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
;
97 int do_debug_cu_index
;
101 bfd_boolean do_checks
;
103 int dwarf_cutoff_level
= -1;
104 unsigned long dwarf_start_die
;
108 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
109 testing whether e.g. a locview list is present. */
110 static const dwarf_vma vm1
= -1;
112 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
113 sections. For version 1 package files, each set is stored in SHNDX_POOL
114 as a zero-terminated list of section indexes comprising one set of debug
115 sections from a .dwo file. */
117 static unsigned int *shndx_pool
= NULL
;
118 static unsigned int shndx_pool_size
= 0;
119 static unsigned int shndx_pool_used
= 0;
121 /* For version 2 package files, each set contains an array of section offsets
122 and an array of section sizes, giving the offset and size of the
123 contribution from a CU or TU within one of the debug sections.
124 When displaying debug info from a package file, we need to use these
125 tables to locate the corresponding contributions to each section. */
130 dwarf_vma section_offsets
[DW_SECT_MAX
];
131 size_t section_sizes
[DW_SECT_MAX
];
134 static int cu_count
= 0;
135 static int tu_count
= 0;
136 static struct cu_tu_set
*cu_sets
= NULL
;
137 static struct cu_tu_set
*tu_sets
= NULL
;
139 static bfd_boolean
load_cu_tu_indexes (void *);
141 /* An array that indicates for a given level of CU nesting whether
142 the latest DW_AT_type seen for that level was a signed type or
144 #define MAX_CU_NESTING (1 << 8)
145 static bfd_boolean level_type_signed
[MAX_CU_NESTING
];
147 /* Values for do_debug_lines. */
148 #define FLAG_DEBUG_LINES_RAW 1
149 #define FLAG_DEBUG_LINES_DECODED 2
152 size_of_encoded_value (int encoding
)
154 switch (encoding
& 0x7)
157 case 0: return eh_addr_size
;
165 get_encoded_value (unsigned char **pdata
,
167 struct dwarf_section
*section
,
170 unsigned char * data
= * pdata
;
171 unsigned int size
= size_of_encoded_value (encoding
);
174 if (data
+ size
>= end
)
176 warn (_("Encoded value extends past end of section\n"));
181 /* PR 17512: file: 002-829853-0.004. */
184 warn (_("Encoded size of %d is too large to read\n"), size
);
189 /* PR 17512: file: 1085-5603-0.004. */
192 warn (_("Encoded size of 0 is too small to read\n"));
197 if (encoding
& DW_EH_PE_signed
)
198 val
= byte_get_signed (data
, size
);
200 val
= byte_get (data
, size
);
202 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
203 val
+= section
->address
+ (data
- section
->start
);
205 * pdata
= data
+ size
;
209 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
211 # define DWARF_VMA_FMT "ll"
212 # define DWARF_VMA_FMT_LONG "%16.16llx"
214 # define DWARF_VMA_FMT "I64"
215 # define DWARF_VMA_FMT_LONG "%016I64x"
218 # define DWARF_VMA_FMT "l"
219 # define DWARF_VMA_FMT_LONG "%16.16lx"
222 /* Convert a dwarf vma value into a string. Returns a pointer to a static
223 buffer containing the converted VALUE. The value is converted according
224 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
225 it specifies the maximum number of bytes to be displayed in the converted
226 value and FMTCH is ignored - hex is always used. */
229 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
231 /* As dwarf_vmatoa is used more then once in a printf call
232 for output, we are cycling through an fixed array of pointers
233 for return address. */
234 static int buf_pos
= 0;
235 static struct dwarf_vmatoa_buf
241 ret
= buf
[buf_pos
++].place
;
242 buf_pos
%= ARRAY_SIZE (buf
);
246 /* Printf does not have a way of specifying a maximum field width for an
247 integer value, so we print the full value into a buffer and then select
248 the precision we need. */
249 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
252 return ret
+ (16 - 2 * num_bytes
);
259 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
261 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
262 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
267 static inline const char *
268 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
270 return dwarf_vmatoa_1 (fmtch
, value
, 0);
273 /* Print a dwarf_vma value (typically an address, offset or length) in
274 hexadecimal format, followed by a space. The length of the VALUE (and
275 hence the precision displayed) is determined by the NUM_BYTES parameter. */
278 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
280 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
283 /* Print a view number in hexadecimal value, with the same width
284 print_dwarf_vma would have printed it with the same num_bytes.
285 Print blanks for zero view, unless force is nonzero. */
288 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
296 assert (value
== (unsigned long) value
);
298 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
300 printf ("%*s", len
+ 1, "");
303 /* Format a 64-bit value, given as two 32-bit values, in hex.
304 For reentrancy, this uses a buffer provided by the caller. */
307 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
308 unsigned int buf_len
)
313 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
316 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
317 snprintf (buf
+ len
, buf_len
- len
,
318 "%08" DWARF_VMA_FMT
"x", lvalue
);
324 /* Read in a LEB128 encoded value starting at address DATA.
325 If SIGN is true, return a signed LEB128 value.
326 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
327 If STATUS_RETURN in not NULL, return with bit 0 (LSB) set if the
328 terminating byte was not found and with bit 1 set if the value
329 overflows a dwarf_vma.
330 No bytes will be read at address END or beyond. */
333 read_leb128 (unsigned char *data
,
334 const unsigned char *const end
,
336 unsigned int *length_return
,
339 dwarf_vma result
= 0;
340 unsigned int num_read
= 0;
341 unsigned int shift
= 0;
346 unsigned char byte
= *data
++;
349 if (shift
< sizeof (result
) * 8)
351 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
352 if ((result
>> shift
) != (byte
& 0x7f))
357 else if ((byte
& 0x7f) != 0)
360 if ((byte
& 0x80) == 0)
363 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
364 result
|= -((dwarf_vma
) 1 << shift
);
369 if (length_return
!= NULL
)
370 *length_return
= num_read
;
371 if (status_return
!= NULL
)
372 *status_return
= status
;
377 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
378 Checks to make sure that the read will not reach or pass END
379 and that VAL is big enough to hold AMOUNT bytes. */
380 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
383 unsigned int amount = (AMOUNT); \
384 if (sizeof (VAL) < amount) \
386 error (ngettext ("internal error: attempt to read %d byte " \
387 "of data in to %d sized variable", \
388 "internal error: attempt to read %d bytes " \
389 "of data in to %d sized variable", \
391 amount, (int) sizeof (VAL)); \
392 amount = sizeof (VAL); \
394 if (((PTR) + amount) >= (END)) \
397 amount = (END) - (PTR); \
401 if (amount == 0 || amount > 8) \
404 VAL = byte_get ((PTR), amount); \
408 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */
409 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
412 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
417 /* Like SAFE_BYTE_GET, but reads a signed value. */
418 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
421 unsigned int amount = (AMOUNT); \
422 if (((PTR) + amount) >= (END)) \
425 amount = (END) - (PTR); \
430 VAL = byte_get_signed ((PTR), amount); \
436 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */
437 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
440 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
445 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
448 if (((PTR) + 8) <= (END)) \
450 byte_get_64 ((PTR), (HIGH), (LOW)); \
454 * (LOW) = * (HIGH) = 0; \
459 typedef struct State_Machine_Registers
468 unsigned char op_index
;
469 unsigned char end_sequence
;
470 /* This variable hold the number of the last entry seen
471 in the File Table. */
472 unsigned int last_file_entry
;
475 static SMR state_machine_regs
;
478 reset_state_machine (int is_stmt
)
480 state_machine_regs
.address
= 0;
481 state_machine_regs
.view
= 0;
482 state_machine_regs
.op_index
= 0;
483 state_machine_regs
.file
= 1;
484 state_machine_regs
.line
= 1;
485 state_machine_regs
.column
= 0;
486 state_machine_regs
.is_stmt
= is_stmt
;
487 state_machine_regs
.basic_block
= 0;
488 state_machine_regs
.end_sequence
= 0;
489 state_machine_regs
.last_file_entry
= 0;
492 /* Handled an extend line op.
493 Returns the number of bytes read. */
496 process_extended_line_op (unsigned char * data
,
500 unsigned char op_code
;
501 size_t len
, header_len
;
503 unsigned char *orig_data
= data
;
506 READ_ULEB (len
, data
, end
);
507 header_len
= data
- orig_data
;
509 if (len
== 0 || data
== end
|| len
> (size_t) (end
- data
))
511 warn (_("Badly formed extended line op encountered!\n"));
517 printf (_(" Extended opcode %d: "), op_code
);
521 case DW_LNE_end_sequence
:
522 printf (_("End of Sequence\n\n"));
523 reset_state_machine (is_stmt
);
526 case DW_LNE_set_address
:
527 /* PR 17512: file: 002-100480-0.004. */
530 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
531 (unsigned long) len
- 1);
535 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
536 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
537 state_machine_regs
.address
= adr
;
538 state_machine_regs
.view
= 0;
539 state_machine_regs
.op_index
= 0;
542 case DW_LNE_define_file
:
543 printf (_("define new File Table entry\n"));
544 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
545 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
551 l
= strnlen ((char *) data
, end
- data
);
553 READ_ULEB (val
, data
, end
);
554 printf ("%s\t", dwarf_vmatoa ("u", val
));
555 READ_ULEB (val
, data
, end
);
556 printf ("%s\t", dwarf_vmatoa ("u", val
));
557 READ_ULEB (val
, data
, end
);
558 printf ("%s\t", dwarf_vmatoa ("u", val
));
559 printf ("%.*s\n\n", (int) l
, name
);
562 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
== end
)
563 warn (_("DW_LNE_define_file: Bad opcode length\n"));
566 case DW_LNE_set_discriminator
:
567 READ_ULEB (val
, data
, end
);
568 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val
));
572 case DW_LNE_HP_negate_is_UV_update
:
573 printf ("DW_LNE_HP_negate_is_UV_update\n");
575 case DW_LNE_HP_push_context
:
576 printf ("DW_LNE_HP_push_context\n");
578 case DW_LNE_HP_pop_context
:
579 printf ("DW_LNE_HP_pop_context\n");
581 case DW_LNE_HP_set_file_line_column
:
582 printf ("DW_LNE_HP_set_file_line_column\n");
584 case DW_LNE_HP_set_routine_name
:
585 printf ("DW_LNE_HP_set_routine_name\n");
587 case DW_LNE_HP_set_sequence
:
588 printf ("DW_LNE_HP_set_sequence\n");
590 case DW_LNE_HP_negate_post_semantics
:
591 printf ("DW_LNE_HP_negate_post_semantics\n");
593 case DW_LNE_HP_negate_function_exit
:
594 printf ("DW_LNE_HP_negate_function_exit\n");
596 case DW_LNE_HP_negate_front_end_logical
:
597 printf ("DW_LNE_HP_negate_front_end_logical\n");
599 case DW_LNE_HP_define_proc
:
600 printf ("DW_LNE_HP_define_proc\n");
602 case DW_LNE_HP_source_file_correlation
:
604 unsigned char *edata
= data
+ len
- 1;
606 printf ("DW_LNE_HP_source_file_correlation\n");
612 READ_ULEB (opc
, data
, edata
);
616 case DW_LNE_HP_SFC_formfeed
:
617 printf (" DW_LNE_HP_SFC_formfeed\n");
619 case DW_LNE_HP_SFC_set_listing_line
:
620 READ_ULEB (val
, data
, edata
);
621 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
622 dwarf_vmatoa ("u", val
));
624 case DW_LNE_HP_SFC_associate
:
625 printf (" DW_LNE_HP_SFC_associate ");
626 READ_ULEB (val
, data
, edata
);
627 printf ("(%s", dwarf_vmatoa ("u", val
));
628 READ_ULEB (val
, data
, edata
);
629 printf (",%s", dwarf_vmatoa ("u", val
));
630 READ_ULEB (val
, data
, edata
);
631 printf (",%s)\n", dwarf_vmatoa ("u", val
));
634 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
644 unsigned int rlen
= len
- 1;
646 if (op_code
>= DW_LNE_lo_user
647 /* The test against DW_LNW_hi_user is redundant due to
648 the limited range of the unsigned char data type used
650 /*&& op_code <= DW_LNE_hi_user*/)
651 printf (_("user defined: "));
653 printf (_("UNKNOWN: "));
654 printf (_("length %d ["), rlen
);
656 printf (" %02x", *data
++);
662 return len
+ header_len
;
665 static const unsigned char *
666 fetch_indirect_string (dwarf_vma offset
)
668 struct dwarf_section
*section
= &debug_displays
[str
].section
;
669 const unsigned char * ret
;
671 if (section
->start
== NULL
)
672 return (const unsigned char *) _("<no .debug_str section>");
674 if (offset
>= section
->size
)
676 warn (_("DW_FORM_strp offset too big: %s\n"),
677 dwarf_vmatoa ("x", offset
));
678 return (const unsigned char *) _("<offset is too big>");
681 ret
= section
->start
+ offset
;
682 /* Unfortunately we cannot rely upon the .debug_str section ending with a
683 NUL byte. Since our caller is expecting to receive a well formed C
684 string we test for the lack of a terminating byte here. */
685 if (strnlen ((const char *) ret
, section
->size
- offset
)
686 == section
->size
- offset
)
687 ret
= (const unsigned char *)
688 _("<no NUL byte at end of .debug_str section>");
693 static const unsigned char *
694 fetch_indirect_line_string (dwarf_vma offset
)
696 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
697 const unsigned char * ret
;
699 if (section
->start
== NULL
)
700 return (const unsigned char *) _("<no .debug_line_str section>");
702 if (offset
>= section
->size
)
704 warn (_("DW_FORM_line_strp offset too big: %s\n"),
705 dwarf_vmatoa ("x", offset
));
706 return (const unsigned char *) _("<offset is too big>");
709 ret
= section
->start
+ offset
;
710 /* Unfortunately we cannot rely upon the .debug_line_str section ending
711 with a NUL byte. Since our caller is expecting to receive a well formed
712 C string we test for the lack of a terminating byte here. */
713 if (strnlen ((const char *) ret
, section
->size
- offset
)
714 == section
->size
- offset
)
715 ret
= (const unsigned char *)
716 _("<no NUL byte at end of .debug_line_str section>");
722 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
723 dwarf_vma offset_size
, bfd_boolean dwo
)
725 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
726 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
727 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
728 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
729 dwarf_vma index_offset
= idx
* offset_size
;
730 dwarf_vma str_offset
;
733 if (index_section
->start
== NULL
)
734 return (dwo
? _("<no .debug_str_offsets.dwo section>")
735 : _("<no .debug_str_offsets section>"));
737 if (this_set
!= NULL
)
738 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
739 if (index_offset
>= index_section
->size
)
741 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
742 dwarf_vmatoa ("x", index_offset
));
743 return _("<index offset is too big>");
746 if (str_section
->start
== NULL
)
747 return (dwo
? _("<no .debug_str.dwo section>")
748 : _("<no .debug_str section>"));
750 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
751 str_offset
-= str_section
->address
;
752 if (str_offset
>= str_section
->size
)
754 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
755 dwarf_vmatoa ("x", str_offset
));
756 return _("<indirect index offset is too big>");
759 ret
= (const char *) str_section
->start
+ str_offset
;
760 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
761 Since our caller is expecting to receive a well formed C string we test
762 for the lack of a terminating byte here. */
763 if (strnlen (ret
, str_section
->size
- str_offset
)
764 == str_section
->size
- str_offset
)
765 ret
= (const char *) _("<no NUL byte at end of section>");
771 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
773 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
775 if (section
->start
== NULL
)
776 return (_("<no .debug_addr section>"));
778 if (offset
+ bytes
> section
->size
)
780 warn (_("Offset into section %s too big: %s\n"),
781 section
->name
, dwarf_vmatoa ("x", offset
));
782 return "<offset too big>";
785 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
789 /* FIXME: There are better and more efficient ways to handle
790 these structures. For now though, I just want something that
791 is simple to implement. */
792 typedef struct abbrev_attr
794 unsigned long attribute
;
796 bfd_signed_vma implicit_const
;
797 struct abbrev_attr
*next
;
801 typedef struct abbrev_entry
806 struct abbrev_attr
*first_attr
;
807 struct abbrev_attr
*last_attr
;
808 struct abbrev_entry
*next
;
812 static abbrev_entry
*first_abbrev
= NULL
;
813 static abbrev_entry
*last_abbrev
= NULL
;
820 for (abbrv
= first_abbrev
; abbrv
;)
822 abbrev_entry
*next_abbrev
= abbrv
->next
;
825 for (attr
= abbrv
->first_attr
; attr
;)
827 abbrev_attr
*next_attr
= attr
->next
;
837 last_abbrev
= first_abbrev
= NULL
;
841 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
845 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
850 entry
->entry
= number
;
852 entry
->children
= children
;
853 entry
->first_attr
= NULL
;
854 entry
->last_attr
= NULL
;
857 if (first_abbrev
== NULL
)
858 first_abbrev
= entry
;
860 last_abbrev
->next
= entry
;
866 add_abbrev_attr (unsigned long attribute
, unsigned long form
,
867 bfd_signed_vma implicit_const
)
871 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
876 attr
->attribute
= attribute
;
878 attr
->implicit_const
= implicit_const
;
881 if (last_abbrev
->first_attr
== NULL
)
882 last_abbrev
->first_attr
= attr
;
884 last_abbrev
->last_attr
->next
= attr
;
886 last_abbrev
->last_attr
= attr
;
889 /* Processes the (partial) contents of a .debug_abbrev section.
890 Returns NULL if the end of the section was encountered.
891 Returns the address after the last byte read if the end of
892 an abbreviation set was found. */
894 static unsigned char *
895 process_abbrev_section (unsigned char *start
, unsigned char *end
)
897 if (first_abbrev
!= NULL
)
904 unsigned long attribute
;
907 READ_ULEB (entry
, start
, end
);
909 /* A single zero is supposed to end the section according
910 to the standard. If there's more, then signal that to
917 READ_ULEB (tag
, start
, end
);
923 add_abbrev (entry
, tag
, children
);
928 /* Initialize it due to a false compiler warning. */
929 bfd_signed_vma implicit_const
= -1;
931 READ_ULEB (attribute
, start
, end
);
935 READ_ULEB (form
, start
, end
);
939 if (form
== DW_FORM_implicit_const
)
941 READ_SLEB (implicit_const
, start
, end
);
946 add_abbrev_attr (attribute
, form
, implicit_const
);
948 while (attribute
!= 0);
951 /* Report the missing single zero which ends the section. */
952 error (_(".debug_abbrev section not zero terminated\n"));
958 get_TAG_name (unsigned long tag
)
960 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
964 static char buffer
[100];
966 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
967 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
969 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
977 get_FORM_name (unsigned long form
)
982 return "DW_FORM value: 0";
984 name
= get_DW_FORM_name (form
);
987 static char buffer
[100];
989 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
997 get_IDX_name (unsigned long idx
)
999 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1003 static char buffer
[100];
1005 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1012 static unsigned char *
1013 display_block (unsigned char *data
,
1015 const unsigned char * const end
, char delimiter
)
1019 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1021 return (unsigned char *) end
;
1023 maxlen
= (dwarf_vma
) (end
- data
);
1024 length
= length
> maxlen
? maxlen
: length
;
1027 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1033 decode_location_expression (unsigned char * data
,
1034 unsigned int pointer_size
,
1035 unsigned int offset_size
,
1038 dwarf_vma cu_offset
,
1039 struct dwarf_section
* section
)
1043 dwarf_signed_vma svalue
;
1044 unsigned char *end
= data
+ length
;
1045 int need_frame_base
= 0;
1054 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1055 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1058 printf ("DW_OP_deref");
1061 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1062 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1065 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1066 printf ("DW_OP_const1s: %ld", (long) svalue
);
1069 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1070 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1073 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1074 printf ("DW_OP_const2s: %ld", (long) svalue
);
1077 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1078 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1081 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1082 printf ("DW_OP_const4s: %ld", (long) svalue
);
1085 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1086 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1087 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1088 printf ("%lu", (unsigned long) uvalue
);
1091 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1092 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1093 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1094 printf ("%ld", (long) svalue
);
1097 READ_ULEB (uvalue
, data
, end
);
1098 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue
));
1101 READ_SLEB (svalue
, data
, end
);
1102 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue
));
1105 printf ("DW_OP_dup");
1108 printf ("DW_OP_drop");
1111 printf ("DW_OP_over");
1114 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1115 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1118 printf ("DW_OP_swap");
1121 printf ("DW_OP_rot");
1124 printf ("DW_OP_xderef");
1127 printf ("DW_OP_abs");
1130 printf ("DW_OP_and");
1133 printf ("DW_OP_div");
1136 printf ("DW_OP_minus");
1139 printf ("DW_OP_mod");
1142 printf ("DW_OP_mul");
1145 printf ("DW_OP_neg");
1148 printf ("DW_OP_not");
1151 printf ("DW_OP_or");
1154 printf ("DW_OP_plus");
1156 case DW_OP_plus_uconst
:
1157 READ_ULEB (uvalue
, data
, end
);
1158 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue
));
1161 printf ("DW_OP_shl");
1164 printf ("DW_OP_shr");
1167 printf ("DW_OP_shra");
1170 printf ("DW_OP_xor");
1173 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1174 printf ("DW_OP_bra: %ld", (long) svalue
);
1177 printf ("DW_OP_eq");
1180 printf ("DW_OP_ge");
1183 printf ("DW_OP_gt");
1186 printf ("DW_OP_le");
1189 printf ("DW_OP_lt");
1192 printf ("DW_OP_ne");
1195 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1196 printf ("DW_OP_skip: %ld", (long) svalue
);
1231 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1266 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1267 regname (op
- DW_OP_reg0
, 1));
1302 READ_SLEB (svalue
, data
, end
);
1303 printf ("DW_OP_breg%d (%s): %s", op
- DW_OP_breg0
,
1304 regname (op
- DW_OP_breg0
, 1), dwarf_vmatoa ("d", svalue
));
1308 READ_ULEB (uvalue
, data
, end
);
1309 printf ("DW_OP_regx: %s (%s)",
1310 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1313 need_frame_base
= 1;
1314 READ_SLEB (svalue
, data
, end
);
1315 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue
));
1318 READ_ULEB (uvalue
, data
, end
);
1319 READ_SLEB (svalue
, data
, end
);
1320 printf ("DW_OP_bregx: %s (%s) %s",
1321 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1322 dwarf_vmatoa ("d", svalue
));
1325 READ_ULEB (uvalue
, data
, end
);
1326 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue
));
1328 case DW_OP_deref_size
:
1329 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1330 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1332 case DW_OP_xderef_size
:
1333 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1334 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1337 printf ("DW_OP_nop");
1340 /* DWARF 3 extensions. */
1341 case DW_OP_push_object_address
:
1342 printf ("DW_OP_push_object_address");
1345 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1346 this ought to be an 8-byte wide computation. */
1347 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1348 printf ("DW_OP_call2: <0x%s>",
1349 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1352 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1353 this ought to be an 8-byte wide computation. */
1354 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1355 printf ("DW_OP_call4: <0x%s>",
1356 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1358 case DW_OP_call_ref
:
1359 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1360 this ought to be an 8-byte wide computation. */
1361 if (dwarf_version
== -1)
1363 printf (_("(DW_OP_call_ref in frame info)"));
1364 /* No way to tell where the next op is, so just bail. */
1365 return need_frame_base
;
1367 if (dwarf_version
== 2)
1369 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1373 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1375 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1377 case DW_OP_form_tls_address
:
1378 printf ("DW_OP_form_tls_address");
1380 case DW_OP_call_frame_cfa
:
1381 printf ("DW_OP_call_frame_cfa");
1383 case DW_OP_bit_piece
:
1384 printf ("DW_OP_bit_piece: ");
1385 READ_ULEB (uvalue
, data
, end
);
1386 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue
));
1387 READ_ULEB (uvalue
, data
, end
);
1388 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue
));
1391 /* DWARF 4 extensions. */
1392 case DW_OP_stack_value
:
1393 printf ("DW_OP_stack_value");
1396 case DW_OP_implicit_value
:
1397 printf ("DW_OP_implicit_value");
1398 READ_ULEB (uvalue
, data
, end
);
1399 data
= display_block (data
, uvalue
, end
, ' ');
1402 /* GNU extensions. */
1403 case DW_OP_GNU_push_tls_address
:
1404 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1406 case DW_OP_GNU_uninit
:
1407 printf ("DW_OP_GNU_uninit");
1408 /* FIXME: Is there data associated with this OP ? */
1410 case DW_OP_GNU_encoded_addr
:
1417 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1419 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1420 print_dwarf_vma (addr
, pointer_size
);
1423 case DW_OP_implicit_pointer
:
1424 case DW_OP_GNU_implicit_pointer
:
1425 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1426 this ought to be an 8-byte wide computation. */
1427 if (dwarf_version
== -1)
1429 printf (_("(%s in frame info)"),
1430 (op
== DW_OP_implicit_pointer
1431 ? "DW_OP_implicit_pointer"
1432 : "DW_OP_GNU_implicit_pointer"));
1433 /* No way to tell where the next op is, so just bail. */
1434 return need_frame_base
;
1436 if (dwarf_version
== 2)
1438 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1442 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1444 READ_SLEB (svalue
, data
, end
);
1445 printf ("%s: <0x%s> %s",
1446 (op
== DW_OP_implicit_pointer
1447 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1448 dwarf_vmatoa ("x", uvalue
),
1449 dwarf_vmatoa ("d", svalue
));
1451 case DW_OP_entry_value
:
1452 case DW_OP_GNU_entry_value
:
1453 READ_ULEB (uvalue
, data
, end
);
1454 /* PR 17531: file: 0cc9cd00. */
1455 if (uvalue
> (dwarf_vma
) (end
- data
))
1456 uvalue
= end
- data
;
1457 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1458 : "DW_OP_GNU_entry_value"));
1459 if (decode_location_expression (data
, pointer_size
, offset_size
,
1460 dwarf_version
, uvalue
,
1461 cu_offset
, section
))
1462 need_frame_base
= 1;
1468 case DW_OP_const_type
:
1469 case DW_OP_GNU_const_type
:
1470 READ_ULEB (uvalue
, data
, end
);
1471 printf ("%s: <0x%s> ",
1472 (op
== DW_OP_const_type
? "DW_OP_const_type"
1473 : "DW_OP_GNU_const_type"),
1474 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1475 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1476 data
= display_block (data
, uvalue
, end
, ' ');
1478 case DW_OP_regval_type
:
1479 case DW_OP_GNU_regval_type
:
1480 READ_ULEB (uvalue
, data
, end
);
1481 printf ("%s: %s (%s)",
1482 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1483 : "DW_OP_GNU_regval_type"),
1484 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1485 READ_ULEB (uvalue
, data
, end
);
1486 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1488 case DW_OP_deref_type
:
1489 case DW_OP_GNU_deref_type
:
1490 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1492 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1493 : "DW_OP_GNU_deref_type"),
1495 READ_ULEB (uvalue
, data
, end
);
1496 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1499 case DW_OP_GNU_convert
:
1500 READ_ULEB (uvalue
, data
, end
);
1501 printf ("%s <0x%s>",
1502 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1503 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1505 case DW_OP_reinterpret
:
1506 case DW_OP_GNU_reinterpret
:
1507 READ_ULEB (uvalue
, data
, end
);
1508 printf ("%s <0x%s>",
1509 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1510 : "DW_OP_GNU_reinterpret"),
1511 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1513 case DW_OP_GNU_parameter_ref
:
1514 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1515 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1516 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1518 case DW_OP_GNU_addr_index
:
1519 READ_ULEB (uvalue
, data
, end
);
1520 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1522 case DW_OP_GNU_const_index
:
1523 READ_ULEB (uvalue
, data
, end
);
1524 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1526 case DW_OP_GNU_variable_value
:
1527 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1528 this ought to be an 8-byte wide computation. */
1529 if (dwarf_version
== -1)
1531 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1532 /* No way to tell where the next op is, so just bail. */
1533 return need_frame_base
;
1535 if (dwarf_version
== 2)
1537 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1541 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1543 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1546 /* HP extensions. */
1547 case DW_OP_HP_is_value
:
1548 printf ("DW_OP_HP_is_value");
1549 /* FIXME: Is there data associated with this OP ? */
1551 case DW_OP_HP_fltconst4
:
1552 printf ("DW_OP_HP_fltconst4");
1553 /* FIXME: Is there data associated with this OP ? */
1555 case DW_OP_HP_fltconst8
:
1556 printf ("DW_OP_HP_fltconst8");
1557 /* FIXME: Is there data associated with this OP ? */
1559 case DW_OP_HP_mod_range
:
1560 printf ("DW_OP_HP_mod_range");
1561 /* FIXME: Is there data associated with this OP ? */
1563 case DW_OP_HP_unmod_range
:
1564 printf ("DW_OP_HP_unmod_range");
1565 /* FIXME: Is there data associated with this OP ? */
1568 printf ("DW_OP_HP_tls");
1569 /* FIXME: Is there data associated with this OP ? */
1572 /* PGI (STMicroelectronics) extensions. */
1573 case DW_OP_PGI_omp_thread_num
:
1574 /* Pushes the thread number for the current thread as it would be
1575 returned by the standard OpenMP library function:
1576 omp_get_thread_num(). The "current thread" is the thread for
1577 which the expression is being evaluated. */
1578 printf ("DW_OP_PGI_omp_thread_num");
1582 if (op
>= DW_OP_lo_user
1583 && op
<= DW_OP_hi_user
)
1584 printf (_("(User defined location op 0x%x)"), op
);
1586 printf (_("(Unknown location op 0x%x)"), op
);
1587 /* No way to tell where the next op is, so just bail. */
1588 return need_frame_base
;
1591 /* Separate the ops. */
1596 return need_frame_base
;
1599 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1600 This is used for DWARF package files. */
1602 static struct cu_tu_set
*
1603 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1605 struct cu_tu_set
*p
;
1607 unsigned int dw_sect
;
1613 dw_sect
= DW_SECT_TYPES
;
1619 dw_sect
= DW_SECT_INFO
;
1623 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1631 /* Add INC to HIGH_BITS:LOW_BITS. */
1633 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1635 dwarf_vma tmp
= * low_bits
;
1639 /* FIXME: There is probably a better way of handling this:
1641 We need to cope with dwarf_vma being a 32-bit or 64-bit
1642 type. Plus regardless of its size LOW_BITS is meant to
1643 only hold 32-bits, so if there is overflow or wrap around
1644 we must propagate into HIGH_BITS. */
1645 if (tmp
< * low_bits
)
1649 else if (sizeof (tmp
) > 8
1660 fetch_alt_indirect_string (dwarf_vma offset
)
1664 if (! do_follow_links
)
1667 if (first_separate_info
== NULL
)
1668 return _("<no links available>");
1670 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1672 struct dwarf_section
* section
;
1675 if (! load_debug_section (separate_debug_str
, i
->handle
))
1678 section
= &debug_displays
[separate_debug_str
].section
;
1680 if (section
->start
== NULL
)
1683 if (offset
>= section
->size
)
1686 ret
= (const char *) (section
->start
+ offset
);
1687 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1688 NUL byte. Since our caller is expecting to receive a well formed C
1689 string we test for the lack of a terminating byte here. */
1690 if (strnlen ((const char *) ret
, section
->size
- offset
)
1691 == section
->size
- offset
)
1692 return _("<no NUL byte at end of alt .debug_str section>");
1697 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1698 dwarf_vmatoa ("x", offset
));
1699 return _("<offset is too big>");
1703 get_AT_name (unsigned long attribute
)
1708 return "DW_AT value: 0";
1710 /* One value is shared by the MIPS and HP extensions: */
1711 if (attribute
== DW_AT_MIPS_fde
)
1712 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1714 name
= get_DW_AT_name (attribute
);
1718 static char buffer
[100];
1720 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1729 add_dwo_info (const char * field
, dwo_type type
)
1731 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1733 dwinfo
->type
= type
;
1734 dwinfo
->value
= field
;
1735 dwinfo
->next
= first_dwo_info
;
1736 first_dwo_info
= dwinfo
;
1740 add_dwo_name (const char * name
)
1742 add_dwo_info (name
, DWO_NAME
);
1746 add_dwo_dir (const char * dir
)
1748 add_dwo_info (dir
, DWO_DIR
);
1752 add_dwo_id (const char * id
)
1754 add_dwo_info (id
, DWO_ID
);
1758 free_dwo_info (void)
1763 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1765 next
= dwinfo
->next
;
1768 first_dwo_info
= NULL
;
1771 /* Ensure that START + UVALUE is less than END.
1772 Return an adjusted UVALUE if necessary to ensure this relationship. */
1774 static inline dwarf_vma
1775 check_uvalue (const unsigned char * start
,
1777 const unsigned char * end
)
1779 dwarf_vma max_uvalue
= end
- start
;
1781 /* See PR 17512: file: 008-103549-0.001:0.1.
1782 and PR 24829 for examples of where these tests are triggered. */
1783 if (uvalue
> max_uvalue
)
1785 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1786 uvalue
= max_uvalue
;
1792 static unsigned char *
1793 skip_attr_bytes (unsigned long form
,
1794 unsigned char * data
,
1795 unsigned const char * end
,
1796 dwarf_vma pointer_size
,
1797 dwarf_vma offset_size
,
1799 dwarf_vma
* value_return
)
1801 dwarf_signed_vma svalue
;
1802 dwarf_vma uvalue
= 0;
1808 case DW_FORM_ref_addr
:
1809 if (dwarf_version
== 2)
1810 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1811 else if (dwarf_version
== 3 || dwarf_version
== 4)
1812 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1818 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1822 case DW_FORM_line_strp
:
1823 case DW_FORM_sec_offset
:
1824 case DW_FORM_GNU_ref_alt
:
1825 case DW_FORM_GNU_strp_alt
:
1826 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1829 case DW_FORM_flag_present
:
1836 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1841 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1846 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1850 READ_SLEB (svalue
, data
, end
);
1854 case DW_FORM_ref_udata
:
1856 case DW_FORM_GNU_str_index
:
1857 case DW_FORM_GNU_addr_index
:
1858 READ_ULEB (uvalue
, data
, end
);
1866 case DW_FORM_data16
:
1870 case DW_FORM_string
:
1871 data
+= strnlen ((char *) data
, end
- data
) + 1;
1875 case DW_FORM_exprloc
:
1876 READ_ULEB (uvalue
, data
, end
);
1879 case DW_FORM_block1
:
1880 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1884 case DW_FORM_block2
:
1885 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1889 case DW_FORM_block4
:
1890 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1894 case DW_FORM_ref_sig8
:
1898 case DW_FORM_indirect
:
1899 /* FIXME: Handle this form. */
1904 * value_return
= uvalue
;
1906 data
= (unsigned char *) end
;
1910 /* Return IS_SIGNED set to TRUE if the type at
1911 DATA can be determined to be a signed type. */
1914 get_type_signedness (unsigned char * start
,
1915 unsigned char * data
,
1916 unsigned const char * end
,
1917 dwarf_vma pointer_size
,
1918 dwarf_vma offset_size
,
1920 bfd_boolean
* is_signed
,
1921 bfd_boolean is_nested
)
1923 unsigned long abbrev_number
;
1924 abbrev_entry
* entry
;
1927 * is_signed
= FALSE
;
1929 READ_ULEB (abbrev_number
, data
, end
);
1931 for (entry
= first_abbrev
;
1932 entry
!= NULL
&& entry
->entry
!= abbrev_number
;
1933 entry
= entry
->next
)
1937 /* FIXME: Issue a warning ? */
1940 for (attr
= entry
->first_attr
;
1941 attr
!= NULL
&& attr
->attribute
;
1944 dwarf_vma uvalue
= 0;
1946 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
1947 offset_size
, dwarf_version
, & uvalue
);
1951 switch (attr
->attribute
)
1953 #if 0 /* FIXME: It would be nice to print the name of the type,
1954 but this would mean updating a lot of binutils tests. */
1956 if (attr
->form
== DW_FORM_strp
)
1957 printf ("%s", fetch_indirect_string (uvalue
));
1964 /* FIXME: Warn - or is this expected ?
1965 NB/ We need to avoid infinite recursion. */
1968 if (uvalue
>= (size_t) (end
- start
))
1970 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
1971 offset_size
, dwarf_version
, is_signed
, TRUE
);
1974 case DW_AT_encoding
:
1975 /* Determine signness. */
1978 case DW_ATE_address
:
1979 /* FIXME - some architectures have signed addresses. */
1980 case DW_ATE_boolean
:
1981 case DW_ATE_unsigned
:
1982 case DW_ATE_unsigned_char
:
1983 case DW_ATE_unsigned_fixed
:
1984 * is_signed
= FALSE
;
1988 case DW_ATE_complex_float
:
1991 case DW_ATE_signed_char
:
1992 case DW_ATE_imaginary_float
:
1993 case DW_ATE_decimal_float
:
1994 case DW_ATE_signed_fixed
:
2004 read_and_print_leb128 (unsigned char * data
,
2005 unsigned int * bytes_read
,
2006 unsigned const char * end
,
2007 bfd_boolean is_signed
)
2010 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2012 report_leb_status (status
, __FILE__
, __LINE__
);
2014 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2018 display_discr_list (unsigned long form
,
2020 unsigned char * data
,
2021 unsigned const char * end
,
2026 printf ("[default]");
2033 case DW_FORM_block1
:
2034 case DW_FORM_block2
:
2035 case DW_FORM_block4
:
2036 /* Move data pointer back to the start of the byte array. */
2040 printf ("<corrupt>\n");
2041 warn (_("corrupt discr_list - not using a block form\n"));
2047 printf ("<corrupt>\n");
2048 warn (_("corrupt discr_list - block not long enough\n"));
2052 bfd_boolean is_signed
=
2053 (level
> 0 && level
<= MAX_CU_NESTING
)
2054 ? level_type_signed
[level
- 1] : FALSE
;
2059 unsigned char discriminant
;
2060 unsigned int bytes_read
;
2062 SAFE_BYTE_GET (discriminant
, data
, 1, end
);
2066 assert (uvalue
> 0);
2067 switch (discriminant
)
2071 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2072 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2073 uvalue
-= bytes_read
;
2079 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2080 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2081 uvalue
-= bytes_read
;
2085 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2086 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2087 uvalue
-= bytes_read
;
2092 printf ("<corrupt>\n");
2093 warn (_("corrupt discr_list - unrecognised discriminant byte %#x\n"),
2103 printf (")(signed)");
2105 printf (")(unsigned)");
2108 static unsigned char *
2109 read_and_display_attr_value (unsigned long attribute
,
2111 dwarf_signed_vma implicit_const
,
2112 unsigned char * start
,
2113 unsigned char * data
,
2114 unsigned char * end
,
2115 dwarf_vma cu_offset
,
2116 dwarf_vma pointer_size
,
2117 dwarf_vma offset_size
,
2119 debug_info
* debug_info_p
,
2121 struct dwarf_section
* section
,
2122 struct cu_tu_set
* this_set
,
2126 dwarf_signed_vma svalue
;
2127 dwarf_vma uvalue
= 0;
2128 unsigned char * block_start
= NULL
;
2129 unsigned char * orig_data
= data
;
2131 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2133 warn (_("Corrupt attribute\n"));
2142 case DW_FORM_ref_addr
:
2143 if (dwarf_version
== 2)
2144 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2145 else if (dwarf_version
== 3 || dwarf_version
== 4)
2146 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2148 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
2153 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2157 case DW_FORM_line_strp
:
2158 case DW_FORM_sec_offset
:
2159 case DW_FORM_GNU_ref_alt
:
2160 case DW_FORM_GNU_strp_alt
:
2161 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2164 case DW_FORM_flag_present
:
2171 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2176 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2181 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2185 READ_SLEB (svalue
, data
, end
);
2189 case DW_FORM_GNU_str_index
:
2190 case DW_FORM_ref_udata
:
2192 case DW_FORM_GNU_addr_index
:
2193 READ_ULEB (uvalue
, data
, end
);
2196 case DW_FORM_indirect
:
2197 READ_ULEB (form
, data
, end
);
2199 printf ("%c%s", delimiter
, get_FORM_name (form
));
2200 if (form
== DW_FORM_implicit_const
)
2201 READ_SLEB (implicit_const
, data
, end
);
2202 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2204 cu_offset
, pointer_size
,
2205 offset_size
, dwarf_version
,
2206 debug_info_p
, do_loc
,
2207 section
, this_set
, delimiter
, level
);
2212 case DW_FORM_ref_addr
:
2214 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2217 case DW_FORM_GNU_ref_alt
:
2219 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2220 /* FIXME: Follow the reference... */
2226 case DW_FORM_ref_udata
:
2228 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2233 case DW_FORM_sec_offset
:
2235 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2238 case DW_FORM_flag_present
:
2245 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2248 case DW_FORM_implicit_const
:
2250 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2257 dwarf_vma high_bits
;
2261 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2263 if (form
== DW_FORM_ref8
)
2264 add64 (& high_bits
, & utmp
, cu_offset
);
2265 printf ("%c0x%s", delimiter
,
2266 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
2269 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2270 && num_debug_info_entries
== 0)
2272 if (sizeof (uvalue
) == 8)
2273 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
2275 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
2281 case DW_FORM_data16
:
2284 dwarf_vma left_high_bits
, left_low_bits
;
2285 dwarf_vma right_high_bits
, right_low_bits
;
2287 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
2288 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
2289 if (byte_get
== byte_get_little_endian
)
2292 left_high_bits
^= right_high_bits
;
2293 right_high_bits
^= left_high_bits
;
2294 left_high_bits
^= right_high_bits
;
2295 left_low_bits
^= right_low_bits
;
2296 right_low_bits
^= left_low_bits
;
2297 left_low_bits
^= right_low_bits
;
2299 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
2300 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
2301 left_high_bits
, left_low_bits
, right_high_bits
,
2307 case DW_FORM_string
:
2309 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2310 data
+= strnlen ((char *) data
, end
- data
) + 1;
2314 case DW_FORM_exprloc
:
2315 READ_ULEB (uvalue
, data
, end
);
2318 if (block_start
>= end
)
2320 warn (_("Block ends prematurely\n"));
2325 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2328 data
= block_start
+ uvalue
;
2330 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2333 case DW_FORM_block1
:
2334 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2337 case DW_FORM_block2
:
2338 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2341 case DW_FORM_block4
:
2342 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2347 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2348 dwarf_vmatoa ("x", uvalue
),
2349 fetch_indirect_string (uvalue
));
2352 case DW_FORM_line_strp
:
2354 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2355 dwarf_vmatoa ("x", uvalue
),
2356 fetch_indirect_line_string (uvalue
));
2359 case DW_FORM_GNU_str_index
:
2362 const char * suffix
= strrchr (section
->name
, '.');
2363 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
2365 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2366 dwarf_vmatoa ("x", uvalue
),
2367 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2371 case DW_FORM_GNU_strp_alt
:
2374 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2375 dwarf_vmatoa ("x", uvalue
),
2376 fetch_alt_indirect_string (uvalue
));
2380 case DW_FORM_indirect
:
2381 /* Handled above. */
2384 case DW_FORM_ref_sig8
:
2387 dwarf_vma high_bits
;
2390 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2391 printf ("%csignature: 0x%s", delimiter
,
2392 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2397 case DW_FORM_GNU_addr_index
:
2399 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2400 dwarf_vmatoa ("x", uvalue
),
2401 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2405 warn (_("Unrecognized form: %lu\n"), form
);
2409 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2410 && num_debug_info_entries
== 0
2411 && debug_info_p
!= NULL
)
2415 case DW_AT_frame_base
:
2416 have_frame_base
= 1;
2418 case DW_AT_location
:
2419 case DW_AT_GNU_locviews
:
2420 case DW_AT_string_length
:
2421 case DW_AT_return_addr
:
2422 case DW_AT_data_member_location
:
2423 case DW_AT_vtable_elem_location
:
2425 case DW_AT_static_link
:
2426 case DW_AT_use_location
:
2427 case DW_AT_call_value
:
2428 case DW_AT_GNU_call_site_value
:
2429 case DW_AT_call_data_value
:
2430 case DW_AT_GNU_call_site_data_value
:
2431 case DW_AT_call_target
:
2432 case DW_AT_GNU_call_site_target
:
2433 case DW_AT_call_target_clobbered
:
2434 case DW_AT_GNU_call_site_target_clobbered
:
2435 if ((dwarf_version
< 4
2436 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2437 || form
== DW_FORM_sec_offset
)
2439 /* Process location list. */
2440 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2441 unsigned int num
= debug_info_p
->num_loc_offsets
;
2443 if (lmax
== 0 || num
>= lmax
)
2446 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2447 xcrealloc (debug_info_p
->loc_offsets
,
2448 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2449 debug_info_p
->loc_views
= (dwarf_vma
*)
2450 xcrealloc (debug_info_p
->loc_views
,
2451 lmax
, sizeof (*debug_info_p
->loc_views
));
2452 debug_info_p
->have_frame_base
= (int *)
2453 xcrealloc (debug_info_p
->have_frame_base
,
2454 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2455 debug_info_p
->max_loc_offsets
= lmax
;
2457 if (this_set
!= NULL
)
2458 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2459 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2460 if (attribute
!= DW_AT_GNU_locviews
)
2462 /* Corrupt DWARF info can produce more offsets than views.
2463 See PR 23062 for an example. */
2464 if (debug_info_p
->num_loc_offsets
2465 > debug_info_p
->num_loc_views
)
2466 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2469 debug_info_p
->loc_offsets
[num
] = uvalue
;
2470 debug_info_p
->num_loc_offsets
++;
2475 assert (debug_info_p
->num_loc_views
<= num
);
2476 num
= debug_info_p
->num_loc_views
;
2477 if (num
> debug_info_p
->num_loc_offsets
)
2478 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2481 debug_info_p
->loc_views
[num
] = uvalue
;
2482 debug_info_p
->num_loc_views
++;
2489 if (need_base_address
)
2490 debug_info_p
->base_address
= uvalue
;
2493 case DW_AT_GNU_addr_base
:
2494 debug_info_p
->addr_base
= uvalue
;
2497 case DW_AT_GNU_ranges_base
:
2498 debug_info_p
->ranges_base
= uvalue
;
2502 if ((dwarf_version
< 4
2503 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2504 || form
== DW_FORM_sec_offset
)
2506 /* Process range list. */
2507 unsigned int lmax
= debug_info_p
->max_range_lists
;
2508 unsigned int num
= debug_info_p
->num_range_lists
;
2510 if (lmax
== 0 || num
>= lmax
)
2513 debug_info_p
->range_lists
= (dwarf_vma
*)
2514 xcrealloc (debug_info_p
->range_lists
,
2515 lmax
, sizeof (*debug_info_p
->range_lists
));
2516 debug_info_p
->max_range_lists
= lmax
;
2518 debug_info_p
->range_lists
[num
] = uvalue
;
2519 debug_info_p
->num_range_lists
++;
2523 case DW_AT_GNU_dwo_name
:
2524 case DW_AT_dwo_name
:
2529 add_dwo_name ((const char *) fetch_indirect_string (uvalue
));
2531 case DW_FORM_GNU_str_index
:
2532 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2534 case DW_FORM_string
:
2535 add_dwo_name ((const char *) orig_data
);
2538 warn (_("Unsupported form (%s) for attribute %s\n"),
2539 get_FORM_name (form
), get_AT_name (attribute
));
2544 case DW_AT_comp_dir
:
2545 /* FIXME: Also extract a build-id in a CU/TU. */
2550 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
));
2552 case DW_FORM_line_strp
:
2553 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
));
2555 case DW_FORM_GNU_str_index
:
2556 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2558 case DW_FORM_string
:
2559 add_dwo_dir ((const char *) orig_data
);
2562 warn (_("Unsupported form (%s) for attribute %s\n"),
2563 get_FORM_name (form
), get_AT_name (attribute
));
2568 case DW_AT_GNU_dwo_id
:
2573 /* FIXME: Record the length of the ID as well ? */
2574 add_dwo_id ((const char *) (data
- 8));
2577 warn (_("Unsupported form (%s) for attribute %s\n"),
2578 get_FORM_name (form
), get_AT_name (attribute
));
2588 if (do_loc
|| attribute
== 0)
2591 /* For some attributes we can display further information. */
2595 if (level
>= 0 && level
< MAX_CU_NESTING
2596 && uvalue
< (size_t) (end
- start
))
2598 bfd_boolean is_signed
= FALSE
;
2600 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
2601 offset_size
, dwarf_version
, & is_signed
, FALSE
);
2602 level_type_signed
[level
] = is_signed
;
2610 case DW_INL_not_inlined
:
2611 printf (_("(not inlined)"));
2613 case DW_INL_inlined
:
2614 printf (_("(inlined)"));
2616 case DW_INL_declared_not_inlined
:
2617 printf (_("(declared as inline but ignored)"));
2619 case DW_INL_declared_inlined
:
2620 printf (_("(declared as inline and inlined)"));
2623 printf (_(" (Unknown inline attribute value: %s)"),
2624 dwarf_vmatoa ("x", uvalue
));
2629 case DW_AT_language
:
2633 /* Ordered by the numeric value of these constants. */
2634 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2635 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2636 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2637 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2638 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2639 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2640 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2641 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2642 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2643 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2644 /* DWARF 2.1 values. */
2645 case DW_LANG_Java
: printf ("(Java)"); break;
2646 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2647 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2648 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2649 /* DWARF 3 values. */
2650 case DW_LANG_PLI
: printf ("(PLI)"); break;
2651 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2652 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2653 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2654 case DW_LANG_D
: printf ("(D)"); break;
2655 /* DWARF 4 values. */
2656 case DW_LANG_Python
: printf ("(Python)"); break;
2657 /* DWARF 5 values. */
2658 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
2659 case DW_LANG_Go
: printf ("(Go)"); break;
2660 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
2661 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
2662 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
2663 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2664 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
2665 case DW_LANG_Rust
: printf ("(Rust)"); break;
2666 case DW_LANG_C11
: printf ("(C11)"); break;
2667 case DW_LANG_Swift
: printf ("(Swift)"); break;
2668 case DW_LANG_Julia
: printf ("(Julia)"); break;
2669 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
2670 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2671 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2672 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2673 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
2674 /* MIPS extension. */
2675 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2676 /* UPC extension. */
2677 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2679 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2680 printf (_("(implementation defined: %s)"),
2681 dwarf_vmatoa ("x", uvalue
));
2683 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2688 case DW_AT_encoding
:
2692 case DW_ATE_void
: printf ("(void)"); break;
2693 case DW_ATE_address
: printf ("(machine address)"); break;
2694 case DW_ATE_boolean
: printf ("(boolean)"); break;
2695 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2696 case DW_ATE_float
: printf ("(float)"); break;
2697 case DW_ATE_signed
: printf ("(signed)"); break;
2698 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2699 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2700 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2701 /* DWARF 2.1 values: */
2702 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2703 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2704 /* DWARF 3 values: */
2705 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2706 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2707 case DW_ATE_edited
: printf ("(edited)"); break;
2708 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2709 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2710 /* DWARF 4 values: */
2711 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2712 /* DWARF 5 values: */
2713 case DW_ATE_UCS
: printf ("(UCS)"); break;
2714 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2716 /* HP extensions: */
2717 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2718 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2719 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2720 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2721 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2722 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2723 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2726 if (uvalue
>= DW_ATE_lo_user
2727 && uvalue
<= DW_ATE_hi_user
)
2728 printf (_("(user defined type)"));
2730 printf (_("(unknown type)"));
2735 case DW_AT_accessibility
:
2739 case DW_ACCESS_public
: printf ("(public)"); break;
2740 case DW_ACCESS_protected
: printf ("(protected)"); break;
2741 case DW_ACCESS_private
: printf ("(private)"); break;
2743 printf (_("(unknown accessibility)"));
2748 case DW_AT_visibility
:
2752 case DW_VIS_local
: printf ("(local)"); break;
2753 case DW_VIS_exported
: printf ("(exported)"); break;
2754 case DW_VIS_qualified
: printf ("(qualified)"); break;
2755 default: printf (_("(unknown visibility)")); break;
2759 case DW_AT_endianity
:
2763 case DW_END_default
: printf ("(default)"); break;
2764 case DW_END_big
: printf ("(big)"); break;
2765 case DW_END_little
: printf ("(little)"); break;
2767 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2768 printf (_("(user specified)"));
2770 printf (_("(unknown endianity)"));
2775 case DW_AT_virtuality
:
2779 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2780 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2781 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2782 default: printf (_("(unknown virtuality)")); break;
2786 case DW_AT_identifier_case
:
2790 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2791 case DW_ID_up_case
: printf ("(up_case)"); break;
2792 case DW_ID_down_case
: printf ("(down_case)"); break;
2793 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2794 default: printf (_("(unknown case)")); break;
2798 case DW_AT_calling_convention
:
2802 case DW_CC_normal
: printf ("(normal)"); break;
2803 case DW_CC_program
: printf ("(program)"); break;
2804 case DW_CC_nocall
: printf ("(nocall)"); break;
2805 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2806 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2807 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2808 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2810 if (uvalue
>= DW_CC_lo_user
2811 && uvalue
<= DW_CC_hi_user
)
2812 printf (_("(user defined)"));
2814 printf (_("(unknown convention)"));
2818 case DW_AT_ordering
:
2823 case -1: printf (_("(undefined)")); break;
2824 case 0: printf ("(row major)"); break;
2825 case 1: printf ("(column major)"); break;
2829 case DW_AT_decimal_sign
:
2833 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2834 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2835 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2836 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2837 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2838 default: printf (_("(unrecognised)")); break;
2842 case DW_AT_defaulted
:
2846 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2847 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2848 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2849 default: printf (_("(unrecognised)")); break;
2853 case DW_AT_discr_list
:
2855 display_discr_list (form
, uvalue
, data
, end
, level
);
2858 case DW_AT_frame_base
:
2859 have_frame_base
= 1;
2861 case DW_AT_location
:
2862 case DW_AT_string_length
:
2863 case DW_AT_return_addr
:
2864 case DW_AT_data_member_location
:
2865 case DW_AT_vtable_elem_location
:
2867 case DW_AT_static_link
:
2868 case DW_AT_use_location
:
2869 case DW_AT_call_value
:
2870 case DW_AT_GNU_call_site_value
:
2871 case DW_AT_call_data_value
:
2872 case DW_AT_GNU_call_site_data_value
:
2873 case DW_AT_call_target
:
2874 case DW_AT_GNU_call_site_target
:
2875 case DW_AT_call_target_clobbered
:
2876 case DW_AT_GNU_call_site_target_clobbered
:
2877 if ((dwarf_version
< 4
2878 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2879 || form
== DW_FORM_sec_offset
)
2880 printf (_(" (location list)"));
2882 case DW_AT_allocated
:
2883 case DW_AT_associated
:
2884 case DW_AT_data_location
:
2886 case DW_AT_upper_bound
:
2887 case DW_AT_lower_bound
:
2890 int need_frame_base
;
2893 need_frame_base
= decode_location_expression (block_start
,
2898 cu_offset
, section
);
2900 if (need_frame_base
&& !have_frame_base
)
2901 printf (_(" [without DW_AT_frame_base]"));
2905 case DW_AT_data_bit_offset
:
2906 case DW_AT_byte_size
:
2907 case DW_AT_bit_size
:
2908 case DW_AT_string_length_byte_size
:
2909 case DW_AT_string_length_bit_size
:
2910 case DW_AT_bit_stride
:
2911 if (form
== DW_FORM_exprloc
)
2914 (void) decode_location_expression (block_start
, pointer_size
,
2915 offset_size
, dwarf_version
,
2916 uvalue
, cu_offset
, section
);
2923 if (form
== DW_FORM_ref_sig8
2924 || form
== DW_FORM_GNU_ref_alt
)
2927 if (form
== DW_FORM_ref1
2928 || form
== DW_FORM_ref2
2929 || form
== DW_FORM_ref4
2930 || form
== DW_FORM_ref_udata
)
2931 uvalue
+= cu_offset
;
2933 if (uvalue
>= section
->size
)
2934 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2935 dwarf_vmatoa ("x", uvalue
),
2936 (unsigned long) (orig_data
- section
->start
));
2939 unsigned long abbrev_number
;
2940 abbrev_entry
*entry
;
2941 unsigned char *p
= section
->start
+ uvalue
;
2943 READ_ULEB (abbrev_number
, p
, end
);
2945 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2946 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2947 use different abbrev table, and we don't track .debug_info chunks
2949 if (form
!= DW_FORM_ref_addr
)
2951 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2952 if (entry
->entry
== abbrev_number
)
2955 printf (" (%s)", get_TAG_name (entry
->tag
));
2969 static unsigned char *
2970 read_and_display_attr (unsigned long attribute
,
2972 dwarf_signed_vma implicit_const
,
2973 unsigned char * start
,
2974 unsigned char * data
,
2975 unsigned char * end
,
2976 dwarf_vma cu_offset
,
2977 dwarf_vma pointer_size
,
2978 dwarf_vma offset_size
,
2980 debug_info
* debug_info_p
,
2982 struct dwarf_section
* section
,
2983 struct cu_tu_set
* this_set
,
2987 printf (" %-18s:", get_AT_name (attribute
));
2988 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
2990 cu_offset
, pointer_size
, offset_size
,
2991 dwarf_version
, debug_info_p
,
2992 do_loc
, section
, this_set
, ' ', level
);
2998 /* Like load_debug_section, but if the ordinary call fails, and we are
2999 following debug links, then attempt to load the requested section
3000 from one of the separate debug info files. */
3003 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3006 if (load_debug_section (sec_enum
, handle
))
3008 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3010 /* See if we can associate a filename with this section. */
3013 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3014 if (i
->handle
== handle
)
3016 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3024 if (do_follow_links
)
3028 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3030 if (load_debug_section (sec_enum
, i
->handle
))
3032 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3034 /* FIXME: We should check to see if any of the remaining debug info
3035 files also contain this section, and, umm, do something about it. */
3045 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
3049 if (do_follow_links
&& section
->filename
)
3050 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3051 section
->name
, section
->filename
);
3053 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3057 if (do_follow_links
&& section
->filename
)
3058 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3059 section
->name
, section
->filename
);
3061 printf (_("Contents of the %s section:\n\n"), section
->name
);
3065 /* Process the contents of a .debug_info section.
3066 If do_loc is TRUE then we are scanning for location lists and dwo tags
3067 and we do not want to display anything to the user.
3068 If do_types is TRUE, we are processing a .debug_types section instead of
3069 a .debug_info section.
3070 The information displayed is restricted by the values in DWARF_START_DIE
3071 and DWARF_CUTOFF_LEVEL.
3072 Returns TRUE upon success. Otherwise an error or warning message is
3073 printed and FALSE is returned. */
3076 process_debug_info (struct dwarf_section
* section
,
3078 enum dwarf_section_display_enum abbrev_sec
,
3080 bfd_boolean do_types
)
3082 unsigned char *start
= section
->start
;
3083 unsigned char *end
= start
+ section
->size
;
3084 unsigned char *section_begin
;
3086 unsigned int num_units
= 0;
3088 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3089 && num_debug_info_entries
== 0
3094 /* First scan the section to get the number of comp units. */
3095 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3098 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3099 will be the length. For a 64-bit DWARF section, it'll be
3100 the escape code 0xffffffff followed by an 8 byte length. */
3101 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
3103 if (length
== 0xffffffff)
3105 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
3106 section_begin
+= length
+ 12;
3108 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3110 warn (_("Reserved length value (0x%s) found in section %s\n"),
3111 dwarf_vmatoa ("x", length
), section
->name
);
3115 section_begin
+= length
+ 4;
3117 /* Negative values are illegal, they may even cause infinite
3118 looping. This can happen if we can't accurately apply
3119 relocations to an object file, or if the file is corrupt. */
3120 if ((signed long) length
<= 0 || section_begin
< start
)
3122 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3123 dwarf_vmatoa ("x", length
), section
->name
);
3130 error (_("No comp units in %s section ?\n"), section
->name
);
3134 /* Then allocate an array to hold the information. */
3135 debug_information
= (debug_info
*) cmalloc (num_units
,
3136 sizeof (* debug_information
));
3137 if (debug_information
== NULL
)
3139 error (_("Not enough memory for a debug info array of %u entries\n"),
3141 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3145 /* PR 17531: file: 92ca3797.
3146 We cannot rely upon the debug_information array being initialised
3147 before it is used. A corrupt file could easily contain references
3148 to a unit for which information has not been made available. So
3149 we ensure that the array is zeroed here. */
3150 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3152 alloc_num_debug_info_entries
= num_units
;
3157 load_debug_section_with_follow (str
, file
);
3158 load_debug_section_with_follow (line_str
, file
);
3159 load_debug_section_with_follow (str_dwo
, file
);
3160 load_debug_section_with_follow (str_index
, file
);
3161 load_debug_section_with_follow (str_index_dwo
, file
);
3162 load_debug_section_with_follow (debug_addr
, file
);
3165 load_debug_section_with_follow (abbrev_sec
, file
);
3166 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3168 warn (_("Unable to locate %s section!\n"),
3169 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3173 if (!do_loc
&& dwarf_start_die
== 0)
3174 introduce (section
, FALSE
);
3176 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
3178 DWARF2_Internal_CompUnit compunit
;
3179 unsigned char *hdrptr
;
3180 unsigned char *tags
;
3181 int level
, last_level
, saved_level
;
3182 dwarf_vma cu_offset
;
3183 unsigned long sec_off
;
3184 unsigned int offset_size
;
3185 unsigned int initial_length_size
;
3186 dwarf_vma signature_high
= 0;
3187 dwarf_vma signature_low
= 0;
3188 dwarf_vma type_offset
= 0;
3189 struct cu_tu_set
*this_set
;
3190 dwarf_vma abbrev_base
;
3195 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3197 if (compunit
.cu_length
== 0xffffffff)
3199 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3201 initial_length_size
= 12;
3206 initial_length_size
= 4;
3209 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3211 cu_offset
= start
- section_begin
;
3213 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3215 if (compunit
.cu_version
< 5)
3217 compunit
.cu_unit_type
= DW_UT_compile
;
3218 /* Initialize it due to a false compiler warning. */
3219 compunit
.cu_pointer_size
= -1;
3223 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3224 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3226 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3229 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3231 if (this_set
== NULL
)
3234 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3238 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3239 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3242 if (compunit
.cu_version
< 5)
3243 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3245 /* PR 17512: file: 001-108546-0.001:0.1. */
3246 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3248 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3249 compunit
.cu_pointer_size
, offset_size
);
3250 compunit
.cu_pointer_size
= offset_size
;
3255 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
3257 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
3260 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
3261 + initial_length_size
))
3263 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3264 + initial_length_size
;
3268 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3269 && num_debug_info_entries
== 0
3272 debug_information
[unit
].cu_offset
= cu_offset
;
3273 debug_information
[unit
].pointer_size
3274 = compunit
.cu_pointer_size
;
3275 debug_information
[unit
].offset_size
= offset_size
;
3276 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3277 debug_information
[unit
].base_address
= 0;
3278 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3279 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3280 debug_information
[unit
].loc_offsets
= NULL
;
3281 debug_information
[unit
].have_frame_base
= NULL
;
3282 debug_information
[unit
].max_loc_offsets
= 0;
3283 debug_information
[unit
].num_loc_offsets
= 0;
3284 debug_information
[unit
].range_lists
= NULL
;
3285 debug_information
[unit
].max_range_lists
= 0;
3286 debug_information
[unit
].num_range_lists
= 0;
3289 if (!do_loc
&& dwarf_start_die
== 0)
3291 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3292 dwarf_vmatoa ("x", cu_offset
));
3293 printf (_(" Length: 0x%s (%s)\n"),
3294 dwarf_vmatoa ("x", compunit
.cu_length
),
3295 offset_size
== 8 ? "64-bit" : "32-bit");
3296 printf (_(" Version: %d\n"), compunit
.cu_version
);
3297 printf (_(" Abbrev Offset: 0x%s\n"),
3298 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3299 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3304 printf (_(" Signature: 0x%s\n"),
3305 dwarf_vmatoa64 (signature_high
, signature_low
,
3306 buf
, sizeof (buf
)));
3307 printf (_(" Type Offset: 0x%s\n"),
3308 dwarf_vmatoa ("x", type_offset
));
3310 if (this_set
!= NULL
)
3312 dwarf_vma
*offsets
= this_set
->section_offsets
;
3313 size_t *sizes
= this_set
->section_sizes
;
3315 printf (_(" Section contributions:\n"));
3316 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3317 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3318 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3319 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3320 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3321 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3322 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3323 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3324 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3325 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3326 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3327 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3331 sec_off
= cu_offset
+ initial_length_size
;
3332 if (sec_off
+ compunit
.cu_length
< sec_off
3333 || sec_off
+ compunit
.cu_length
> section
->size
)
3335 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3337 (unsigned long) cu_offset
,
3338 dwarf_vmatoa ("x", compunit
.cu_length
));
3344 start
+= compunit
.cu_length
+ initial_length_size
;
3346 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3348 warn (_("CU at offset %s contains corrupt or "
3349 "unsupported version number: %d.\n"),
3350 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3354 if (compunit
.cu_unit_type
!= DW_UT_compile
3355 && compunit
.cu_unit_type
!= DW_UT_type
)
3357 warn (_("CU at offset %s contains corrupt or "
3358 "unsupported unit type: %d.\n"),
3359 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3365 /* Process the abbrevs used by this compilation unit. */
3366 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3367 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3368 (unsigned long) compunit
.cu_abbrev_offset
,
3369 (unsigned long) abbrev_size
);
3370 /* PR 17531: file:4bcd9ce9. */
3371 else if ((abbrev_base
+ abbrev_size
)
3372 > debug_displays
[abbrev_sec
].section
.size
)
3373 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3374 (unsigned long) abbrev_base
+ abbrev_size
,
3375 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3377 process_abbrev_section
3378 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3379 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3380 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3381 + abbrev_base
+ abbrev_size
));
3386 while (tags
< start
)
3388 unsigned long abbrev_number
;
3389 unsigned long die_offset
;
3390 abbrev_entry
*entry
;
3392 int do_printing
= 1;
3394 die_offset
= tags
- section_begin
;
3396 READ_ULEB (abbrev_number
, tags
, start
);
3398 /* A null DIE marks the end of a list of siblings or it may also be
3399 a section padding. */
3400 if (abbrev_number
== 0)
3402 /* Check if it can be a section padding for the last CU. */
3403 if (level
== 0 && start
== end
)
3407 for (chk
= tags
; chk
< start
; chk
++)
3414 if (!do_loc
&& die_offset
>= dwarf_start_die
3415 && (dwarf_cutoff_level
== -1
3416 || level
< dwarf_cutoff_level
))
3417 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3423 static unsigned num_bogus_warns
= 0;
3425 if (num_bogus_warns
< 3)
3427 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3428 die_offset
, section
->name
);
3430 if (num_bogus_warns
== 3)
3431 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3434 if (dwarf_start_die
!= 0 && level
< saved_level
)
3441 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3445 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3446 saved_level
= level
;
3447 do_printing
= (dwarf_cutoff_level
== -1
3448 || level
< dwarf_cutoff_level
);
3450 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3451 level
, die_offset
, abbrev_number
);
3452 else if (dwarf_cutoff_level
== -1
3453 || last_level
< dwarf_cutoff_level
)
3454 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3459 /* Scan through the abbreviation list until we reach the
3461 for (entry
= first_abbrev
;
3462 entry
&& entry
->entry
!= abbrev_number
;
3463 entry
= entry
->next
)
3468 if (!do_loc
&& do_printing
)
3473 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3474 die_offset
, abbrev_number
);
3478 if (!do_loc
&& do_printing
)
3479 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3484 need_base_address
= 0;
3486 case DW_TAG_compile_unit
:
3487 need_base_address
= 1;
3488 need_dwo_info
= do_loc
;
3490 case DW_TAG_entry_point
:
3491 case DW_TAG_subprogram
:
3492 need_base_address
= 0;
3493 /* Assuming that there is no DW_AT_frame_base. */
3494 have_frame_base
= 0;
3498 debug_info
*debug_info_p
=
3499 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3500 ? debug_information
+ unit
: NULL
;
3502 assert (!debug_info_p
3503 || (debug_info_p
->num_loc_offsets
3504 == debug_info_p
->num_loc_views
));
3506 for (attr
= entry
->first_attr
;
3507 attr
&& attr
->attribute
;
3510 if (! do_loc
&& do_printing
)
3511 /* Show the offset from where the tag was extracted. */
3512 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3513 tags
= read_and_display_attr (attr
->attribute
,
3515 attr
->implicit_const
,
3520 compunit
.cu_pointer_size
,
3522 compunit
.cu_version
,
3524 do_loc
|| ! do_printing
,
3530 /* If a locview attribute appears before a location one,
3531 make sure we don't associate it with an earlier
3534 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3537 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3538 debug_info_p
->num_loc_views
++;
3539 assert (debug_info_p
->num_loc_views
3540 == debug_info_p
->num_loc_offsets
);
3547 warn(_("DIE has locviews without loclist\n"));
3548 debug_info_p
->num_loc_views
--;
3555 if (entry
->children
)
3560 /* Set num_debug_info_entries here so that it can be used to check if
3561 we need to process .debug_loc and .debug_ranges sections. */
3562 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3563 && num_debug_info_entries
== 0
3566 if (num_units
> alloc_num_debug_info_entries
)
3567 num_debug_info_entries
= alloc_num_debug_info_entries
;
3569 num_debug_info_entries
= num_units
;
3578 /* Locate and scan the .debug_info section in the file and record the pointer
3579 sizes and offsets for the compilation units in it. Usually an executable
3580 will have just one pointer size, but this is not guaranteed, and so we try
3581 not to make any assumptions. Returns zero upon failure, or the number of
3582 compilation units upon success. */
3585 load_debug_info (void * file
)
3587 /* If we have already tried and failed to load the .debug_info
3588 section then do not bother to repeat the task. */
3589 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3592 /* If we already have the information there is nothing else to do. */
3593 if (num_debug_info_entries
> 0)
3594 return num_debug_info_entries
;
3596 /* If this is a DWARF package file, load the CU and TU indexes. */
3597 (void) load_cu_tu_indexes (file
);
3599 if (load_debug_section_with_follow (info
, file
)
3600 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3601 return num_debug_info_entries
;
3603 if (load_debug_section_with_follow (info_dwo
, file
)
3604 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3605 abbrev_dwo
, TRUE
, FALSE
))
3606 return num_debug_info_entries
;
3608 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3612 /* Read a DWARF .debug_line section header starting at DATA.
3613 Upon success returns an updated DATA pointer and the LINFO
3614 structure and the END_OF_SEQUENCE pointer will be filled in.
3615 Otherwise returns NULL. */
3617 static unsigned char *
3618 read_debug_line_header (struct dwarf_section
* section
,
3619 unsigned char * data
,
3620 unsigned char * end
,
3621 DWARF2_Internal_LineInfo
* linfo
,
3622 unsigned char ** end_of_sequence
)
3624 unsigned char *hdrptr
;
3625 unsigned int initial_length_size
;
3627 /* Extract information from the Line Number Program Header.
3628 (section 6.2.4 in the Dwarf3 doc). */
3631 /* Get and check the length of the block. */
3632 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3634 if (linfo
->li_length
== 0xffffffff)
3636 /* This section is 64-bit DWARF 3. */
3637 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3638 linfo
->li_offset_size
= 8;
3639 initial_length_size
= 12;
3643 linfo
->li_offset_size
= 4;
3644 initial_length_size
= 4;
3647 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3649 /* If the length field has a relocation against it, then we should
3650 not complain if it is inaccurate (and probably negative). This
3651 happens in object files when the .debug_line section is actually
3652 comprised of several different .debug_line.* sections, (some of
3653 which may be removed by linker garbage collection), and a relocation
3654 is used to compute the correct length once that is done. */
3655 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3657 linfo
->li_length
= (end
- data
) - initial_length_size
;
3661 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3662 (long) linfo
->li_length
);
3667 /* Get and check the version number. */
3668 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3670 if (linfo
->li_version
!= 2
3671 && linfo
->li_version
!= 3
3672 && linfo
->li_version
!= 4
3673 && linfo
->li_version
!= 5)
3675 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3676 "is currently supported.\n"));
3680 if (linfo
->li_version
>= 5)
3682 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
3684 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
3685 if (linfo
->li_segment_size
!= 0)
3687 warn (_("The %s section contains "
3688 "unsupported segment selector size: %d.\n"),
3689 section
->name
, linfo
->li_segment_size
);
3694 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3695 linfo
->li_offset_size
, end
);
3696 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3698 if (linfo
->li_version
>= 4)
3700 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3702 if (linfo
->li_max_ops_per_insn
== 0)
3704 warn (_("Invalid maximum operations per insn.\n"));
3709 linfo
->li_max_ops_per_insn
= 1;
3711 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3712 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3713 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3714 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3716 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3717 /* PR 17512: file:002-117414-0.004. */
3718 if (* end_of_sequence
> end
)
3720 warn (_("Line length %s extends beyond end of section\n"),
3721 dwarf_vmatoa ("u", linfo
->li_length
));
3722 * end_of_sequence
= end
;
3729 static unsigned char *
3730 display_formatted_table (unsigned char * data
,
3731 unsigned char * start
,
3732 unsigned char * end
,
3733 const DWARF2_Internal_LineInfo
* linfo
,
3734 struct dwarf_section
* section
,
3737 unsigned char *format_start
, format_count
, *format
, formati
;
3738 dwarf_vma data_count
, datai
;
3739 unsigned int namepass
, last_entry
= 0;
3740 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
3742 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3743 if (do_checks
&& format_count
> 5)
3744 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
3745 table_name
, format_count
);
3747 format_start
= data
;
3748 for (formati
= 0; formati
< format_count
; formati
++)
3750 SKIP_ULEB (data
, end
);
3751 SKIP_ULEB (data
, end
);
3754 warn (_("%s: Corrupt format description entry\n"), table_name
);
3759 READ_ULEB (data_count
, data
, end
);
3760 if (data_count
== 0)
3762 printf (_("\n The %s is empty.\n"), table_name
);
3765 else if (data
== end
)
3767 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
3768 table_name
, dwarf_vmatoa ("x", data_count
));
3772 else if (format_count
== 0)
3774 warn (_("%s: format count is zero, but the table is not empty\n"),
3779 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
3780 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
3783 printf (_(" Entry"));
3784 /* Delay displaying name as the last entry for better screen layout. */
3785 for (namepass
= 0; namepass
< 2; namepass
++)
3787 format
= format_start
;
3788 for (formati
= 0; formati
< format_count
; formati
++)
3790 dwarf_vma content_type
;
3792 READ_ULEB (content_type
, format
, end
);
3793 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3794 switch (content_type
)
3797 printf (_("\tName"));
3799 case DW_LNCT_directory_index
:
3800 printf (_("\tDir"));
3802 case DW_LNCT_timestamp
:
3803 printf (_("\tTime"));
3806 printf (_("\tSize"));
3809 printf (_("\tMD5\t\t\t"));
3812 printf (_("\t(Unknown format content type %s)"),
3813 dwarf_vmatoa ("u", content_type
));
3815 SKIP_ULEB (format
, end
);
3820 for (datai
= 0; datai
< data_count
; datai
++)
3822 unsigned char *datapass
= data
;
3824 printf (" %d", last_entry
++);
3825 /* Delay displaying name as the last entry for better screen layout. */
3826 for (namepass
= 0; namepass
< 2; namepass
++)
3828 format
= format_start
;
3830 for (formati
= 0; formati
< format_count
; formati
++)
3832 dwarf_vma content_type
, form
;
3834 READ_ULEB (content_type
, format
, end
);
3835 READ_ULEB (form
, format
, end
);
3836 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
3837 0, 0, linfo
->li_offset_size
,
3838 linfo
->li_version
, NULL
,
3839 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3840 section
, NULL
, '\t', -1);
3844 if (data
== end
&& (datai
< data_count
- 1))
3846 warn (_("\n%s: Corrupt entries list\n"), table_name
);
3855 display_debug_lines_raw (struct dwarf_section
* section
,
3856 unsigned char * data
,
3857 unsigned char * end
,
3860 unsigned char *start
= section
->start
;
3861 int verbose_view
= 0;
3863 introduce (section
, TRUE
);
3867 static DWARF2_Internal_LineInfo saved_linfo
;
3868 DWARF2_Internal_LineInfo linfo
;
3869 unsigned char *standard_opcodes
;
3870 unsigned char *end_of_sequence
;
3873 if (const_strneq (section
->name
, ".debug_line.")
3874 /* Note: the following does not apply to .debug_line.dwo sections.
3875 These are full debug_line sections. */
3876 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3878 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3879 section containing just the Line Number Statements. They are
3880 created by the assembler and intended to be used alongside gcc's
3881 -ffunction-sections command line option. When the linker's
3882 garbage collection decides to discard a .text.<foo> section it
3883 can then also discard the line number information in .debug_line.<foo>.
3885 Since the section is a fragment it does not have the details
3886 needed to fill out a LineInfo structure, so instead we use the
3887 details from the last full debug_line section that we processed. */
3888 end_of_sequence
= end
;
3889 standard_opcodes
= NULL
;
3890 linfo
= saved_linfo
;
3891 /* PR 17531: file: 0522b371. */
3892 if (linfo
.li_line_range
== 0)
3894 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3897 reset_state_machine (linfo
.li_default_is_stmt
);
3901 unsigned char * hdrptr
;
3903 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3904 & end_of_sequence
)) == NULL
)
3907 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3908 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3909 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3910 if (linfo
.li_version
>= 5)
3912 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
3913 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
3915 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3916 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3917 if (linfo
.li_version
>= 4)
3918 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3919 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3920 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3921 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3922 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3924 /* PR 17512: file: 1665-6428-0.004. */
3925 if (linfo
.li_line_range
== 0)
3927 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3928 linfo
.li_line_range
= 1;
3931 reset_state_machine (linfo
.li_default_is_stmt
);
3933 /* Display the contents of the Opcodes table. */
3934 standard_opcodes
= hdrptr
;
3936 /* PR 17512: file: 002-417945-0.004. */
3937 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3939 warn (_("Line Base extends beyond end of section\n"));
3943 printf (_("\n Opcodes:\n"));
3945 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3946 printf (ngettext (" Opcode %d has %d arg\n",
3947 " Opcode %d has %d args\n",
3948 standard_opcodes
[i
- 1]),
3949 i
, standard_opcodes
[i
- 1]);
3951 /* Display the contents of the Directory table. */
3952 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3954 if (linfo
.li_version
>= 5)
3956 load_debug_section_with_follow (line_str
, file
);
3958 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3960 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3966 printf (_("\n The Directory Table is empty.\n"));
3969 unsigned int last_dir_entry
= 0;
3971 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3972 (long)(data
- start
));
3974 while (data
< end
&& *data
!= 0)
3976 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
3978 data
+= strnlen ((char *) data
, end
- data
) + 1;
3981 /* PR 17512: file: 002-132094-0.004. */
3982 if (data
>= end
- 1)
3986 /* Skip the NUL at the end of the table. */
3989 /* Display the contents of the File Name table. */
3991 printf (_("\n The File Name Table is empty.\n"));
3994 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3995 (long)(data
- start
));
3996 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3998 while (data
< end
&& *data
!= 0)
4000 unsigned char *name
;
4003 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4005 data
+= strnlen ((char *) data
, end
- data
) + 1;
4007 READ_ULEB (val
, data
, end
);
4008 printf ("%s\t", dwarf_vmatoa ("u", val
));
4009 READ_ULEB (val
, data
, end
);
4010 printf ("%s\t", dwarf_vmatoa ("u", val
));
4011 READ_ULEB (val
, data
, end
);
4012 printf ("%s\t", dwarf_vmatoa ("u", val
));
4013 printf ("%.*s\n", (int)(end
- name
), name
);
4017 warn (_("Corrupt file name table entry\n"));
4023 /* Skip the NUL at the end of the table. */
4028 saved_linfo
= linfo
;
4031 /* Now display the statements. */
4032 if (data
>= end_of_sequence
)
4033 printf (_(" No Line Number Statements.\n"));
4036 printf (_(" Line Number Statements:\n"));
4038 while (data
< end_of_sequence
)
4040 unsigned char op_code
;
4041 dwarf_signed_vma adv
;
4044 printf (" [0x%08lx]", (long)(data
- start
));
4048 if (op_code
>= linfo
.li_opcode_base
)
4050 op_code
-= linfo
.li_opcode_base
;
4051 uladv
= (op_code
/ linfo
.li_line_range
);
4052 if (linfo
.li_max_ops_per_insn
== 1)
4054 uladv
*= linfo
.li_min_insn_length
;
4055 state_machine_regs
.address
+= uladv
;
4057 state_machine_regs
.view
= 0;
4058 printf (_(" Special opcode %d: "
4059 "advance Address by %s to 0x%s%s"),
4060 op_code
, dwarf_vmatoa ("u", uladv
),
4061 dwarf_vmatoa ("x", state_machine_regs
.address
),
4062 verbose_view
&& uladv
4063 ? _(" (reset view)") : "");
4068 = ((state_machine_regs
.op_index
+ uladv
)
4069 / linfo
.li_max_ops_per_insn
)
4070 * linfo
.li_min_insn_length
;
4072 state_machine_regs
.address
+= addrdelta
;
4073 state_machine_regs
.op_index
4074 = (state_machine_regs
.op_index
+ uladv
)
4075 % linfo
.li_max_ops_per_insn
;
4077 state_machine_regs
.view
= 0;
4078 printf (_(" Special opcode %d: "
4079 "advance Address by %s to 0x%s[%d]%s"),
4080 op_code
, dwarf_vmatoa ("u", uladv
),
4081 dwarf_vmatoa ("x", state_machine_regs
.address
),
4082 state_machine_regs
.op_index
,
4083 verbose_view
&& addrdelta
4084 ? _(" (reset view)") : "");
4086 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4087 state_machine_regs
.line
+= adv
;
4088 printf (_(" and Line by %s to %d"),
4089 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4090 if (verbose_view
|| state_machine_regs
.view
)
4091 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4094 state_machine_regs
.view
++;
4099 case DW_LNS_extended_op
:
4100 data
+= process_extended_line_op (data
,
4101 linfo
.li_default_is_stmt
,
4106 printf (_(" Copy"));
4107 if (verbose_view
|| state_machine_regs
.view
)
4108 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4111 state_machine_regs
.view
++;
4114 case DW_LNS_advance_pc
:
4115 READ_ULEB (uladv
, data
, end
);
4116 if (linfo
.li_max_ops_per_insn
== 1)
4118 uladv
*= linfo
.li_min_insn_length
;
4119 state_machine_regs
.address
+= uladv
;
4121 state_machine_regs
.view
= 0;
4122 printf (_(" Advance PC by %s to 0x%s%s\n"),
4123 dwarf_vmatoa ("u", uladv
),
4124 dwarf_vmatoa ("x", state_machine_regs
.address
),
4125 verbose_view
&& uladv
4126 ? _(" (reset view)") : "");
4131 = ((state_machine_regs
.op_index
+ uladv
)
4132 / linfo
.li_max_ops_per_insn
)
4133 * linfo
.li_min_insn_length
;
4134 state_machine_regs
.address
4136 state_machine_regs
.op_index
4137 = (state_machine_regs
.op_index
+ uladv
)
4138 % linfo
.li_max_ops_per_insn
;
4140 state_machine_regs
.view
= 0;
4141 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4142 dwarf_vmatoa ("u", uladv
),
4143 dwarf_vmatoa ("x", state_machine_regs
.address
),
4144 state_machine_regs
.op_index
,
4145 verbose_view
&& addrdelta
4146 ? _(" (reset view)") : "");
4150 case DW_LNS_advance_line
:
4151 READ_SLEB (adv
, data
, end
);
4152 state_machine_regs
.line
+= adv
;
4153 printf (_(" Advance Line by %s to %d\n"),
4154 dwarf_vmatoa ("d", adv
),
4155 state_machine_regs
.line
);
4158 case DW_LNS_set_file
:
4159 READ_ULEB (uladv
, data
, end
);
4160 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4161 dwarf_vmatoa ("u", uladv
));
4162 state_machine_regs
.file
= uladv
;
4165 case DW_LNS_set_column
:
4166 READ_ULEB (uladv
, data
, end
);
4167 printf (_(" Set column to %s\n"),
4168 dwarf_vmatoa ("u", uladv
));
4169 state_machine_regs
.column
= uladv
;
4172 case DW_LNS_negate_stmt
:
4173 adv
= state_machine_regs
.is_stmt
;
4175 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4176 state_machine_regs
.is_stmt
= adv
;
4179 case DW_LNS_set_basic_block
:
4180 printf (_(" Set basic block\n"));
4181 state_machine_regs
.basic_block
= 1;
4184 case DW_LNS_const_add_pc
:
4185 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4186 if (linfo
.li_max_ops_per_insn
)
4188 uladv
*= linfo
.li_min_insn_length
;
4189 state_machine_regs
.address
+= uladv
;
4191 state_machine_regs
.view
= 0;
4192 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4193 dwarf_vmatoa ("u", uladv
),
4194 dwarf_vmatoa ("x", state_machine_regs
.address
),
4195 verbose_view
&& uladv
4196 ? _(" (reset view)") : "");
4201 = ((state_machine_regs
.op_index
+ uladv
)
4202 / linfo
.li_max_ops_per_insn
)
4203 * linfo
.li_min_insn_length
;
4204 state_machine_regs
.address
4206 state_machine_regs
.op_index
4207 = (state_machine_regs
.op_index
+ uladv
)
4208 % linfo
.li_max_ops_per_insn
;
4210 state_machine_regs
.view
= 0;
4211 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4212 dwarf_vmatoa ("u", uladv
),
4213 dwarf_vmatoa ("x", state_machine_regs
.address
),
4214 state_machine_regs
.op_index
,
4215 verbose_view
&& addrdelta
4216 ? _(" (reset view)") : "");
4220 case DW_LNS_fixed_advance_pc
:
4221 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4222 state_machine_regs
.address
+= uladv
;
4223 state_machine_regs
.op_index
= 0;
4224 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4225 dwarf_vmatoa ("u", uladv
),
4226 dwarf_vmatoa ("x", state_machine_regs
.address
));
4227 /* Do NOT reset view. */
4230 case DW_LNS_set_prologue_end
:
4231 printf (_(" Set prologue_end to true\n"));
4234 case DW_LNS_set_epilogue_begin
:
4235 printf (_(" Set epilogue_begin to true\n"));
4238 case DW_LNS_set_isa
:
4239 READ_ULEB (uladv
, data
, end
);
4240 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4244 printf (_(" Unknown opcode %d with operands: "), op_code
);
4246 if (standard_opcodes
!= NULL
)
4247 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4249 READ_ULEB (uladv
, data
, end
);
4250 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4251 i
== 1 ? "" : ", ");
4266 unsigned char *name
;
4267 unsigned int directory_index
;
4268 unsigned int modification_date
;
4269 unsigned int length
;
4272 /* Output a decoded representation of the .debug_line section. */
4275 display_debug_lines_decoded (struct dwarf_section
* section
,
4276 unsigned char * start
,
4277 unsigned char * data
,
4278 unsigned char * end
,
4281 static DWARF2_Internal_LineInfo saved_linfo
;
4283 introduce (section
, FALSE
);
4287 /* This loop amounts to one iteration per compilation unit. */
4288 DWARF2_Internal_LineInfo linfo
;
4289 unsigned char *standard_opcodes
;
4290 unsigned char *end_of_sequence
;
4292 File_Entry
*file_table
= NULL
;
4293 unsigned int n_files
= 0;
4294 unsigned char **directory_table
= NULL
;
4295 dwarf_vma n_directories
= 0;
4297 if (const_strneq (section
->name
, ".debug_line.")
4298 /* Note: the following does not apply to .debug_line.dwo sections.
4299 These are full debug_line sections. */
4300 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4302 /* See comment in display_debug_lines_raw(). */
4303 end_of_sequence
= end
;
4304 standard_opcodes
= NULL
;
4305 linfo
= saved_linfo
;
4306 /* PR 17531: file: 0522b371. */
4307 if (linfo
.li_line_range
== 0)
4309 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4312 reset_state_machine (linfo
.li_default_is_stmt
);
4316 unsigned char *hdrptr
;
4318 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4319 & end_of_sequence
)) == NULL
)
4322 /* PR 17531: file: 0522b371. */
4323 if (linfo
.li_line_range
== 0)
4325 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4326 linfo
.li_line_range
= 1;
4328 reset_state_machine (linfo
.li_default_is_stmt
);
4330 /* Save a pointer to the contents of the Opcodes table. */
4331 standard_opcodes
= hdrptr
;
4333 /* Traverse the Directory table just to count entries. */
4334 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4338 warn (_("opcode base of %d extends beyond end of section\n"),
4339 linfo
.li_opcode_base
);
4343 if (linfo
.li_version
>= 5)
4345 unsigned char *format_start
, format_count
, *format
;
4346 dwarf_vma formati
, entryi
;
4348 load_debug_section_with_follow (line_str
, fileptr
);
4350 /* Skip directories format. */
4351 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4352 if (do_checks
&& format_count
> 1)
4353 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4355 format_start
= data
;
4356 for (formati
= 0; formati
< format_count
; formati
++)
4358 SKIP_ULEB (data
, end
);
4359 SKIP_ULEB (data
, end
);
4362 READ_ULEB (n_directories
, data
, end
);
4365 warn (_("Corrupt directories list\n"));
4369 if (n_directories
== 0)
4370 directory_table
= NULL
;
4372 directory_table
= (unsigned char **)
4373 xmalloc (n_directories
* sizeof (unsigned char *));
4375 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4377 unsigned char **pathp
= &directory_table
[entryi
];
4379 format
= format_start
;
4380 for (formati
= 0; formati
< format_count
; formati
++)
4382 dwarf_vma content_type
, form
;
4385 READ_ULEB (content_type
, format
, end
);
4386 READ_ULEB (form
, format
, end
);
4389 warn (_("Corrupt directories list\n"));
4392 switch (content_type
)
4397 case DW_FORM_string
:
4400 case DW_FORM_line_strp
:
4401 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4403 /* Remove const by the cast. */
4404 *pathp
= (unsigned char *)
4405 fetch_indirect_line_string (uvalue
);
4410 data
= read_and_display_attr_value (0, form
, 0, start
,
4412 linfo
.li_offset_size
,
4419 warn (_("Corrupt directories list\n"));
4424 /* Skip files format. */
4425 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4426 if (do_checks
&& format_count
> 5)
4427 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
4429 format_start
= data
;
4430 for (formati
= 0; formati
< format_count
; formati
++)
4432 SKIP_ULEB (data
, end
);
4433 SKIP_ULEB (data
, end
);
4436 READ_ULEB (n_files
, data
, end
);
4437 if (data
== end
&& n_files
> 0)
4439 warn (_("Corrupt file name list\n"));
4446 file_table
= (File_Entry
*) xcalloc (1, n_files
4447 * sizeof (File_Entry
));
4449 for (entryi
= 0; entryi
< n_files
; entryi
++)
4451 File_Entry
*file
= &file_table
[entryi
];
4453 format
= format_start
;
4454 for (formati
= 0; formati
< format_count
; formati
++)
4456 dwarf_vma content_type
, form
;
4460 READ_ULEB (content_type
, format
, end
);
4461 READ_ULEB (form
, format
, end
);
4464 warn (_("Corrupt file name list\n"));
4467 switch (content_type
)
4472 case DW_FORM_string
:
4475 case DW_FORM_line_strp
:
4476 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4478 /* Remove const by the cast. */
4479 file
->name
= (unsigned char *)
4480 fetch_indirect_line_string (uvalue
);
4484 case DW_LNCT_directory_index
:
4488 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4492 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4497 READ_ULEB (file
->directory_index
, tmp
, end
);
4502 data
= read_and_display_attr_value (0, form
, 0, start
,
4504 linfo
.li_offset_size
,
4511 warn (_("Corrupt file name list\n"));
4520 unsigned char *ptr_directory_table
= data
;
4522 while (data
< end
&& *data
!= 0)
4524 data
+= strnlen ((char *) data
, end
- data
) + 1;
4531 warn (_("directory table ends unexpectedly\n"));
4536 /* Go through the directory table again to save the directories. */
4537 directory_table
= (unsigned char **)
4538 xmalloc (n_directories
* sizeof (unsigned char *));
4541 while (*ptr_directory_table
!= 0)
4543 directory_table
[i
] = ptr_directory_table
;
4544 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4545 ptr_directory_table
- end
) + 1;
4549 /* Skip the NUL at the end of the table. */
4552 /* Traverse the File Name table just to count the entries. */
4553 if (data
< end
&& *data
!= 0)
4555 unsigned char *ptr_file_name_table
= data
;
4557 while (data
< end
&& *data
!= 0)
4559 /* Skip Name, directory index, last modification
4560 time and length of file. */
4561 data
+= strnlen ((char *) data
, end
- data
) + 1;
4562 SKIP_ULEB (data
, end
);
4563 SKIP_ULEB (data
, end
);
4564 SKIP_ULEB (data
, end
);
4570 warn (_("file table ends unexpectedly\n"));
4575 /* Go through the file table again to save the strings. */
4576 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4579 while (*ptr_file_name_table
!= 0)
4581 file_table
[i
].name
= ptr_file_name_table
;
4582 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4583 end
- ptr_file_name_table
) + 1;
4585 /* We are not interested in directory, time or size. */
4586 READ_ULEB (file_table
[i
].directory_index
,
4587 ptr_file_name_table
, end
);
4588 READ_ULEB (file_table
[i
].modification_date
,
4589 ptr_file_name_table
, end
);
4590 READ_ULEB (file_table
[i
].length
,
4591 ptr_file_name_table
, end
);
4597 /* Skip the NUL at the end of the table. */
4601 /* Print the Compilation Unit's name and a header. */
4602 if (file_table
== NULL
)
4603 printf (_("CU: No directory table\n"));
4604 else if (directory_table
== NULL
)
4605 printf (_("CU: %s:\n"), file_table
[0].name
);
4608 unsigned int ix
= file_table
[0].directory_index
;
4609 const char *directory
;
4614 else if (n_directories
== 0)
4615 directory
= _("<unknown>");
4616 else if (ix
> n_directories
)
4618 warn (_("directory index %u > number of directories %s\n"),
4619 ix
, dwarf_vmatoa ("u", n_directories
));
4620 directory
= _("<corrupt>");
4623 directory
= (char *) directory_table
[ix
- 1];
4625 if (do_wide
|| strlen (directory
) < 76)
4626 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4628 printf ("%s:\n", file_table
[0].name
);
4632 printf (_("File name Line number Starting address View Stmt\n"));
4634 printf (_("CU: Empty file name table\n"));
4635 saved_linfo
= linfo
;
4638 /* This loop iterates through the Dwarf Line Number Program. */
4639 while (data
< end_of_sequence
)
4641 unsigned char op_code
;
4644 unsigned long int uladv
;
4645 int is_special_opcode
= 0;
4650 if (op_code
>= linfo
.li_opcode_base
)
4652 op_code
-= linfo
.li_opcode_base
;
4653 uladv
= (op_code
/ linfo
.li_line_range
);
4654 if (linfo
.li_max_ops_per_insn
== 1)
4656 uladv
*= linfo
.li_min_insn_length
;
4657 state_machine_regs
.address
+= uladv
;
4659 state_machine_regs
.view
= 0;
4664 = ((state_machine_regs
.op_index
+ uladv
)
4665 / linfo
.li_max_ops_per_insn
)
4666 * linfo
.li_min_insn_length
;
4667 state_machine_regs
.address
4669 state_machine_regs
.op_index
4670 = (state_machine_regs
.op_index
+ uladv
)
4671 % linfo
.li_max_ops_per_insn
;
4673 state_machine_regs
.view
= 0;
4676 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4677 state_machine_regs
.line
+= adv
;
4678 is_special_opcode
= 1;
4679 /* Increment view after printing this row. */
4684 case DW_LNS_extended_op
:
4686 unsigned int ext_op_code_len
;
4687 unsigned char ext_op_code
;
4688 unsigned char *op_code_end
;
4689 unsigned char *op_code_data
= data
;
4691 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
4692 op_code_end
= op_code_data
+ ext_op_code_len
;
4693 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
4695 warn (_("Badly formed extended line op encountered!\n"));
4698 ext_op_code
= *op_code_data
++;
4702 switch (ext_op_code
)
4704 case DW_LNE_end_sequence
:
4705 /* Reset stuff after printing this row. */
4707 case DW_LNE_set_address
:
4708 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4710 op_code_end
- op_code_data
,
4712 state_machine_regs
.op_index
= 0;
4713 state_machine_regs
.view
= 0;
4715 case DW_LNE_define_file
:
4716 file_table
= (File_Entry
*) xrealloc
4717 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4719 ++state_machine_regs
.last_file_entry
;
4720 /* Source file name. */
4721 file_table
[n_files
].name
= op_code_data
;
4722 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4723 /* Directory index. */
4724 READ_ULEB (file_table
[n_files
].directory_index
,
4725 op_code_data
, op_code_end
);
4726 /* Last modification time. */
4727 READ_ULEB (file_table
[n_files
].modification_date
,
4728 op_code_data
, op_code_end
);
4730 READ_ULEB (file_table
[n_files
].length
,
4731 op_code_data
, op_code_end
);
4735 case DW_LNE_set_discriminator
:
4736 case DW_LNE_HP_set_sequence
:
4737 /* Simply ignored. */
4741 printf (_("UNKNOWN (%u): length %ld\n"),
4742 ext_op_code
, (long int) (op_code_data
- data
));
4749 /* Increment view after printing this row. */
4752 case DW_LNS_advance_pc
:
4753 READ_ULEB (uladv
, data
, end
);
4754 if (linfo
.li_max_ops_per_insn
== 1)
4756 uladv
*= linfo
.li_min_insn_length
;
4757 state_machine_regs
.address
+= uladv
;
4759 state_machine_regs
.view
= 0;
4764 = ((state_machine_regs
.op_index
+ uladv
)
4765 / linfo
.li_max_ops_per_insn
)
4766 * linfo
.li_min_insn_length
;
4767 state_machine_regs
.address
4769 state_machine_regs
.op_index
4770 = (state_machine_regs
.op_index
+ uladv
)
4771 % linfo
.li_max_ops_per_insn
;
4773 state_machine_regs
.view
= 0;
4777 case DW_LNS_advance_line
:
4778 READ_SLEB (adv
, data
, end
);
4779 state_machine_regs
.line
+= adv
;
4782 case DW_LNS_set_file
:
4783 READ_ULEB (uladv
, data
, end
);
4784 state_machine_regs
.file
= uladv
;
4787 unsigned file
= state_machine_regs
.file
- 1;
4790 if (file_table
== NULL
|| n_files
== 0)
4791 printf (_("\n [Use file table entry %d]\n"), file
);
4793 else if (file
>= n_files
)
4795 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4796 printf (_("\n <over large file table index %u>"), file
);
4798 else if ((dir
= file_table
[file
].directory_index
) == 0)
4799 /* If directory index is 0, that means current directory. */
4800 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4801 else if (directory_table
== NULL
|| n_directories
== 0)
4802 printf (_("\n [Use file %s in directory table entry %d]\n"),
4803 file_table
[file
].name
, dir
);
4805 else if (dir
> n_directories
)
4807 warn (_("directory index %u > number of directories %s\n"),
4808 dir
, dwarf_vmatoa ("u", n_directories
));
4809 printf (_("\n <over large directory table entry %u>\n"), dir
);
4812 printf ("\n%s/%s:\n",
4813 /* The directory index starts counting at 1. */
4814 directory_table
[dir
- 1], file_table
[file
].name
);
4818 case DW_LNS_set_column
:
4819 READ_ULEB (uladv
, data
, end
);
4820 state_machine_regs
.column
= uladv
;
4823 case DW_LNS_negate_stmt
:
4824 adv
= state_machine_regs
.is_stmt
;
4826 state_machine_regs
.is_stmt
= adv
;
4829 case DW_LNS_set_basic_block
:
4830 state_machine_regs
.basic_block
= 1;
4833 case DW_LNS_const_add_pc
:
4834 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4835 if (linfo
.li_max_ops_per_insn
== 1)
4837 uladv
*= linfo
.li_min_insn_length
;
4838 state_machine_regs
.address
+= uladv
;
4840 state_machine_regs
.view
= 0;
4845 = ((state_machine_regs
.op_index
+ uladv
)
4846 / linfo
.li_max_ops_per_insn
)
4847 * linfo
.li_min_insn_length
;
4848 state_machine_regs
.address
4850 state_machine_regs
.op_index
4851 = (state_machine_regs
.op_index
+ uladv
)
4852 % linfo
.li_max_ops_per_insn
;
4854 state_machine_regs
.view
= 0;
4858 case DW_LNS_fixed_advance_pc
:
4859 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4860 state_machine_regs
.address
+= uladv
;
4861 state_machine_regs
.op_index
= 0;
4862 /* Do NOT reset view. */
4865 case DW_LNS_set_prologue_end
:
4868 case DW_LNS_set_epilogue_begin
:
4871 case DW_LNS_set_isa
:
4872 READ_ULEB (uladv
, data
, end
);
4873 printf (_(" Set ISA to %lu\n"), uladv
);
4877 printf (_(" Unknown opcode %d with operands: "), op_code
);
4879 if (standard_opcodes
!= NULL
)
4880 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4884 READ_ULEB (val
, data
, end
);
4885 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
4886 i
== 1 ? "" : ", ");
4892 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4893 to the DWARF address/line matrix. */
4894 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4895 || (xop
== DW_LNS_copy
))
4897 const unsigned int MAX_FILENAME_LENGTH
= 35;
4899 char *newFileName
= NULL
;
4900 size_t fileNameLength
;
4904 unsigned indx
= state_machine_regs
.file
- 1;
4906 if (indx
>= n_files
)
4908 warn (_("corrupt file index %u encountered\n"), indx
);
4909 fileName
= _("<corrupt>");
4912 fileName
= (char *) file_table
[indx
].name
;
4915 fileName
= _("<unknown>");
4917 fileNameLength
= strlen (fileName
);
4919 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4921 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4922 /* Truncate file name */
4923 strncpy (newFileName
,
4924 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4925 MAX_FILENAME_LENGTH
+ 1);
4926 /* FIXME: This is to pacify gcc-10 which can warn that the
4927 strncpy above might leave a non-NUL terminated string
4928 in newFileName. It won't, but gcc's analysis doesn't
4929 quite go far enough to discover this. */
4930 newFileName
[MAX_FILENAME_LENGTH
] = 0;
4934 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4935 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4938 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4940 if (linfo
.li_max_ops_per_insn
== 1)
4941 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4942 newFileName
, state_machine_regs
.line
,
4943 state_machine_regs
.address
);
4945 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4946 newFileName
, state_machine_regs
.line
,
4947 state_machine_regs
.address
,
4948 state_machine_regs
.op_index
);
4952 if (linfo
.li_max_ops_per_insn
== 1)
4953 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
4954 newFileName
, state_machine_regs
.line
,
4955 state_machine_regs
.address
);
4957 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4958 newFileName
, state_machine_regs
.line
,
4959 state_machine_regs
.address
,
4960 state_machine_regs
.op_index
);
4963 if (state_machine_regs
.view
)
4964 printf (" %6u", state_machine_regs
.view
);
4968 if (state_machine_regs
.is_stmt
)
4972 state_machine_regs
.view
++;
4974 if (xop
== -DW_LNE_end_sequence
)
4976 reset_state_machine (linfo
.li_default_is_stmt
);
4991 if (directory_table
)
4993 free (directory_table
);
4994 directory_table
= NULL
;
5005 display_debug_lines (struct dwarf_section
*section
, void *file
)
5007 unsigned char *data
= section
->start
;
5008 unsigned char *end
= data
+ section
->size
;
5010 int retValDecoded
= 1;
5012 if (do_debug_lines
== 0)
5013 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5015 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5016 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5018 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5019 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5021 if (!retValRaw
|| !retValDecoded
)
5028 find_debug_info_for_offset (unsigned long offset
)
5032 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5035 for (i
= 0; i
< num_debug_info_entries
; i
++)
5036 if (debug_information
[i
].cu_offset
== offset
)
5037 return debug_information
+ i
;
5043 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5045 /* See gdb/gdb-index.h. */
5046 static const char * const kinds
[] =
5058 return _ (kinds
[kind
]);
5062 display_debug_pubnames_worker (struct dwarf_section
*section
,
5063 void *file ATTRIBUTE_UNUSED
,
5066 DWARF2_Internal_PubNames names
;
5067 unsigned char *start
= section
->start
;
5068 unsigned char *end
= start
+ section
->size
;
5070 /* It does not matter if this load fails,
5071 we test for that later on. */
5072 load_debug_info (file
);
5074 introduce (section
, FALSE
);
5078 unsigned char *data
;
5079 unsigned long sec_off
;
5080 unsigned int offset_size
, initial_length_size
;
5082 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5083 if (names
.pn_length
== 0xffffffff)
5085 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5087 initial_length_size
= 12;
5092 initial_length_size
= 4;
5095 sec_off
= start
- section
->start
;
5096 if (sec_off
+ names
.pn_length
< sec_off
5097 || sec_off
+ names
.pn_length
> section
->size
)
5099 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5101 sec_off
- initial_length_size
,
5102 dwarf_vmatoa ("x", names
.pn_length
));
5107 start
+= names
.pn_length
;
5109 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5110 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5112 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5113 && num_debug_info_entries
> 0
5114 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5115 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5116 (unsigned long) names
.pn_offset
, section
->name
);
5118 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5120 printf (_(" Length: %ld\n"),
5121 (long) names
.pn_length
);
5122 printf (_(" Version: %d\n"),
5124 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5125 (unsigned long) names
.pn_offset
);
5126 printf (_(" Size of area in .debug_info section: %ld\n"),
5127 (long) names
.pn_size
);
5129 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5131 static int warned
= 0;
5135 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5143 printf (_("\n Offset Kind Name\n"));
5145 printf (_("\n Offset\tName\n"));
5149 bfd_size_type maxprint
;
5152 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5157 data
+= offset_size
;
5160 maxprint
= (end
- data
) - 1;
5164 unsigned int kind_data
;
5165 gdb_index_symbol_kind kind
;
5166 const char *kind_name
;
5169 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5172 /* GCC computes the kind as the upper byte in the CU index
5173 word, and then right shifts it by the CU index size.
5174 Left shift KIND to where the gdb-index.h accessor macros
5176 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5177 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5178 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5179 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5180 printf (" %-6lx %s,%-10s %.*s\n",
5181 (unsigned long) offset
, is_static
? _("s") : _("g"),
5182 kind_name
, (int) maxprint
, data
);
5185 printf (" %-6lx\t%.*s\n",
5186 (unsigned long) offset
, (int) maxprint
, data
);
5188 data
+= strnlen ((char *) data
, maxprint
) + 1;
5199 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5201 return display_debug_pubnames_worker (section
, file
, 0);
5205 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5207 return display_debug_pubnames_worker (section
, file
, 1);
5211 display_debug_macinfo (struct dwarf_section
*section
,
5212 void *file ATTRIBUTE_UNUSED
)
5214 unsigned char *start
= section
->start
;
5215 unsigned char *end
= start
+ section
->size
;
5216 unsigned char *curr
= start
;
5217 enum dwarf_macinfo_record_type op
;
5219 introduce (section
, FALSE
);
5223 unsigned int lineno
;
5224 const unsigned char *string
;
5226 op
= (enum dwarf_macinfo_record_type
) *curr
;
5231 case DW_MACINFO_start_file
:
5233 unsigned int filenum
;
5235 READ_ULEB (lineno
, curr
, end
);
5236 READ_ULEB (filenum
, curr
, end
);
5237 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5242 case DW_MACINFO_end_file
:
5243 printf (_(" DW_MACINFO_end_file\n"));
5246 case DW_MACINFO_define
:
5247 READ_ULEB (lineno
, curr
, end
);
5249 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5250 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5254 case DW_MACINFO_undef
:
5255 READ_ULEB (lineno
, curr
, end
);
5257 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5258 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5262 case DW_MACINFO_vendor_ext
:
5264 unsigned int constant
;
5266 READ_ULEB (constant
, curr
, end
);
5268 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5269 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5279 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5280 filename and dirname corresponding to file name table entry with index
5281 FILEIDX. Return NULL on failure. */
5283 static unsigned char *
5284 get_line_filename_and_dirname (dwarf_vma line_offset
,
5286 unsigned char **dir_name
)
5288 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5289 unsigned char *hdrptr
, *dirtable
, *file_name
;
5290 unsigned int offset_size
, initial_length_size
;
5291 unsigned int version
, opcode_base
;
5292 dwarf_vma length
, diridx
;
5293 const unsigned char * end
;
5296 if (section
->start
== NULL
5297 || line_offset
>= section
->size
5301 hdrptr
= section
->start
+ line_offset
;
5302 end
= section
->start
+ section
->size
;
5304 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5305 if (length
== 0xffffffff)
5307 /* This section is 64-bit DWARF 3. */
5308 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5310 initial_length_size
= 12;
5315 initial_length_size
= 4;
5317 if (length
+ initial_length_size
< length
5318 || length
+ initial_length_size
> section
->size
)
5321 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5322 if (version
!= 2 && version
!= 3 && version
!= 4)
5324 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5326 hdrptr
++; /* Skip max_ops_per_insn. */
5327 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5329 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5330 if (opcode_base
== 0)
5333 hdrptr
+= opcode_base
- 1;
5338 /* Skip over dirname table. */
5339 while (*hdrptr
!= '\0')
5341 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5345 hdrptr
++; /* Skip the NUL at the end of the table. */
5347 /* Now skip over preceding filename table entries. */
5348 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5350 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5351 SKIP_ULEB (hdrptr
, end
);
5352 SKIP_ULEB (hdrptr
, end
);
5353 SKIP_ULEB (hdrptr
, end
);
5355 if (hdrptr
>= end
|| *hdrptr
== '\0')
5359 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5362 READ_ULEB (diridx
, hdrptr
, end
);
5365 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5366 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5367 if (dirtable
>= end
|| *dirtable
== '\0')
5369 *dir_name
= dirtable
;
5374 display_debug_macro (struct dwarf_section
*section
,
5377 unsigned char *start
= section
->start
;
5378 unsigned char *end
= start
+ section
->size
;
5379 unsigned char *curr
= start
;
5380 unsigned char *extended_op_buf
[256];
5382 load_debug_section_with_follow (str
, file
);
5383 load_debug_section_with_follow (line
, file
);
5385 introduce (section
, FALSE
);
5389 unsigned int lineno
, version
, flags
;
5390 unsigned int offset_size
= 4;
5391 const unsigned char *string
;
5392 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5393 unsigned char **extended_ops
= NULL
;
5395 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5396 if (version
!= 4 && version
!= 5)
5398 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5403 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5406 printf (_(" Offset: 0x%lx\n"),
5407 (unsigned long) sec_offset
);
5408 printf (_(" Version: %d\n"), version
);
5409 printf (_(" Offset size: %d\n"), offset_size
);
5412 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5413 printf (_(" Offset into .debug_line: 0x%lx\n"),
5414 (unsigned long) line_offset
);
5418 unsigned int i
, count
, op
;
5421 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5423 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5424 extended_ops
= extended_op_buf
;
5427 printf (_(" Extension opcode arguments:\n"));
5428 for (i
= 0; i
< count
; i
++)
5430 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5431 extended_ops
[op
] = curr
;
5432 READ_ULEB (nargs
, curr
, end
);
5434 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5437 printf (_(" DW_MACRO_%02x arguments: "), op
);
5438 for (n
= 0; n
< nargs
; n
++)
5442 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5443 printf ("%s%s", get_FORM_name (form
),
5444 n
== nargs
- 1 ? "\n" : ", ");
5454 case DW_FORM_block1
:
5455 case DW_FORM_block2
:
5456 case DW_FORM_block4
:
5458 case DW_FORM_string
:
5460 case DW_FORM_sec_offset
:
5463 error (_("Invalid extension opcode form %s\n"),
5464 get_FORM_name (form
));
5480 error (_(".debug_macro section not zero terminated\n"));
5484 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5490 case DW_MACRO_start_file
:
5492 unsigned int filenum
;
5493 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5495 READ_ULEB (lineno
, curr
, end
);
5496 READ_ULEB (filenum
, curr
, end
);
5498 if ((flags
& 2) == 0)
5499 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5502 = get_line_filename_and_dirname (line_offset
, filenum
,
5504 if (file_name
== NULL
)
5505 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5508 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5510 dir_name
!= NULL
? (const char *) dir_name
: "",
5511 dir_name
!= NULL
? "/" : "", file_name
);
5515 case DW_MACRO_end_file
:
5516 printf (_(" DW_MACRO_end_file\n"));
5519 case DW_MACRO_define
:
5520 READ_ULEB (lineno
, curr
, end
);
5522 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5523 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5527 case DW_MACRO_undef
:
5528 READ_ULEB (lineno
, curr
, end
);
5530 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5531 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5535 case DW_MACRO_define_strp
:
5536 READ_ULEB (lineno
, curr
, end
);
5537 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5538 string
= fetch_indirect_string (offset
);
5539 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5543 case DW_MACRO_undef_strp
:
5544 READ_ULEB (lineno
, curr
, end
);
5545 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5546 string
= fetch_indirect_string (offset
);
5547 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5551 case DW_MACRO_import
:
5552 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5553 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5554 (unsigned long) offset
);
5557 case DW_MACRO_define_sup
:
5558 READ_ULEB (lineno
, curr
, end
);
5559 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5560 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5561 lineno
, (unsigned long) offset
);
5564 case DW_MACRO_undef_sup
:
5565 READ_ULEB (lineno
, curr
, end
);
5566 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5567 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5568 lineno
, (unsigned long) offset
);
5571 case DW_MACRO_import_sup
:
5572 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5573 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5574 (unsigned long) offset
);
5578 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5580 error (_(" Unknown macro opcode %02x seen\n"), op
);
5585 /* Skip over unhandled opcodes. */
5587 unsigned char *desc
= extended_ops
[op
];
5588 READ_ULEB (nargs
, desc
, end
);
5591 printf (_(" DW_MACRO_%02x\n"), op
);
5594 printf (_(" DW_MACRO_%02x -"), op
);
5595 for (n
= 0; n
< nargs
; n
++)
5599 /* DW_FORM_implicit_const is not expected here. */
5600 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5602 = read_and_display_attr_value (0, val
, 0,
5603 start
, curr
, end
, 0, 0, offset_size
,
5604 version
, NULL
, 0, NULL
,
5622 display_debug_abbrev (struct dwarf_section
*section
,
5623 void *file ATTRIBUTE_UNUSED
)
5625 abbrev_entry
*entry
;
5626 unsigned char *start
= section
->start
;
5627 unsigned char *end
= start
+ section
->size
;
5629 introduce (section
, FALSE
);
5633 unsigned char *last
;
5638 start
= process_abbrev_section (start
, end
);
5640 if (first_abbrev
== NULL
)
5643 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5645 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5649 printf (" %ld %s [%s]\n",
5651 get_TAG_name (entry
->tag
),
5652 entry
->children
? _("has children") : _("no children"));
5654 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5656 printf (" %-18s %s",
5657 get_AT_name (attr
->attribute
),
5658 get_FORM_name (attr
->form
));
5659 if (attr
->form
== DW_FORM_implicit_const
)
5660 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5672 /* Return true when ADDR is the maximum address, when addresses are
5673 POINTER_SIZE bytes long. */
5676 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5678 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5679 return ((addr
& mask
) == mask
);
5682 /* Display a view pair list starting at *VSTART_PTR and ending at
5683 VLISTEND within SECTION. */
5686 display_view_pair_list (struct dwarf_section
*section
,
5687 unsigned char **vstart_ptr
,
5688 unsigned int debug_info_entry
,
5689 unsigned char *vlistend
)
5691 unsigned char *vstart
= *vstart_ptr
;
5692 unsigned char *section_end
= section
->start
+ section
->size
;
5693 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5695 if (vlistend
< section_end
)
5696 section_end
= vlistend
;
5700 while (vstart
< section_end
)
5702 dwarf_vma off
= vstart
- section
->start
;
5703 dwarf_vma vbegin
, vend
;
5705 READ_ULEB (vbegin
, vstart
, section_end
);
5706 if (vstart
== section_end
)
5709 READ_ULEB (vend
, vstart
, section_end
);
5710 printf (" %8.8lx ", (unsigned long) off
);
5712 print_dwarf_view (vbegin
, pointer_size
, 1);
5713 print_dwarf_view (vend
, pointer_size
, 1);
5714 printf (_("location view pair\n"));
5718 *vstart_ptr
= vstart
;
5721 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5724 display_loc_list (struct dwarf_section
*section
,
5725 unsigned char **start_ptr
,
5726 unsigned int debug_info_entry
,
5728 dwarf_vma base_address
,
5729 unsigned char **vstart_ptr
,
5732 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5733 unsigned char *section_end
= section
->start
+ section
->size
;
5734 unsigned long cu_offset
;
5735 unsigned int pointer_size
;
5736 unsigned int offset_size
;
5741 unsigned short length
;
5742 int need_frame_base
;
5744 if (debug_info_entry
>= num_debug_info_entries
)
5746 warn (_("No debug information available for loc lists of entry: %u\n"),
5751 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5752 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5753 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5754 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5756 if (pointer_size
< 2 || pointer_size
> 8)
5758 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5759 pointer_size
, debug_info_entry
);
5765 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5766 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5768 if (start
+ 2 * pointer_size
> section_end
)
5770 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5771 (unsigned long) offset
);
5775 printf (" %8.8lx ", (unsigned long) off
);
5777 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5778 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5780 if (begin
== 0 && end
== 0)
5782 /* PR 18374: In a object file we can have a location list that
5783 starts with a begin and end of 0 because there are relocations
5784 that need to be applied to the addresses. Actually applying
5785 the relocations now does not help as they will probably resolve
5786 to 0, since the object file has not been fully linked. Real
5787 end of list markers will not have any relocations against them. */
5788 if (! reloc_at (section
, off
)
5789 && ! reloc_at (section
, off
+ pointer_size
))
5791 printf (_("<End of list>\n"));
5796 /* Check base address specifiers. */
5797 if (is_max_address (begin
, pointer_size
)
5798 && !is_max_address (end
, pointer_size
))
5801 print_dwarf_vma (begin
, pointer_size
);
5802 print_dwarf_vma (end
, pointer_size
);
5803 printf (_("(base address)\n"));
5809 off
= offset
+ (vstart
- *start_ptr
);
5811 READ_ULEB (vbegin
, vstart
, section_end
);
5812 print_dwarf_view (vbegin
, pointer_size
, 1);
5814 READ_ULEB (vend
, vstart
, section_end
);
5815 print_dwarf_view (vend
, pointer_size
, 1);
5817 printf (_("views at %8.8lx for:\n %*s "),
5818 (unsigned long) off
, 8, "");
5821 if (start
+ 2 > section_end
)
5823 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5824 (unsigned long) offset
);
5828 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5830 if (start
+ length
> section_end
)
5832 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5833 (unsigned long) offset
);
5837 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5838 print_dwarf_vma (end
+ base_address
, pointer_size
);
5841 need_frame_base
= decode_location_expression (start
,
5846 cu_offset
, section
);
5849 if (need_frame_base
&& !has_frame_base
)
5850 printf (_(" [without DW_AT_frame_base]"));
5852 if (begin
== end
&& vbegin
== vend
)
5853 fputs (_(" (start == end)"), stdout
);
5854 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5855 fputs (_(" (start > end)"), stdout
);
5863 *vstart_ptr
= vstart
;
5866 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5869 display_loclists_list (struct dwarf_section
*section
,
5870 unsigned char **start_ptr
,
5871 unsigned int debug_info_entry
,
5873 dwarf_vma base_address
,
5874 unsigned char **vstart_ptr
,
5877 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5878 unsigned char *section_end
= section
->start
+ section
->size
;
5879 unsigned long cu_offset
;
5880 unsigned int pointer_size
;
5881 unsigned int offset_size
;
5884 /* Initialize it due to a false compiler warning. */
5885 dwarf_vma begin
= -1, vbegin
= -1;
5886 dwarf_vma end
= -1, vend
= -1;
5888 int need_frame_base
;
5890 if (debug_info_entry
>= num_debug_info_entries
)
5892 warn (_("No debug information available for "
5893 "loclists lists of entry: %u\n"),
5898 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5899 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5900 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5901 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5903 if (pointer_size
< 2 || pointer_size
> 8)
5905 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5906 pointer_size
, debug_info_entry
);
5912 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5913 enum dwarf_location_list_entry_type llet
;
5915 if (start
+ 1 > section_end
)
5917 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5918 (unsigned long) offset
);
5922 printf (" %8.8lx ", (unsigned long) off
);
5924 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5926 if (vstart
&& llet
== DW_LLE_offset_pair
)
5928 off
= offset
+ (vstart
- *start_ptr
);
5930 READ_ULEB (vbegin
, vstart
, section_end
);
5931 print_dwarf_view (vbegin
, pointer_size
, 1);
5933 READ_ULEB (vend
, vstart
, section_end
);
5934 print_dwarf_view (vend
, pointer_size
, 1);
5936 printf (_("views at %8.8lx for:\n %*s "),
5937 (unsigned long) off
, 8, "");
5942 case DW_LLE_end_of_list
:
5943 printf (_("<End of list>\n"));
5945 case DW_LLE_offset_pair
:
5946 READ_ULEB (begin
, start
, section_end
);
5947 READ_ULEB (end
, start
, section_end
);
5949 case DW_LLE_base_address
:
5950 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
5952 print_dwarf_vma (base_address
, pointer_size
);
5953 printf (_("(base address)\n"));
5955 #ifdef DW_LLE_view_pair
5956 case DW_LLE_view_pair
:
5958 printf (_("View pair entry in loclist with locviews attribute\n"));
5959 READ_ULEB (vbegin
, start
, section_end
);
5960 print_dwarf_view (vbegin
, pointer_size
, 1);
5962 READ_ULEB (vend
, start
, section_end
);
5963 print_dwarf_view (vend
, pointer_size
, 1);
5965 printf (_("views for:\n"));
5969 error (_("Invalid location list entry type %d\n"), llet
);
5972 if (llet
== DW_LLE_end_of_list
)
5974 if (llet
!= DW_LLE_offset_pair
)
5977 if (start
+ 2 > section_end
)
5979 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5980 (unsigned long) offset
);
5984 READ_ULEB (length
, start
, section_end
);
5986 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5987 print_dwarf_vma (end
+ base_address
, pointer_size
);
5990 need_frame_base
= decode_location_expression (start
,
5995 cu_offset
, section
);
5998 if (need_frame_base
&& !has_frame_base
)
5999 printf (_(" [without DW_AT_frame_base]"));
6001 if (begin
== end
&& vbegin
== vend
)
6002 fputs (_(" (start == end)"), stdout
);
6003 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6004 fputs (_(" (start > end)"), stdout
);
6012 if (vbegin
!= vm1
|| vend
!= vm1
)
6013 printf (_("Trailing view pair not used in a range"));
6016 *vstart_ptr
= vstart
;
6019 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6020 right-adjusted in a field of length LEN, and followed by a space. */
6023 print_addr_index (unsigned int idx
, unsigned int len
)
6025 static char buf
[15];
6026 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6027 printf ("%*s ", len
, buf
);
6030 /* Display a location list from a .dwo section. It uses address indexes rather
6031 than embedded addresses. This code closely follows display_loc_list, but the
6032 two are sufficiently different that combining things is very ugly. */
6035 display_loc_list_dwo (struct dwarf_section
*section
,
6036 unsigned char **start_ptr
,
6037 unsigned int debug_info_entry
,
6039 unsigned char **vstart_ptr
,
6042 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6043 unsigned char *section_end
= section
->start
+ section
->size
;
6044 unsigned long cu_offset
;
6045 unsigned int pointer_size
;
6046 unsigned int offset_size
;
6049 unsigned short length
;
6050 int need_frame_base
;
6053 if (debug_info_entry
>= num_debug_info_entries
)
6055 warn (_("No debug information for loc lists of entry: %u\n"),
6060 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6061 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6062 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6063 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6065 if (pointer_size
< 2 || pointer_size
> 8)
6067 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6068 pointer_size
, debug_info_entry
);
6074 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6076 if (start
>= section_end
)
6078 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6079 (unsigned long) offset
);
6083 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6096 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6098 READ_ULEB (view
, vstart
, section_end
);
6099 print_dwarf_view (view
, 8, 1);
6101 READ_ULEB (view
, vstart
, section_end
);
6102 print_dwarf_view (view
, 8, 1);
6104 printf (_("views at %8.8lx for:\n %*s "),
6105 (unsigned long) off
, 8, "");
6113 case 0: /* A terminating entry. */
6115 *vstart_ptr
= vstart
;
6116 printf (_("<End of list>\n"));
6118 case 1: /* A base-address entry. */
6119 READ_ULEB (idx
, start
, section_end
);
6120 print_addr_index (idx
, 8);
6121 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6122 printf (_("(base address selection entry)\n"));
6124 case 2: /* A start/end entry. */
6125 READ_ULEB (idx
, start
, section_end
);
6126 print_addr_index (idx
, 8);
6127 READ_ULEB (idx
, start
, section_end
);
6128 print_addr_index (idx
, 8);
6130 case 3: /* A start/length entry. */
6131 READ_ULEB (idx
, start
, section_end
);
6132 print_addr_index (idx
, 8);
6133 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6134 printf ("%08x ", idx
);
6136 case 4: /* An offset pair entry. */
6137 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6138 printf ("%08x ", idx
);
6139 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6140 printf ("%08x ", idx
);
6143 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6145 *vstart_ptr
= vstart
;
6149 if (start
+ 2 > section_end
)
6151 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6152 (unsigned long) offset
);
6156 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6157 if (start
+ length
> section_end
)
6159 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6160 (unsigned long) offset
);
6165 need_frame_base
= decode_location_expression (start
,
6170 cu_offset
, section
);
6173 if (need_frame_base
&& !has_frame_base
)
6174 printf (_(" [without DW_AT_frame_base]"));
6182 *vstart_ptr
= vstart
;
6185 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6188 static dwarf_vma
*loc_offsets
, *loc_views
;
6191 loc_offsets_compar (const void *ap
, const void *bp
)
6193 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6194 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6196 int ret
= (a
> b
) - (b
> a
);
6200 a
= loc_views
[*(const unsigned int *) ap
];
6201 b
= loc_views
[*(const unsigned int *) bp
];
6203 ret
= (a
> b
) - (b
> a
);
6209 display_debug_loc (struct dwarf_section
*section
, void *file
)
6211 unsigned char *start
= section
->start
, *vstart
= NULL
;
6212 unsigned long bytes
;
6213 unsigned char *section_begin
= start
;
6214 unsigned int num_loc_list
= 0;
6215 unsigned long last_offset
= 0;
6216 unsigned long last_view
= 0;
6217 unsigned int first
= 0;
6220 int seen_first_offset
= 0;
6221 int locs_sorted
= 1;
6222 unsigned char *next
= start
, *vnext
= vstart
;
6223 unsigned int *array
= NULL
;
6224 const char *suffix
= strrchr (section
->name
, '.');
6225 bfd_boolean is_dwo
= FALSE
;
6226 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6227 dwarf_vma expected_start
= 0;
6229 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6232 bytes
= section
->size
;
6236 printf (_("\nThe %s section is empty.\n"), section
->name
);
6242 unsigned char *hdrptr
= section_begin
;
6243 dwarf_vma ll_length
;
6244 unsigned short ll_version
;
6245 unsigned char *end
= section_begin
+ section
->size
;
6246 unsigned char address_size
, segment_selector_size
;
6247 uint32_t offset_entry_count
;
6249 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6250 if (ll_length
== 0xffffffff)
6251 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6253 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6254 if (ll_version
!= 5)
6256 warn (_("The %s section contains corrupt or "
6257 "unsupported version number: %d.\n"),
6258 section
->name
, ll_version
);
6262 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6264 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6265 if (segment_selector_size
!= 0)
6267 warn (_("The %s section contains "
6268 "unsupported segment selector size: %d.\n"),
6269 section
->name
, segment_selector_size
);
6273 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6274 if (offset_entry_count
!= 0)
6276 warn (_("The %s section contains "
6277 "unsupported offset entry count: %d.\n"),
6278 section
->name
, offset_entry_count
);
6282 expected_start
= hdrptr
- section_begin
;
6285 if (load_debug_info (file
) == 0)
6287 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6292 /* Check the order of location list in .debug_info section. If
6293 offsets of location lists are in the ascending order, we can
6294 use `debug_information' directly. */
6295 for (i
= 0; i
< num_debug_info_entries
; i
++)
6299 num
= debug_information
[i
].num_loc_offsets
;
6300 if (num
> num_loc_list
)
6303 /* Check if we can use `debug_information' directly. */
6304 if (locs_sorted
&& num
!= 0)
6306 if (!seen_first_offset
)
6308 /* This is the first location list. */
6309 last_offset
= debug_information
[i
].loc_offsets
[0];
6310 last_view
= debug_information
[i
].loc_views
[0];
6312 seen_first_offset
= 1;
6318 for (; j
< num
; j
++)
6321 debug_information
[i
].loc_offsets
[j
]
6322 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6323 && last_view
> debug_information
[i
].loc_views
[j
]))
6328 last_offset
= debug_information
[i
].loc_offsets
[j
];
6329 last_view
= debug_information
[i
].loc_views
[j
];
6334 if (!seen_first_offset
)
6335 error (_("No location lists in .debug_info section!\n"));
6337 if (debug_information
[first
].num_loc_offsets
> 0
6338 && debug_information
[first
].loc_offsets
[0] != expected_start
6339 && debug_information
[first
].loc_views
[0] != expected_start
)
6340 warn (_("Location lists in %s section start at 0x%s\n"),
6342 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6345 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6347 introduce (section
, FALSE
);
6349 if (reloc_at (section
, 0))
6350 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6352 printf (_(" Offset Begin End Expression\n"));
6354 seen_first_offset
= 0;
6355 for (i
= first
; i
< num_debug_info_entries
; i
++)
6357 dwarf_vma offset
, voffset
;
6358 dwarf_vma base_address
;
6364 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6366 loc_offsets
= debug_information
[i
].loc_offsets
;
6367 loc_views
= debug_information
[i
].loc_views
;
6368 qsort (array
, debug_information
[i
].num_loc_offsets
,
6369 sizeof (*array
), loc_offsets_compar
);
6372 int adjacent_view_loclists
= 1;
6373 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6375 j
= locs_sorted
? k
: array
[k
];
6377 && (debug_information
[i
].loc_offsets
[locs_sorted
6378 ? k
- 1 : array
[k
- 1]]
6379 == debug_information
[i
].loc_offsets
[j
])
6380 && (debug_information
[i
].loc_views
[locs_sorted
6381 ? k
- 1 : array
[k
- 1]]
6382 == debug_information
[i
].loc_views
[j
]))
6384 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6385 offset
= debug_information
[i
].loc_offsets
[j
];
6386 next
= section_begin
+ offset
;
6387 voffset
= debug_information
[i
].loc_views
[j
];
6389 vnext
= section_begin
+ voffset
;
6392 base_address
= debug_information
[i
].base_address
;
6394 if (vnext
&& vnext
< next
)
6397 display_view_pair_list (section
, &vstart
, i
, next
);
6402 if (!seen_first_offset
|| !adjacent_view_loclists
)
6403 seen_first_offset
= 1;
6407 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6408 (unsigned long) (start
- section_begin
),
6409 (unsigned long) offset
);
6410 else if (start
> next
)
6411 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6412 (unsigned long) (start
- section_begin
),
6413 (unsigned long) offset
);
6418 if (offset
>= bytes
)
6420 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6421 (unsigned long) offset
);
6425 if (vnext
&& voffset
>= bytes
)
6427 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6428 (unsigned long) voffset
);
6435 display_loc_list_dwo (section
, &start
, i
, offset
,
6436 &vstart
, has_frame_base
);
6438 display_loc_list (section
, &start
, i
, offset
, base_address
,
6439 &vstart
, has_frame_base
);
6444 warn (_("DWO is not yet supported.\n"));
6446 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6447 &vstart
, has_frame_base
);
6450 /* FIXME: this arrangement is quite simplistic. Nothing
6451 requires locview lists to be adjacent to corresponding
6452 loclists, and a single loclist could be augmented by
6453 different locview lists, and vice-versa, unlikely as it
6454 is that it would make sense to do so. Hopefully we'll
6455 have view pair support built into loclists before we ever
6456 need to address all these possibilities. */
6457 if (adjacent_view_loclists
&& vnext
6458 && vnext
!= start
&& vstart
!= next
)
6460 adjacent_view_loclists
= 0;
6461 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6464 if (vnext
&& vnext
== start
)
6465 display_view_pair_list (section
, &start
, i
, vstart
);
6469 if (start
< section
->start
+ section
->size
)
6470 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6471 "There are %ld unused bytes at the end of section %s\n",
6472 (long) (section
->start
+ section
->size
- start
)),
6473 (long) (section
->start
+ section
->size
- start
), section
->name
);
6480 display_debug_str (struct dwarf_section
*section
,
6481 void *file ATTRIBUTE_UNUSED
)
6483 unsigned char *start
= section
->start
;
6484 unsigned long bytes
= section
->size
;
6485 dwarf_vma addr
= section
->address
;
6489 printf (_("\nThe %s section is empty.\n"), section
->name
);
6493 introduce (section
, FALSE
);
6501 lbytes
= (bytes
> 16 ? 16 : bytes
);
6503 printf (" 0x%8.8lx ", (unsigned long) addr
);
6505 for (j
= 0; j
< 16; j
++)
6508 printf ("%2.2x", start
[j
]);
6516 for (j
= 0; j
< lbytes
; j
++)
6519 if (k
>= ' ' && k
< 0x80)
6538 display_debug_info (struct dwarf_section
*section
, void *file
)
6540 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6544 display_debug_types (struct dwarf_section
*section
, void *file
)
6546 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6550 display_trace_info (struct dwarf_section
*section
, void *file
)
6552 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6556 display_debug_aranges (struct dwarf_section
*section
,
6557 void *file ATTRIBUTE_UNUSED
)
6559 unsigned char *start
= section
->start
;
6560 unsigned char *end
= start
+ section
->size
;
6562 introduce (section
, FALSE
);
6564 /* It does not matter if this load fails,
6565 we test for that later on. */
6566 load_debug_info (file
);
6570 unsigned char *hdrptr
;
6571 DWARF2_Internal_ARange arange
;
6572 unsigned char *addr_ranges
;
6575 unsigned long sec_off
;
6576 unsigned char address_size
;
6578 unsigned int offset_size
;
6579 unsigned int initial_length_size
;
6583 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6584 if (arange
.ar_length
== 0xffffffff)
6586 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6588 initial_length_size
= 12;
6593 initial_length_size
= 4;
6596 sec_off
= hdrptr
- section
->start
;
6597 if (sec_off
+ arange
.ar_length
< sec_off
6598 || sec_off
+ arange
.ar_length
> section
->size
)
6600 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6602 sec_off
- initial_length_size
,
6603 dwarf_vmatoa ("x", arange
.ar_length
));
6607 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6608 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6610 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6611 && num_debug_info_entries
> 0
6612 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6613 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6614 (unsigned long) arange
.ar_info_offset
, section
->name
);
6616 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6617 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6619 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6621 /* PR 19872: A version number of 0 probably means that there is
6622 padding at the end of the .debug_aranges section. Gold puts
6623 it there when performing an incremental link, for example.
6624 So do not generate a warning in this case. */
6625 if (arange
.ar_version
)
6626 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6630 printf (_(" Length: %ld\n"),
6631 (long) arange
.ar_length
);
6632 printf (_(" Version: %d\n"), arange
.ar_version
);
6633 printf (_(" Offset into .debug_info: 0x%lx\n"),
6634 (unsigned long) arange
.ar_info_offset
);
6635 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6636 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6638 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6640 /* PR 17512: file: 001-108546-0.001:0.1. */
6641 if (address_size
== 0 || address_size
> 8)
6643 error (_("Invalid address size in %s section!\n"),
6648 /* The DWARF spec does not require that the address size be a power
6649 of two, but we do. This will have to change if we ever encounter
6650 an uneven architecture. */
6651 if ((address_size
& (address_size
- 1)) != 0)
6653 warn (_("Pointer size + Segment size is not a power of two.\n"));
6657 if (address_size
> 4)
6658 printf (_("\n Address Length\n"));
6660 printf (_("\n Address Length\n"));
6662 addr_ranges
= hdrptr
;
6664 /* Must pad to an alignment boundary that is twice the address size. */
6665 excess
= (hdrptr
- start
) % (2 * address_size
);
6667 addr_ranges
+= (2 * address_size
) - excess
;
6669 start
+= arange
.ar_length
+ initial_length_size
;
6671 while (addr_ranges
+ 2 * address_size
<= start
)
6673 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6674 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6677 print_dwarf_vma (address
, address_size
);
6678 print_dwarf_vma (length
, address_size
);
6688 /* Comparison function for qsort. */
6690 comp_addr_base (const void * v0
, const void * v1
)
6692 debug_info
*info0
= *(debug_info
**) v0
;
6693 debug_info
*info1
= *(debug_info
**) v1
;
6694 return info0
->addr_base
- info1
->addr_base
;
6697 /* Display the debug_addr section. */
6699 display_debug_addr (struct dwarf_section
*section
,
6702 debug_info
**debug_addr_info
;
6703 unsigned char *entry
;
6708 if (section
->size
== 0)
6710 printf (_("\nThe %s section is empty.\n"), section
->name
);
6714 if (load_debug_info (file
) == 0)
6716 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6721 introduce (section
, FALSE
);
6723 /* PR 17531: file: cf38d01b.
6724 We use xcalloc because a corrupt file may not have initialised all of the
6725 fields in the debug_info structure, which means that the sort below might
6726 try to move uninitialised data. */
6727 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6728 sizeof (debug_info
*));
6731 for (i
= 0; i
< num_debug_info_entries
; i
++)
6732 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6734 /* PR 17531: file: cf38d01b. */
6735 if (debug_information
[i
].addr_base
>= section
->size
)
6736 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6737 (unsigned long) debug_information
[i
].addr_base
, i
);
6739 debug_addr_info
[count
++] = debug_information
+ i
;
6742 /* Add a sentinel to make iteration convenient. */
6743 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6744 debug_addr_info
[count
]->addr_base
= section
->size
;
6745 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6747 for (i
= 0; i
< count
; i
++)
6750 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6752 printf (_(" For compilation unit at offset 0x%s:\n"),
6753 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6755 printf (_("\tIndex\tAddress\n"));
6756 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6757 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6761 dwarf_vma base
= byte_get (entry
, address_size
);
6762 printf (_("\t%d:\t"), idx
);
6763 print_dwarf_vma (base
, address_size
);
6765 entry
+= address_size
;
6771 free (debug_addr_info
);
6775 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6778 display_debug_str_offsets (struct dwarf_section
*section
,
6779 void *file ATTRIBUTE_UNUSED
)
6781 if (section
->size
== 0)
6783 printf (_("\nThe %s section is empty.\n"), section
->name
);
6786 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6787 what the offset size is for this section. */
6791 /* Each debug_information[x].range_lists[y] gets this representation for
6792 sorting purposes. */
6796 /* The debug_information[x].range_lists[y] value. */
6797 dwarf_vma ranges_offset
;
6799 /* Original debug_information to find parameters of the data. */
6800 debug_info
*debug_info_p
;
6803 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6806 range_entry_compar (const void *ap
, const void *bp
)
6808 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6809 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6810 const dwarf_vma a
= a_re
->ranges_offset
;
6811 const dwarf_vma b
= b_re
->ranges_offset
;
6813 return (a
> b
) - (b
> a
);
6817 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6818 unsigned int pointer_size
, unsigned long offset
,
6819 unsigned long base_address
)
6821 while (start
< finish
)
6826 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6827 if (start
>= finish
)
6829 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6832 printf (" %8.8lx ", offset
);
6834 if (begin
== 0 && end
== 0)
6836 printf (_("<End of list>\n"));
6840 /* Check base address specifiers. */
6841 if (is_max_address (begin
, pointer_size
)
6842 && !is_max_address (end
, pointer_size
))
6845 print_dwarf_vma (begin
, pointer_size
);
6846 print_dwarf_vma (end
, pointer_size
);
6847 printf ("(base address)\n");
6851 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6852 print_dwarf_vma (end
+ base_address
, pointer_size
);
6855 fputs (_("(start == end)"), stdout
);
6856 else if (begin
> end
)
6857 fputs (_("(start > end)"), stdout
);
6864 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
6865 unsigned int pointer_size
, unsigned long offset
,
6866 unsigned long base_address
)
6868 unsigned char *next
= start
;
6872 unsigned long off
= offset
+ (start
- next
);
6873 enum dwarf_range_list_entry rlet
;
6874 /* Initialize it due to a false compiler warning. */
6875 dwarf_vma begin
= -1, length
, end
= -1;
6877 if (start
+ 1 > finish
)
6879 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6884 printf (" %8.8lx ", off
);
6886 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
6890 case DW_RLE_end_of_list
:
6891 printf (_("<End of list>\n"));
6893 case DW_RLE_base_address
:
6894 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
6895 print_dwarf_vma (base_address
, pointer_size
);
6896 printf (_("(base address)\n"));
6898 case DW_RLE_start_length
:
6899 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6900 READ_ULEB (length
, start
, finish
);
6901 end
= begin
+ length
;
6903 case DW_RLE_offset_pair
:
6904 READ_ULEB (begin
, start
, finish
);
6905 READ_ULEB (end
, start
, finish
);
6907 case DW_RLE_start_end
:
6908 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6909 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6912 error (_("Invalid range list entry type %d\n"), rlet
);
6913 rlet
= DW_RLE_end_of_list
;
6916 if (rlet
== DW_RLE_end_of_list
)
6918 if (rlet
== DW_RLE_base_address
)
6921 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6922 print_dwarf_vma (end
+ base_address
, pointer_size
);
6925 fputs (_("(start == end)"), stdout
);
6926 else if (begin
> end
)
6927 fputs (_("(start > end)"), stdout
);
6934 display_debug_ranges (struct dwarf_section
*section
,
6935 void *file ATTRIBUTE_UNUSED
)
6937 unsigned char *start
= section
->start
;
6938 unsigned char *last_start
= start
;
6939 unsigned long bytes
= section
->size
;
6940 unsigned char *section_begin
= start
;
6941 unsigned char *finish
= start
+ bytes
;
6942 unsigned int num_range_list
, i
;
6943 struct range_entry
*range_entries
, *range_entry_fill
;
6944 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
6945 /* Initialize it due to a false compiler warning. */
6946 unsigned char address_size
= 0;
6947 dwarf_vma last_offset
= 0;
6951 printf (_("\nThe %s section is empty.\n"), section
->name
);
6957 dwarf_vma initial_length
;
6958 unsigned int initial_length_size
;
6959 unsigned char segment_selector_size
;
6960 unsigned int offset_size
, offset_entry_count
;
6961 unsigned short version
;
6963 /* Get and check the length of the block. */
6964 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
6966 if (initial_length
== 0xffffffff)
6968 /* This section is 64-bit DWARF 3. */
6969 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
6971 initial_length_size
= 12;
6976 initial_length_size
= 4;
6979 if (initial_length
+ initial_length_size
> section
->size
)
6981 /* If the length field has a relocation against it, then we should
6982 not complain if it is inaccurate (and probably negative).
6983 It is copied from .debug_line handling code. */
6984 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
6986 initial_length
= (finish
- start
) - initial_length_size
;
6990 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6991 (long) initial_length
);
6996 /* Get and check the version number. */
6997 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7001 warn (_("Only DWARF version 5 debug_rnglists info "
7002 "is currently supported.\n"));
7006 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7008 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7009 if (segment_selector_size
!= 0)
7011 warn (_("The %s section contains "
7012 "unsupported segment selector size: %d.\n"),
7013 section
->name
, segment_selector_size
);
7017 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7018 if (offset_entry_count
!= 0)
7020 warn (_("The %s section contains "
7021 "unsupported offset entry count: %u.\n"),
7022 section
->name
, offset_entry_count
);
7027 if (load_debug_info (file
) == 0)
7029 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7035 for (i
= 0; i
< num_debug_info_entries
; i
++)
7036 num_range_list
+= debug_information
[i
].num_range_lists
;
7038 if (num_range_list
== 0)
7040 /* This can happen when the file was compiled with -gsplit-debug
7041 which removes references to range lists from the primary .o file. */
7042 printf (_("No range lists in .debug_info section.\n"));
7046 range_entries
= (struct range_entry
*)
7047 xmalloc (sizeof (*range_entries
) * num_range_list
);
7048 range_entry_fill
= range_entries
;
7050 for (i
= 0; i
< num_debug_info_entries
; i
++)
7052 debug_info
*debug_info_p
= &debug_information
[i
];
7055 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7057 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7058 range_entry_fill
->debug_info_p
= debug_info_p
;
7063 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7064 range_entry_compar
);
7066 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7067 warn (_("Range lists in %s section start at 0x%lx\n"),
7068 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7070 introduce (section
, FALSE
);
7072 printf (_(" Offset Begin End\n"));
7074 for (i
= 0; i
< num_range_list
; i
++)
7076 struct range_entry
*range_entry
= &range_entries
[i
];
7077 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7078 unsigned int pointer_size
;
7080 unsigned char *next
;
7081 dwarf_vma base_address
;
7083 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7084 offset
= range_entry
->ranges_offset
;
7085 next
= section_begin
+ offset
;
7086 base_address
= debug_info_p
->base_address
;
7088 /* PR 17512: file: 001-101485-0.001:0.1. */
7089 if (pointer_size
< 2 || pointer_size
> 8)
7091 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7092 pointer_size
, (unsigned long) offset
);
7096 if (next
< section_begin
|| next
>= finish
)
7098 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7099 (unsigned long) offset
, i
);
7103 /* If multiple DWARF entities reference the same range then we will
7104 have multiple entries in the `range_entries' list for the same
7105 offset. Thanks to the sort above these will all be consecutive in
7106 the `range_entries' list, so we can easily ignore duplicates
7108 if (i
> 0 && last_offset
== offset
)
7110 last_offset
= offset
;
7112 if (dwarf_check
!= 0 && i
> 0)
7115 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7116 (unsigned long) (start
- section_begin
),
7117 (unsigned long) (next
- section_begin
), section
->name
);
7118 else if (start
> next
)
7120 if (next
== last_start
)
7122 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7123 (unsigned long) (start
- section_begin
),
7124 (unsigned long) (next
- section_begin
), section
->name
);
7131 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7132 (start
, finish
, pointer_size
, offset
, base_address
);
7136 free (range_entries
);
7141 typedef struct Frame_Chunk
7143 struct Frame_Chunk
*next
;
7144 unsigned char *chunk_start
;
7146 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7147 short int *col_type
;
7150 unsigned int code_factor
;
7154 unsigned int cfa_reg
;
7155 dwarf_vma cfa_offset
;
7157 unsigned char fde_encoding
;
7158 unsigned char cfa_exp
;
7159 unsigned char ptr_size
;
7160 unsigned char segment_size
;
7164 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7165 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7166 static const char *const *dwarf_regnames
;
7167 static unsigned int dwarf_regnames_count
;
7170 /* A marker for a col_type that means this column was never referenced
7171 in the frame info. */
7172 #define DW_CFA_unreferenced (-1)
7174 /* Return 0 if no more space is needed, 1 if more space is needed,
7175 -1 for invalid reg. */
7178 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7180 unsigned int prev
= fc
->ncols
;
7182 if (reg
< (unsigned int) fc
->ncols
)
7185 if (dwarf_regnames_count
> 0
7186 && reg
> dwarf_regnames_count
)
7189 fc
->ncols
= reg
+ 1;
7190 /* PR 17512: file: 10450-2643-0.004.
7191 If reg == -1 then this can happen... */
7195 /* PR 17512: file: 2844a11d. */
7196 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7198 error (_("Unfeasibly large register number: %u\n"), reg
);
7200 /* FIXME: 1024 is an arbitrary limit. Increase it if
7201 we ever encounter a valid binary that exceeds it. */
7205 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7206 sizeof (short int));
7207 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7208 /* PR 17512: file:002-10025-0.005. */
7209 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7211 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7217 while (prev
< fc
->ncols
)
7219 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7220 fc
->col_offset
[prev
] = 0;
7226 static const char *const dwarf_regnames_i386
[] =
7228 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7229 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7230 "eip", "eflags", NULL
, /* 8 - 10 */
7231 "st0", "st1", "st2", "st3", /* 11 - 14 */
7232 "st4", "st5", "st6", "st7", /* 15 - 18 */
7233 NULL
, NULL
, /* 19 - 20 */
7234 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7235 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7236 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7237 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7238 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7239 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7240 "tr", "ldtr", /* 48 - 49 */
7241 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7242 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7243 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7244 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7245 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7246 NULL
, NULL
, NULL
, /* 90 - 92 */
7247 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7250 static const char *const dwarf_regnames_iamcu
[] =
7252 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7253 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7254 "eip", "eflags", NULL
, /* 8 - 10 */
7255 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7256 NULL
, NULL
, /* 19 - 20 */
7257 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7258 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7259 NULL
, NULL
, NULL
, /* 37 - 39 */
7260 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7261 "tr", "ldtr", /* 48 - 49 */
7262 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7263 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7264 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7265 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7266 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7267 NULL
, NULL
, NULL
, /* 90 - 92 */
7268 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7272 init_dwarf_regnames_i386 (void)
7274 dwarf_regnames
= dwarf_regnames_i386
;
7275 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7276 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7280 init_dwarf_regnames_iamcu (void)
7282 dwarf_regnames
= dwarf_regnames_iamcu
;
7283 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7284 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7287 static const char *const dwarf_regnames_x86_64
[] =
7289 "rax", "rdx", "rcx", "rbx",
7290 "rsi", "rdi", "rbp", "rsp",
7291 "r8", "r9", "r10", "r11",
7292 "r12", "r13", "r14", "r15",
7294 "xmm0", "xmm1", "xmm2", "xmm3",
7295 "xmm4", "xmm5", "xmm6", "xmm7",
7296 "xmm8", "xmm9", "xmm10", "xmm11",
7297 "xmm12", "xmm13", "xmm14", "xmm15",
7298 "st0", "st1", "st2", "st3",
7299 "st4", "st5", "st6", "st7",
7300 "mm0", "mm1", "mm2", "mm3",
7301 "mm4", "mm5", "mm6", "mm7",
7303 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7304 "fs.base", "gs.base", NULL
, NULL
,
7306 "mxcsr", "fcw", "fsw",
7307 "xmm16", "xmm17", "xmm18", "xmm19",
7308 "xmm20", "xmm21", "xmm22", "xmm23",
7309 "xmm24", "xmm25", "xmm26", "xmm27",
7310 "xmm28", "xmm29", "xmm30", "xmm31",
7311 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7312 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7313 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7314 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7315 NULL
, NULL
, NULL
, /* 115 - 117 */
7316 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7320 init_dwarf_regnames_x86_64 (void)
7322 dwarf_regnames
= dwarf_regnames_x86_64
;
7323 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7324 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7327 static const char *const dwarf_regnames_aarch64
[] =
7329 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7330 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7331 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7332 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7333 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7334 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7335 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7336 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7337 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7338 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7339 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7340 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7341 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7342 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7343 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7344 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7348 init_dwarf_regnames_aarch64 (void)
7350 dwarf_regnames
= dwarf_regnames_aarch64
;
7351 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7352 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7355 static const char *const dwarf_regnames_s390
[] =
7357 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7358 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7359 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7360 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7361 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7362 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7363 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7364 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7365 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7368 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7369 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7373 init_dwarf_regnames_s390 (void)
7375 dwarf_regnames
= dwarf_regnames_s390
;
7376 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7377 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7380 static const char *const dwarf_regnames_riscv
[] =
7382 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7383 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7384 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7385 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7386 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7387 "fs0", "fs1", /* 40 - 41 */
7388 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7389 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7390 "fs10", "fs11", /* 58 - 59 */
7391 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7394 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
7395 the large number of CSRs. */
7398 regname_internal_riscv (unsigned int regno
)
7400 const char *name
= NULL
;
7402 /* Lookup in the table first, this covers GPR and FPR. */
7403 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
7404 name
= dwarf_regnames_riscv
[regno
];
7405 else if (regno
>= 4096 && regno
<= 8191)
7407 /* This might be a CSR, these live in a sparse number space from 4096
7408 to 8191 These numbers are defined in the RISC-V ELF ABI
7412 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
7413 case VALUE + 4096: name = #NAME; break;
7414 #include "opcode/riscv-opc.h"
7419 static char csr_name
[10];
7420 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7431 init_dwarf_regnames_riscv (void)
7433 dwarf_regnames
= NULL
;
7434 dwarf_regnames_count
= 8192;
7435 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7439 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7441 dwarf_regnames_lookup_func
= NULL
;
7446 init_dwarf_regnames_i386 ();
7450 init_dwarf_regnames_iamcu ();
7456 init_dwarf_regnames_x86_64 ();
7460 init_dwarf_regnames_aarch64 ();
7464 init_dwarf_regnames_s390 ();
7468 init_dwarf_regnames_riscv ();
7476 /* Initialize the DWARF register name lookup state based on the
7477 architecture and specific machine type of a BFD. */
7480 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7483 dwarf_regnames_lookup_func
= NULL
;
7490 case bfd_mach_x86_64
:
7491 case bfd_mach_x86_64_intel_syntax
:
7492 case bfd_mach_x86_64_nacl
:
7493 case bfd_mach_x64_32
:
7494 case bfd_mach_x64_32_intel_syntax
:
7495 case bfd_mach_x64_32_nacl
:
7496 init_dwarf_regnames_x86_64 ();
7500 init_dwarf_regnames_i386 ();
7505 case bfd_arch_iamcu
:
7506 init_dwarf_regnames_iamcu ();
7509 case bfd_arch_aarch64
:
7510 init_dwarf_regnames_aarch64();
7514 init_dwarf_regnames_s390 ();
7517 case bfd_arch_riscv
:
7518 init_dwarf_regnames_riscv ();
7527 regname_internal_by_table_only (unsigned int regno
)
7529 if (dwarf_regnames
!= NULL
7530 && regno
< dwarf_regnames_count
7531 && dwarf_regnames
[regno
] != NULL
)
7532 return dwarf_regnames
[regno
];
7538 regname (unsigned int regno
, int name_only_p
)
7540 static char reg
[64];
7542 const char *name
= NULL
;
7544 if (dwarf_regnames_lookup_func
!= NULL
)
7545 name
= dwarf_regnames_lookup_func (regno
);
7551 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7554 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7559 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7564 if (*max_regs
!= fc
->ncols
)
7565 *max_regs
= fc
->ncols
;
7567 if (*need_col_headers
)
7569 static const char *sloc
= " LOC";
7571 *need_col_headers
= 0;
7573 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7575 for (r
= 0; r
< *max_regs
; r
++)
7576 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7581 printf ("%-5s ", regname (r
, 1));
7587 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7589 strcpy (tmp
, "exp");
7591 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7592 printf ("%-8s ", tmp
);
7594 for (r
= 0; r
< fc
->ncols
; r
++)
7596 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7598 switch (fc
->col_type
[r
])
7600 case DW_CFA_undefined
:
7603 case DW_CFA_same_value
:
7607 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7609 case DW_CFA_val_offset
:
7610 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7612 case DW_CFA_register
:
7613 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7615 case DW_CFA_expression
:
7616 strcpy (tmp
, "exp");
7618 case DW_CFA_val_expression
:
7619 strcpy (tmp
, "vexp");
7622 strcpy (tmp
, "n/a");
7625 printf ("%-5s ", tmp
);
7631 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7633 static unsigned char *
7634 read_cie (unsigned char *start
, unsigned char *end
,
7635 Frame_Chunk
**p_cie
, int *p_version
,
7636 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7640 unsigned char *augmentation_data
= NULL
;
7641 bfd_size_type augmentation_data_len
= 0;
7644 /* PR 17512: file: 001-228113-0.004. */
7648 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7649 memset (fc
, 0, sizeof (Frame_Chunk
));
7651 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7652 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7656 fc
->augmentation
= (char *) start
;
7657 /* PR 17512: file: 001-228113-0.004.
7658 Skip past augmentation name, but avoid running off the end of the data. */
7660 if (* start
++ == '\0')
7664 warn (_("No terminator for augmentation name\n"));
7668 if (strcmp (fc
->augmentation
, "eh") == 0)
7669 start
+= eh_addr_size
;
7673 GET (fc
->ptr_size
, 1);
7674 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7676 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7680 GET (fc
->segment_size
, 1);
7681 /* PR 17512: file: e99d2804. */
7682 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7684 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7688 eh_addr_size
= fc
->ptr_size
;
7692 fc
->ptr_size
= eh_addr_size
;
7693 fc
->segment_size
= 0;
7696 READ_ULEB (fc
->code_factor
, start
, end
);
7697 READ_SLEB (fc
->data_factor
, start
, end
);
7705 READ_ULEB (fc
->ra
, start
, end
);
7708 if (fc
->augmentation
[0] == 'z')
7710 READ_ULEB (augmentation_data_len
, start
, end
);
7711 augmentation_data
= start
;
7712 /* PR 17512: file: 11042-2589-0.004. */
7713 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7715 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7716 dwarf_vmatoa ("x", augmentation_data_len
),
7717 (unsigned long) (end
- start
));
7720 start
+= augmentation_data_len
;
7723 if (augmentation_data_len
)
7727 unsigned char *qend
;
7729 p
= (unsigned char *) fc
->augmentation
+ 1;
7730 q
= augmentation_data
;
7731 qend
= q
+ augmentation_data_len
;
7733 while (p
< end
&& q
< qend
)
7738 q
+= 1 + size_of_encoded_value (*q
);
7740 fc
->fde_encoding
= *q
++;
7749 /* Note - it is OK if this loop terminates with q < qend.
7750 Padding may have been inserted to align the end of the CIE. */
7755 *p_version
= version
;
7758 *p_aug_len
= augmentation_data_len
;
7759 *p_aug
= augmentation_data
;
7764 free (fc
->col_offset
);
7765 free (fc
->col_type
);
7770 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7771 If do_wide is not enabled, then formats the output to fit into 80 columns.
7772 PRINTED contains the number of characters already written to the current
7776 display_data (bfd_size_type printed
,
7777 const unsigned char * data
,
7778 const bfd_size_type len
)
7780 if (do_wide
|| len
< ((80 - printed
) / 3))
7781 for (printed
= 0; printed
< len
; ++printed
)
7782 printf (" %02x", data
[printed
]);
7785 for (printed
= 0; printed
< len
; ++printed
)
7787 if (printed
% (80 / 3) == 0)
7789 printf (" %02x", data
[printed
]);
7794 /* Prints out the contents on the augmentation data array.
7795 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7798 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7802 i
= printf (_(" Augmentation data: "));
7803 display_data (i
, data
, len
);
7807 display_debug_frames (struct dwarf_section
*section
,
7808 void *file ATTRIBUTE_UNUSED
)
7810 unsigned char *start
= section
->start
;
7811 unsigned char *end
= start
+ section
->size
;
7812 unsigned char *section_start
= start
;
7813 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7814 Frame_Chunk
*remembered_state
= NULL
;
7816 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7817 unsigned int max_regs
= 0;
7818 const char *bad_reg
= _("bad register: ");
7819 unsigned int saved_eh_addr_size
= eh_addr_size
;
7821 introduce (section
, FALSE
);
7825 unsigned char *saved_start
;
7826 unsigned char *block_end
;
7831 int need_col_headers
= 1;
7832 unsigned char *augmentation_data
= NULL
;
7833 bfd_size_type augmentation_data_len
= 0;
7834 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7835 unsigned int offset_size
;
7836 unsigned int initial_length_size
;
7837 bfd_boolean all_nops
;
7838 static Frame_Chunk fde_fc
;
7840 saved_start
= start
;
7842 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7846 printf ("\n%08lx ZERO terminator\n\n",
7847 (unsigned long)(saved_start
- section_start
));
7848 /* Skip any zero terminators that directly follow.
7849 A corrupt section size could have loaded a whole
7850 slew of zero filled memory bytes. eg
7851 PR 17512: file: 070-19381-0.004. */
7852 while (start
< end
&& * start
== 0)
7857 if (length
== 0xffffffff)
7859 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7861 initial_length_size
= 12;
7866 initial_length_size
= 4;
7869 block_end
= saved_start
+ length
+ initial_length_size
;
7870 if (block_end
> end
|| block_end
< start
)
7872 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7873 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7874 (unsigned long) (saved_start
- section_start
));
7878 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7880 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7881 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7886 start
= read_cie (start
, end
, &cie
, &version
,
7887 &augmentation_data_len
, &augmentation_data
);
7888 /* PR 17512: file: 027-135133-0.005. */
7895 fc
->chunk_start
= saved_start
;
7896 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7899 if (frame_need_space (fc
, mreg
) < 0)
7901 if (fc
->fde_encoding
)
7902 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7904 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7905 print_dwarf_vma (length
, fc
->ptr_size
);
7906 print_dwarf_vma (cie_id
, offset_size
);
7908 if (do_debug_frames_interp
)
7910 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7911 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7916 printf (" Version: %d\n", version
);
7917 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7920 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7921 printf (" Segment Size: %u\n", fc
->segment_size
);
7923 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7924 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7925 printf (" Return address column: %d\n", fc
->ra
);
7927 if (augmentation_data_len
)
7928 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7935 unsigned char *look_for
;
7936 unsigned long segment_selector
;
7940 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7941 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7944 look_for
= section_start
+ cie_id
;
7946 if (look_for
<= saved_start
)
7948 for (cie
= chunks
; cie
; cie
= cie
->next
)
7949 if (cie
->chunk_start
== look_for
)
7954 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7955 if (cie
->chunk_start
== look_for
)
7959 unsigned int off_size
;
7960 unsigned char *cie_scan
;
7962 cie_scan
= look_for
;
7964 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7965 if (length
== 0xffffffff)
7967 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7974 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7977 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7978 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7983 read_cie (cie_scan
, end
, &cie
, &version
,
7984 &augmentation_data_len
, &augmentation_data
);
7985 /* PR 17512: file: 3450-2098-0.004. */
7988 warn (_("Failed to read CIE information\n"));
7991 cie
->next
= forward_refs
;
7993 cie
->chunk_start
= look_for
;
7994 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7997 if (frame_need_space (cie
, mreg
) < 0)
7999 warn (_("Invalid max register\n"));
8002 if (cie
->fde_encoding
)
8004 = size_of_encoded_value (cie
->fde_encoding
);
8011 memset (fc
, 0, sizeof (Frame_Chunk
));
8015 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8016 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8017 (unsigned long) (saved_start
- section_start
));
8019 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8020 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8021 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8023 warn (_("Invalid max register\n"));
8027 fc
->augmentation
= "";
8028 fc
->fde_encoding
= 0;
8029 fc
->ptr_size
= eh_addr_size
;
8030 fc
->segment_size
= 0;
8034 fc
->ncols
= cie
->ncols
;
8035 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8036 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8037 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8038 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8039 fc
->augmentation
= cie
->augmentation
;
8040 fc
->ptr_size
= cie
->ptr_size
;
8041 eh_addr_size
= cie
->ptr_size
;
8042 fc
->segment_size
= cie
->segment_size
;
8043 fc
->code_factor
= cie
->code_factor
;
8044 fc
->data_factor
= cie
->data_factor
;
8045 fc
->cfa_reg
= cie
->cfa_reg
;
8046 fc
->cfa_offset
= cie
->cfa_offset
;
8048 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8050 warn (_("Invalid max register\n"));
8053 fc
->fde_encoding
= cie
->fde_encoding
;
8056 if (fc
->fde_encoding
)
8057 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8059 segment_selector
= 0;
8060 if (fc
->segment_size
)
8062 if (fc
->segment_size
> sizeof (segment_selector
))
8064 /* PR 17512: file: 9e196b3e. */
8065 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8066 fc
->segment_size
= 4;
8068 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8071 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8073 /* FIXME: It appears that sometimes the final pc_range value is
8074 encoded in less than encoded_ptr_size bytes. See the x86_64
8075 run of the "objcopy on compressed debug sections" test for an
8077 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8079 if (cie
->augmentation
[0] == 'z')
8081 READ_ULEB (augmentation_data_len
, start
, end
);
8082 augmentation_data
= start
;
8083 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8084 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8086 warn (_("Augmentation data too long: 0x%s, "
8087 "expected at most %#lx\n"),
8088 dwarf_vmatoa ("x", augmentation_data_len
),
8089 (unsigned long) (end
- start
));
8091 augmentation_data
= NULL
;
8092 augmentation_data_len
= 0;
8094 start
+= augmentation_data_len
;
8097 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8098 (unsigned long)(saved_start
- section_start
),
8099 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8100 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8101 (unsigned long)(cie
->chunk_start
- section_start
));
8103 if (fc
->segment_size
)
8104 printf ("%04lx:", segment_selector
);
8107 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8108 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8110 if (! do_debug_frames_interp
&& augmentation_data_len
)
8112 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8117 /* At this point, fc is the current chunk, cie (if any) is set, and
8118 we're about to interpret instructions for the chunk. */
8119 /* ??? At present we need to do this always, since this sizes the
8120 fc->col_type and fc->col_offset arrays, which we write into always.
8121 We should probably split the interpreted and non-interpreted bits
8122 into two different routines, since there's so much that doesn't
8123 really overlap between them. */
8124 if (1 || do_debug_frames_interp
)
8126 /* Start by making a pass over the chunk, allocating storage
8127 and taking note of what registers are used. */
8128 unsigned char *tmp
= start
;
8130 while (start
< block_end
)
8132 unsigned int reg
, op
, opa
;
8134 unsigned char * new_start
;
8141 /* Warning: if you add any more cases to this switch, be
8142 sure to add them to the corresponding switch below. */
8145 case DW_CFA_advance_loc
:
8148 SKIP_ULEB (start
, end
);
8149 if (frame_need_space (fc
, opa
) >= 0)
8150 fc
->col_type
[opa
] = DW_CFA_undefined
;
8152 case DW_CFA_restore
:
8153 if (frame_need_space (fc
, opa
) >= 0)
8154 fc
->col_type
[opa
] = DW_CFA_undefined
;
8156 case DW_CFA_set_loc
:
8157 start
+= encoded_ptr_size
;
8159 case DW_CFA_advance_loc1
:
8162 case DW_CFA_advance_loc2
:
8165 case DW_CFA_advance_loc4
:
8168 case DW_CFA_offset_extended
:
8169 case DW_CFA_val_offset
:
8170 READ_ULEB (reg
, start
, end
);
8171 SKIP_ULEB (start
, end
);
8172 if (frame_need_space (fc
, reg
) >= 0)
8173 fc
->col_type
[reg
] = DW_CFA_undefined
;
8175 case DW_CFA_restore_extended
:
8176 READ_ULEB (reg
, start
, end
);
8177 if (frame_need_space (fc
, reg
) >= 0)
8178 fc
->col_type
[reg
] = DW_CFA_undefined
;
8180 case DW_CFA_undefined
:
8181 READ_ULEB (reg
, start
, end
);
8182 if (frame_need_space (fc
, reg
) >= 0)
8183 fc
->col_type
[reg
] = DW_CFA_undefined
;
8185 case DW_CFA_same_value
:
8186 READ_ULEB (reg
, start
, end
);
8187 if (frame_need_space (fc
, reg
) >= 0)
8188 fc
->col_type
[reg
] = DW_CFA_undefined
;
8190 case DW_CFA_register
:
8191 READ_ULEB (reg
, start
, end
);
8192 SKIP_ULEB (start
, end
);
8193 if (frame_need_space (fc
, reg
) >= 0)
8194 fc
->col_type
[reg
] = DW_CFA_undefined
;
8196 case DW_CFA_def_cfa
:
8197 SKIP_ULEB (start
, end
);
8198 SKIP_ULEB (start
, end
);
8200 case DW_CFA_def_cfa_register
:
8201 SKIP_ULEB (start
, end
);
8203 case DW_CFA_def_cfa_offset
:
8204 SKIP_ULEB (start
, end
);
8206 case DW_CFA_def_cfa_expression
:
8207 READ_ULEB (temp
, start
, end
);
8208 new_start
= start
+ temp
;
8209 if (new_start
< start
)
8211 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8217 case DW_CFA_expression
:
8218 case DW_CFA_val_expression
:
8219 READ_ULEB (reg
, start
, end
);
8220 READ_ULEB (temp
, start
, end
);
8221 new_start
= start
+ temp
;
8222 if (new_start
< start
)
8224 /* PR 17512: file:306-192417-0.005. */
8225 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8230 if (frame_need_space (fc
, reg
) >= 0)
8231 fc
->col_type
[reg
] = DW_CFA_undefined
;
8233 case DW_CFA_offset_extended_sf
:
8234 case DW_CFA_val_offset_sf
:
8235 READ_ULEB (reg
, start
, end
);
8236 SKIP_SLEB (start
, end
);
8237 if (frame_need_space (fc
, reg
) >= 0)
8238 fc
->col_type
[reg
] = DW_CFA_undefined
;
8240 case DW_CFA_def_cfa_sf
:
8241 SKIP_ULEB (start
, end
);
8242 SKIP_SLEB (start
, end
);
8244 case DW_CFA_def_cfa_offset_sf
:
8245 SKIP_SLEB (start
, end
);
8247 case DW_CFA_MIPS_advance_loc8
:
8250 case DW_CFA_GNU_args_size
:
8251 SKIP_ULEB (start
, end
);
8253 case DW_CFA_GNU_negative_offset_extended
:
8254 READ_ULEB (reg
, start
, end
);
8255 SKIP_ULEB (start
, end
);
8256 if (frame_need_space (fc
, reg
) >= 0)
8257 fc
->col_type
[reg
] = DW_CFA_undefined
;
8268 /* Now we know what registers are used, make a second pass over
8269 the chunk, this time actually printing out the info. */
8271 while (start
< block_end
)
8273 unsigned char * tmp
;
8275 unsigned long ul
, roffs
;
8276 /* Note: It is tempting to use an unsigned long for 'reg' but there
8277 are various functions, notably frame_space_needed() that assume that
8278 reg is an unsigned int. */
8283 const char *reg_prefix
= "";
8290 /* Make a note if something other than DW_CFA_nop happens. */
8291 if (op
!= DW_CFA_nop
)
8294 /* Warning: if you add any more cases to this switch, be
8295 sure to add them to the corresponding switch above. */
8298 case DW_CFA_advance_loc
:
8299 if (do_debug_frames_interp
)
8300 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8302 printf (" DW_CFA_advance_loc: %d to %s\n",
8303 opa
* fc
->code_factor
,
8304 dwarf_vmatoa_1 (NULL
,
8305 fc
->pc_begin
+ opa
* fc
->code_factor
,
8307 fc
->pc_begin
+= opa
* fc
->code_factor
;
8311 READ_ULEB (roffs
, start
, end
);
8312 if (opa
>= (unsigned int) fc
->ncols
)
8313 reg_prefix
= bad_reg
;
8314 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8315 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8316 reg_prefix
, regname (opa
, 0),
8317 roffs
* fc
->data_factor
);
8318 if (*reg_prefix
== '\0')
8320 fc
->col_type
[opa
] = DW_CFA_offset
;
8321 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8325 case DW_CFA_restore
:
8326 if (opa
>= (unsigned int) fc
->ncols
)
8327 reg_prefix
= bad_reg
;
8328 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8329 printf (" DW_CFA_restore: %s%s\n",
8330 reg_prefix
, regname (opa
, 0));
8331 if (*reg_prefix
!= '\0')
8334 if (opa
>= (unsigned int) cie
->ncols
8335 || (do_debug_frames_interp
8336 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8338 fc
->col_type
[opa
] = DW_CFA_undefined
;
8339 fc
->col_offset
[opa
] = 0;
8343 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8344 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8348 case DW_CFA_set_loc
:
8349 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8350 if (do_debug_frames_interp
)
8351 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8353 printf (" DW_CFA_set_loc: %s\n",
8354 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8358 case DW_CFA_advance_loc1
:
8359 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8360 if (do_debug_frames_interp
)
8361 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8363 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8364 (unsigned long) (ofs
* fc
->code_factor
),
8365 dwarf_vmatoa_1 (NULL
,
8366 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8368 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8371 case DW_CFA_advance_loc2
:
8372 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8373 if (do_debug_frames_interp
)
8374 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8376 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8377 (unsigned long) (ofs
* fc
->code_factor
),
8378 dwarf_vmatoa_1 (NULL
,
8379 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8381 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8384 case DW_CFA_advance_loc4
:
8385 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8386 if (do_debug_frames_interp
)
8387 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8389 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8390 (unsigned long) (ofs
* fc
->code_factor
),
8391 dwarf_vmatoa_1 (NULL
,
8392 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8394 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8397 case DW_CFA_offset_extended
:
8398 READ_ULEB (reg
, start
, end
);
8399 READ_ULEB (roffs
, start
, end
);
8400 if (reg
>= (unsigned int) fc
->ncols
)
8401 reg_prefix
= bad_reg
;
8402 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8403 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8404 reg_prefix
, regname (reg
, 0),
8405 roffs
* fc
->data_factor
);
8406 if (*reg_prefix
== '\0')
8408 fc
->col_type
[reg
] = DW_CFA_offset
;
8409 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8413 case DW_CFA_val_offset
:
8414 READ_ULEB (reg
, start
, end
);
8415 READ_ULEB (roffs
, start
, end
);
8416 if (reg
>= (unsigned int) fc
->ncols
)
8417 reg_prefix
= bad_reg
;
8418 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8419 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8420 reg_prefix
, regname (reg
, 0),
8421 roffs
* fc
->data_factor
);
8422 if (*reg_prefix
== '\0')
8424 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8425 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8429 case DW_CFA_restore_extended
:
8430 READ_ULEB (reg
, start
, end
);
8431 if (reg
>= (unsigned int) fc
->ncols
)
8432 reg_prefix
= bad_reg
;
8433 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8434 printf (" DW_CFA_restore_extended: %s%s\n",
8435 reg_prefix
, regname (reg
, 0));
8436 if (*reg_prefix
!= '\0')
8439 if (reg
>= (unsigned int) cie
->ncols
)
8441 fc
->col_type
[reg
] = DW_CFA_undefined
;
8442 fc
->col_offset
[reg
] = 0;
8446 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8447 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8451 case DW_CFA_undefined
:
8452 READ_ULEB (reg
, start
, end
);
8453 if (reg
>= (unsigned int) fc
->ncols
)
8454 reg_prefix
= bad_reg
;
8455 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8456 printf (" DW_CFA_undefined: %s%s\n",
8457 reg_prefix
, regname (reg
, 0));
8458 if (*reg_prefix
== '\0')
8460 fc
->col_type
[reg
] = DW_CFA_undefined
;
8461 fc
->col_offset
[reg
] = 0;
8465 case DW_CFA_same_value
:
8466 READ_ULEB (reg
, start
, end
);
8467 if (reg
>= (unsigned int) fc
->ncols
)
8468 reg_prefix
= bad_reg
;
8469 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8470 printf (" DW_CFA_same_value: %s%s\n",
8471 reg_prefix
, regname (reg
, 0));
8472 if (*reg_prefix
== '\0')
8474 fc
->col_type
[reg
] = DW_CFA_same_value
;
8475 fc
->col_offset
[reg
] = 0;
8479 case DW_CFA_register
:
8480 READ_ULEB (reg
, start
, end
);
8481 READ_ULEB (roffs
, start
, end
);
8482 if (reg
>= (unsigned int) fc
->ncols
)
8483 reg_prefix
= bad_reg
;
8484 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8486 printf (" DW_CFA_register: %s%s in ",
8487 reg_prefix
, regname (reg
, 0));
8488 puts (regname (roffs
, 0));
8490 if (*reg_prefix
== '\0')
8492 fc
->col_type
[reg
] = DW_CFA_register
;
8493 fc
->col_offset
[reg
] = roffs
;
8497 case DW_CFA_remember_state
:
8498 if (! do_debug_frames_interp
)
8499 printf (" DW_CFA_remember_state\n");
8500 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8501 rs
->cfa_offset
= fc
->cfa_offset
;
8502 rs
->cfa_reg
= fc
->cfa_reg
;
8504 rs
->cfa_exp
= fc
->cfa_exp
;
8505 rs
->ncols
= fc
->ncols
;
8506 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8507 sizeof (* rs
->col_type
));
8508 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8509 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8510 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8511 rs
->next
= remembered_state
;
8512 remembered_state
= rs
;
8515 case DW_CFA_restore_state
:
8516 if (! do_debug_frames_interp
)
8517 printf (" DW_CFA_restore_state\n");
8518 rs
= remembered_state
;
8521 remembered_state
= rs
->next
;
8522 fc
->cfa_offset
= rs
->cfa_offset
;
8523 fc
->cfa_reg
= rs
->cfa_reg
;
8525 fc
->cfa_exp
= rs
->cfa_exp
;
8526 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8528 warn (_("Invalid column number in saved frame state\n"));
8532 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8533 memcpy (fc
->col_offset
, rs
->col_offset
,
8534 rs
->ncols
* sizeof (* rs
->col_offset
));
8535 free (rs
->col_type
);
8536 free (rs
->col_offset
);
8539 else if (do_debug_frames_interp
)
8540 printf ("Mismatched DW_CFA_restore_state\n");
8543 case DW_CFA_def_cfa
:
8544 READ_ULEB (fc
->cfa_reg
, start
, end
);
8545 READ_ULEB (fc
->cfa_offset
, start
, end
);
8547 if (! do_debug_frames_interp
)
8548 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8549 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8552 case DW_CFA_def_cfa_register
:
8553 READ_ULEB (fc
->cfa_reg
, start
, end
);
8555 if (! do_debug_frames_interp
)
8556 printf (" DW_CFA_def_cfa_register: %s\n",
8557 regname (fc
->cfa_reg
, 0));
8560 case DW_CFA_def_cfa_offset
:
8561 READ_ULEB (fc
->cfa_offset
, start
, end
);
8562 if (! do_debug_frames_interp
)
8563 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8567 if (! do_debug_frames_interp
)
8568 printf (" DW_CFA_nop\n");
8571 case DW_CFA_def_cfa_expression
:
8572 READ_ULEB (ul
, start
, end
);
8573 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8575 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8578 if (! do_debug_frames_interp
)
8580 printf (" DW_CFA_def_cfa_expression (");
8581 decode_location_expression (start
, eh_addr_size
, 0, -1,
8589 case DW_CFA_expression
:
8590 READ_ULEB (reg
, start
, end
);
8591 READ_ULEB (ul
, start
, end
);
8592 if (reg
>= (unsigned int) fc
->ncols
)
8593 reg_prefix
= bad_reg
;
8594 /* PR 17512: file: 069-133014-0.006. */
8595 /* PR 17512: file: 98c02eb4. */
8597 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8599 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8602 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8604 printf (" DW_CFA_expression: %s%s (",
8605 reg_prefix
, regname (reg
, 0));
8606 decode_location_expression (start
, eh_addr_size
, 0, -1,
8610 if (*reg_prefix
== '\0')
8611 fc
->col_type
[reg
] = DW_CFA_expression
;
8615 case DW_CFA_val_expression
:
8616 READ_ULEB (reg
, start
, end
);
8617 READ_ULEB (ul
, start
, end
);
8618 if (reg
>= (unsigned int) fc
->ncols
)
8619 reg_prefix
= bad_reg
;
8621 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8623 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8626 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8628 printf (" DW_CFA_val_expression: %s%s (",
8629 reg_prefix
, regname (reg
, 0));
8630 decode_location_expression (start
, eh_addr_size
, 0, -1,
8634 if (*reg_prefix
== '\0')
8635 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8639 case DW_CFA_offset_extended_sf
:
8640 READ_ULEB (reg
, start
, end
);
8641 READ_SLEB (l
, start
, end
);
8642 if (frame_need_space (fc
, reg
) < 0)
8643 reg_prefix
= bad_reg
;
8644 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8645 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8646 reg_prefix
, regname (reg
, 0),
8647 (long)(l
* fc
->data_factor
));
8648 if (*reg_prefix
== '\0')
8650 fc
->col_type
[reg
] = DW_CFA_offset
;
8651 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8655 case DW_CFA_val_offset_sf
:
8656 READ_ULEB (reg
, start
, end
);
8657 READ_SLEB (l
, start
, end
);
8658 if (frame_need_space (fc
, reg
) < 0)
8659 reg_prefix
= bad_reg
;
8660 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8661 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8662 reg_prefix
, regname (reg
, 0),
8663 (long)(l
* fc
->data_factor
));
8664 if (*reg_prefix
== '\0')
8666 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8667 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8671 case DW_CFA_def_cfa_sf
:
8672 READ_ULEB (fc
->cfa_reg
, start
, end
);
8673 READ_ULEB (fc
->cfa_offset
, start
, end
);
8674 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8676 if (! do_debug_frames_interp
)
8677 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8678 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8681 case DW_CFA_def_cfa_offset_sf
:
8682 READ_ULEB (fc
->cfa_offset
, start
, end
);
8683 fc
->cfa_offset
*= fc
->data_factor
;
8684 if (! do_debug_frames_interp
)
8685 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8688 case DW_CFA_MIPS_advance_loc8
:
8689 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8690 if (do_debug_frames_interp
)
8691 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8693 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8694 (unsigned long) (ofs
* fc
->code_factor
),
8695 dwarf_vmatoa_1 (NULL
,
8696 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8698 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8701 case DW_CFA_GNU_window_save
:
8702 if (! do_debug_frames_interp
)
8703 printf (" DW_CFA_GNU_window_save\n");
8706 case DW_CFA_GNU_args_size
:
8707 READ_ULEB (ul
, start
, end
);
8708 if (! do_debug_frames_interp
)
8709 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8712 case DW_CFA_GNU_negative_offset_extended
:
8713 READ_ULEB (reg
, start
, end
);
8714 READ_SLEB (l
, start
, end
);
8716 if (frame_need_space (fc
, reg
) < 0)
8717 reg_prefix
= bad_reg
;
8718 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8719 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8720 reg_prefix
, regname (reg
, 0),
8721 (long)(l
* fc
->data_factor
));
8722 if (*reg_prefix
== '\0')
8724 fc
->col_type
[reg
] = DW_CFA_offset
;
8725 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8730 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8731 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8733 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8738 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8739 if (do_debug_frames_interp
&& ! all_nops
)
8740 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8742 if (fde_fc
.col_type
!= NULL
)
8744 free (fde_fc
.col_type
);
8745 fde_fc
.col_type
= NULL
;
8747 if (fde_fc
.col_offset
!= NULL
)
8749 free (fde_fc
.col_offset
);
8750 fde_fc
.col_offset
= NULL
;
8754 eh_addr_size
= saved_eh_addr_size
;
8759 while (remembered_state
!= NULL
)
8761 rs
= remembered_state
;
8762 remembered_state
= rs
->next
;
8763 free (rs
->col_type
);
8764 free (rs
->col_offset
);
8765 rs
->next
= NULL
; /* Paranoia. */
8769 while (chunks
!= NULL
)
8773 free (rs
->col_type
);
8774 free (rs
->col_offset
);
8775 rs
->next
= NULL
; /* Paranoia. */
8779 while (forward_refs
!= NULL
)
8782 forward_refs
= rs
->next
;
8783 free (rs
->col_type
);
8784 free (rs
->col_offset
);
8785 rs
->next
= NULL
; /* Paranoia. */
8795 display_debug_names (struct dwarf_section
*section
, void *file
)
8797 unsigned char *hdrptr
= section
->start
;
8798 dwarf_vma unit_length
;
8799 unsigned char *unit_start
;
8800 const unsigned char *const section_end
= section
->start
+ section
->size
;
8801 unsigned char *unit_end
;
8803 introduce (section
, FALSE
);
8805 load_debug_section_with_follow (str
, file
);
8807 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8809 unsigned int offset_size
;
8810 uint16_t dwarf_version
, padding
;
8811 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8812 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8813 uint32_t augmentation_string_size
;
8815 unsigned long sec_off
;
8816 bfd_boolean augmentation_printable
;
8817 const char *augmentation_string
;
8819 unit_start
= hdrptr
;
8821 /* Get and check the length of the block. */
8822 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8824 if (unit_length
== 0xffffffff)
8826 /* This section is 64-bit DWARF. */
8827 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8832 unit_end
= hdrptr
+ unit_length
;
8834 sec_off
= hdrptr
- section
->start
;
8835 if (sec_off
+ unit_length
< sec_off
8836 || sec_off
+ unit_length
> section
->size
)
8838 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8840 (unsigned long) (unit_start
- section
->start
),
8841 dwarf_vmatoa ("x", unit_length
));
8845 /* Get and check the version number. */
8846 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8847 printf (_("Version %ld\n"), (long) dwarf_version
);
8849 /* Prior versions did not exist, and future versions may not be
8850 backwards compatible. */
8851 if (dwarf_version
!= 5)
8853 warn (_("Only DWARF version 5 .debug_names "
8854 "is currently supported.\n"));
8858 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8860 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8863 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8864 if (comp_unit_count
== 0)
8865 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8867 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8868 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8869 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8870 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8871 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8873 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8874 if (augmentation_string_size
% 4 != 0)
8876 warn (_("Augmentation string length %u must be rounded up "
8877 "to a multiple of 4 in .debug_names.\n"),
8878 augmentation_string_size
);
8879 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8882 printf (_("Augmentation string:"));
8884 augmentation_printable
= TRUE
;
8885 augmentation_string
= (const char *) hdrptr
;
8887 for (i
= 0; i
< augmentation_string_size
; i
++)
8891 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8892 printf (" %02x", uc
);
8894 if (uc
!= 0 && !ISPRINT (uc
))
8895 augmentation_printable
= FALSE
;
8898 if (augmentation_printable
)
8902 i
< augmentation_string_size
&& augmentation_string
[i
];
8904 putchar (augmentation_string
[i
]);
8909 printf (_("CU table:\n"));
8910 for (i
= 0; i
< comp_unit_count
; i
++)
8914 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8915 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8919 printf (_("TU table:\n"));
8920 for (i
= 0; i
< local_type_unit_count
; i
++)
8924 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8925 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8929 printf (_("Foreign TU table:\n"));
8930 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8934 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8935 printf (_("[%3u] "), i
);
8936 print_dwarf_vma (signature
, 8);
8941 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8942 hdrptr
+= bucket_count
* sizeof (uint32_t);
8943 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8944 hdrptr
+= name_count
* sizeof (uint32_t);
8945 unsigned char *const name_table_string_offsets
= hdrptr
;
8946 hdrptr
+= name_count
* offset_size
;
8947 unsigned char *const name_table_entry_offsets
= hdrptr
;
8948 hdrptr
+= name_count
* offset_size
;
8949 unsigned char *const abbrev_table
= hdrptr
;
8950 hdrptr
+= abbrev_table_size
;
8951 const unsigned char *const abbrev_table_end
= hdrptr
;
8952 unsigned char *const entry_pool
= hdrptr
;
8953 if (hdrptr
> unit_end
)
8955 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8956 "for unit 0x%lx in the debug_names\n"),
8957 (long) (hdrptr
- section
->start
),
8958 (long) (unit_end
- section
->start
),
8959 (long) (unit_start
- section
->start
));
8963 size_t buckets_filled
= 0;
8965 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8967 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8972 printf (ngettext ("Used %zu of %lu bucket.\n",
8973 "Used %zu of %lu buckets.\n",
8975 buckets_filled
, (unsigned long) bucket_count
);
8977 uint32_t hash_prev
= 0;
8978 size_t hash_clash_count
= 0;
8979 size_t longest_clash
= 0;
8980 size_t this_length
= 0;
8982 for (hashi
= 0; hashi
< name_count
; hashi
++)
8984 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8988 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8992 longest_clash
= MAX (longest_clash
, this_length
);
8997 hash_prev
= hash_this
;
8999 printf (_("Out of %lu items there are %zu bucket clashes"
9000 " (longest of %zu entries).\n"),
9001 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9002 assert (name_count
== buckets_filled
+ hash_clash_count
);
9004 struct abbrev_lookup_entry
9006 dwarf_vma abbrev_tag
;
9007 unsigned char *abbrev_lookup_ptr
;
9009 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9010 size_t abbrev_lookup_used
= 0;
9011 size_t abbrev_lookup_allocated
= 0;
9013 unsigned char *abbrevptr
= abbrev_table
;
9016 dwarf_vma abbrev_tag
;
9018 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9019 if (abbrev_tag
== 0)
9021 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9023 abbrev_lookup_allocated
= MAX (0x100,
9024 abbrev_lookup_allocated
* 2);
9025 abbrev_lookup
= xrealloc (abbrev_lookup
,
9026 (abbrev_lookup_allocated
9027 * sizeof (*abbrev_lookup
)));
9029 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9030 struct abbrev_lookup_entry
*entry
;
9031 for (entry
= abbrev_lookup
;
9032 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9034 if (entry
->abbrev_tag
== abbrev_tag
)
9036 warn (_("Duplicate abbreviation tag %lu "
9037 "in unit 0x%lx in the debug_names\n"),
9038 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9041 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9042 entry
->abbrev_tag
= abbrev_tag
;
9043 entry
->abbrev_lookup_ptr
= abbrevptr
;
9045 /* Skip DWARF tag. */
9046 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9049 dwarf_vma xindex
, form
;
9051 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9052 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9053 if (xindex
== 0 && form
== 0)
9058 printf (_("\nSymbol table:\n"));
9060 for (namei
= 0; namei
< name_count
; ++namei
)
9062 uint64_t string_offset
, entry_offset
;
9064 SAFE_BYTE_GET (string_offset
,
9065 name_table_string_offsets
+ namei
* offset_size
,
9066 offset_size
, unit_end
);
9067 SAFE_BYTE_GET (entry_offset
,
9068 name_table_entry_offsets
+ namei
* offset_size
,
9069 offset_size
, unit_end
);
9071 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9072 fetch_indirect_string (string_offset
));
9074 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9076 // We need to scan first whether there is a single or multiple
9077 // entries. TAGNO is -2 for the first entry, it is -1 for the
9078 // initial tag read of the second entry, then it becomes 0 for the
9079 // first entry for real printing etc.
9081 /* Initialize it due to a false compiler warning. */
9082 dwarf_vma second_abbrev_tag
= -1;
9085 dwarf_vma abbrev_tag
;
9086 dwarf_vma dwarf_tag
;
9087 const struct abbrev_lookup_entry
*entry
;
9089 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9092 second_abbrev_tag
= abbrev_tag
;
9094 entryptr
= entry_pool
+ entry_offset
;
9097 if (abbrev_tag
== 0)
9101 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9102 (unsigned long) abbrev_tag
);
9104 for (entry
= abbrev_lookup
;
9105 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9107 if (entry
->abbrev_tag
== abbrev_tag
)
9109 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9111 warn (_("Undefined abbreviation tag %lu "
9112 "in unit 0x%lx in the debug_names\n"),
9114 (long) (unit_start
- section
->start
));
9117 abbrevptr
= entry
->abbrev_lookup_ptr
;
9118 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9120 printf (" %s", get_TAG_name (dwarf_tag
));
9123 dwarf_vma xindex
, form
;
9125 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9126 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9127 if (xindex
== 0 && form
== 0)
9131 printf (" %s", get_IDX_name (xindex
));
9132 entryptr
= read_and_display_attr_value (0, form
, 0,
9133 unit_start
, entryptr
, unit_end
,
9135 dwarf_version
, NULL
,
9142 printf (_(" <no entries>"));
9146 free (abbrev_lookup
);
9153 display_debug_links (struct dwarf_section
* section
,
9154 void * file ATTRIBUTE_UNUSED
)
9156 const unsigned char * filename
;
9157 unsigned int filelen
;
9159 introduce (section
, FALSE
);
9161 /* The .gnu_debuglink section is formatted as:
9162 (c-string) Filename.
9163 (padding) If needed to reach a 4 byte boundary.
9164 (uint32_t) CRC32 value.
9166 The .gun_debugaltlink section is formatted as:
9167 (c-string) Filename.
9168 (binary) Build-ID. */
9170 filename
= section
->start
;
9171 filelen
= strnlen ((const char *) filename
, section
->size
);
9172 if (filelen
== section
->size
)
9174 warn (_("The debuglink filename is corrupt/missing\n"));
9178 printf (_(" Separate debug info file: %s\n"), filename
);
9180 if (const_strneq (section
->name
, ".gnu_debuglink"))
9183 unsigned int crc_offset
;
9185 crc_offset
= filelen
+ 1;
9186 crc_offset
= (crc_offset
+ 3) & ~3;
9187 if (crc_offset
+ 4 > section
->size
)
9189 warn (_("CRC offset missing/truncated\n"));
9193 crc32
= byte_get (filename
+ crc_offset
, 4);
9195 printf (_(" CRC value: %#x\n"), crc32
);
9197 if (crc_offset
+ 4 < section
->size
)
9199 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9200 (long)(section
->size
- (crc_offset
+ 4)));
9204 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9206 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9207 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9208 bfd_size_type printed
;
9210 /* FIXME: Should we support smaller build-id notes ? */
9211 if (build_id_len
< 0x14)
9213 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9217 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9218 display_data (printed
, build_id
, build_id_len
);
9227 display_gdb_index (struct dwarf_section
*section
,
9228 void *file ATTRIBUTE_UNUSED
)
9230 unsigned char *start
= section
->start
;
9232 uint32_t cu_list_offset
, tu_list_offset
;
9233 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9234 unsigned int cu_list_elements
, tu_list_elements
;
9235 unsigned int address_table_size
, symbol_table_slots
;
9236 unsigned char *cu_list
, *tu_list
;
9237 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9240 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9242 introduce (section
, FALSE
);
9244 if (section
->size
< 6 * sizeof (uint32_t))
9246 warn (_("Truncated header in the %s section.\n"), section
->name
);
9250 version
= byte_get_little_endian (start
, 4);
9251 printf (_("Version %ld\n"), (long) version
);
9253 /* Prior versions are obsolete, and future versions may not be
9254 backwards compatible. */
9255 if (version
< 3 || version
> 8)
9257 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9261 warn (_("The address table data in version 3 may be wrong.\n"));
9263 warn (_("Version 4 does not support case insensitive lookups.\n"));
9265 warn (_("Version 5 does not include inlined functions.\n"));
9267 warn (_("Version 6 does not include symbol attributes.\n"));
9268 /* Version 7 indices generated by Gold have bad type unit references,
9269 PR binutils/15021. But we don't know if the index was generated by
9270 Gold or not, so to avoid worrying users with gdb-generated indices
9271 we say nothing for version 7 here. */
9273 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9274 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9275 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9276 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9277 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9279 if (cu_list_offset
> section
->size
9280 || tu_list_offset
> section
->size
9281 || address_table_offset
> section
->size
9282 || symbol_table_offset
> section
->size
9283 || constant_pool_offset
> section
->size
)
9285 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9289 /* PR 17531: file: 418d0a8a. */
9290 if (tu_list_offset
< cu_list_offset
)
9292 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9293 tu_list_offset
, cu_list_offset
);
9297 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9299 if (address_table_offset
< tu_list_offset
)
9301 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9302 address_table_offset
, tu_list_offset
);
9306 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9308 /* PR 17531: file: 18a47d3d. */
9309 if (symbol_table_offset
< address_table_offset
)
9311 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9312 symbol_table_offset
, address_table_offset
);
9316 address_table_size
= symbol_table_offset
- address_table_offset
;
9318 if (constant_pool_offset
< symbol_table_offset
)
9320 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9321 constant_pool_offset
, symbol_table_offset
);
9325 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9327 cu_list
= start
+ cu_list_offset
;
9328 tu_list
= start
+ tu_list_offset
;
9329 address_table
= start
+ address_table_offset
;
9330 symbol_table
= start
+ symbol_table_offset
;
9331 constant_pool
= start
+ constant_pool_offset
;
9333 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9335 warn (_("Address table extends beyond end of section.\n"));
9339 printf (_("\nCU table:\n"));
9340 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9342 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9343 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9345 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9346 (unsigned long) cu_offset
,
9347 (unsigned long) (cu_offset
+ cu_length
- 1));
9350 printf (_("\nTU table:\n"));
9351 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9353 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9354 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9355 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9357 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9358 (unsigned long) tu_offset
,
9359 (unsigned long) type_offset
);
9360 print_dwarf_vma (signature
, 8);
9364 printf (_("\nAddress table:\n"));
9365 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9368 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9369 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9370 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9372 print_dwarf_vma (low
, 8);
9373 print_dwarf_vma (high
, 8);
9374 printf (_("%lu\n"), (unsigned long) cu_index
);
9377 printf (_("\nSymbol table:\n"));
9378 for (i
= 0; i
< symbol_table_slots
; ++i
)
9380 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9381 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9382 uint32_t num_cus
, cu
;
9384 if (name_offset
!= 0
9385 || cu_vector_offset
!= 0)
9388 unsigned char * adr
;
9390 adr
= constant_pool
+ name_offset
;
9391 /* PR 17531: file: 5b7b07ad. */
9392 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9394 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9395 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9399 printf ("[%3u] %.*s:", i
,
9400 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9401 constant_pool
+ name_offset
);
9403 adr
= constant_pool
+ cu_vector_offset
;
9404 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9406 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9407 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9408 cu_vector_offset
, i
);
9412 num_cus
= byte_get_little_endian (adr
, 4);
9414 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9415 if (num_cus
* 4 < num_cus
9416 || adr
>= section
->start
+ section
->size
9417 || adr
< constant_pool
)
9419 printf ("<invalid number of CUs: %d>\n", num_cus
);
9420 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9428 for (j
= 0; j
< num_cus
; ++j
)
9431 gdb_index_symbol_kind kind
;
9433 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9434 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9435 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9436 cu
= GDB_INDEX_CU_VALUE (cu
);
9437 /* Convert to TU number if it's for a type unit. */
9438 if (cu
>= cu_list_elements
/ 2)
9439 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9440 (unsigned long) (cu
- cu_list_elements
/ 2));
9442 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9444 printf (" [%s, %s]",
9445 is_static
? _("static") : _("global"),
9446 get_gdb_index_symbol_kind_name (kind
));
9458 /* Pre-allocate enough space for the CU/TU sets needed. */
9461 prealloc_cu_tu_list (unsigned int nshndx
)
9463 if (shndx_pool
== NULL
)
9465 shndx_pool_size
= nshndx
;
9466 shndx_pool_used
= 0;
9467 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9468 sizeof (unsigned int));
9472 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9473 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9474 sizeof (unsigned int));
9479 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9481 if (shndx_pool_used
>= shndx_pool_size
)
9483 error (_("Internal error: out of space in the shndx pool.\n"));
9486 shndx_pool
[shndx_pool_used
++] = shndx
;
9490 end_cu_tu_entry (void)
9492 if (shndx_pool_used
>= shndx_pool_size
)
9494 error (_("Internal error: out of space in the shndx pool.\n"));
9497 shndx_pool
[shndx_pool_used
++] = 0;
9500 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9503 get_DW_SECT_short_name (unsigned int dw_sect
)
9505 static char buf
[16];
9513 case DW_SECT_ABBREV
:
9519 case DW_SECT_STR_OFFSETS
:
9521 case DW_SECT_MACINFO
:
9529 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9533 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9534 These sections are extensions for Fission.
9535 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9538 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9540 unsigned char *phdr
= section
->start
;
9541 unsigned char *limit
= phdr
+ section
->size
;
9542 unsigned char *phash
;
9543 unsigned char *pindex
;
9544 unsigned char *ppool
;
9545 unsigned int version
;
9546 unsigned int ncols
= 0;
9548 unsigned int nslots
;
9551 dwarf_vma signature_high
;
9552 dwarf_vma signature_low
;
9555 /* PR 17512: file: 002-168123-0.004. */
9558 warn (_("Section %s is empty\n"), section
->name
);
9561 /* PR 17512: file: 002-376-0.004. */
9562 if (section
->size
< 24)
9564 warn (_("Section %s is too small to contain a CU/TU header\n"),
9569 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9571 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9572 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9573 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9576 pindex
= phash
+ (size_t) nslots
* 8;
9577 ppool
= pindex
+ (size_t) nslots
* 4;
9581 introduce (section
, FALSE
);
9583 printf (_(" Version: %u\n"), version
);
9585 printf (_(" Number of columns: %u\n"), ncols
);
9586 printf (_(" Number of used entries: %u\n"), nused
);
9587 printf (_(" Number of slots: %u\n\n"), nslots
);
9590 /* PR 17531: file: 45d69832. */
9591 if ((size_t) nslots
* 8 / 8 != nslots
9592 || phash
< phdr
|| phash
> limit
9593 || pindex
< phash
|| pindex
> limit
9594 || ppool
< pindex
|| ppool
> limit
)
9596 warn (ngettext ("Section %s is too small for %u slot\n",
9597 "Section %s is too small for %u slots\n",
9599 section
->name
, nslots
);
9606 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9607 for (i
= 0; i
< nslots
; i
++)
9609 unsigned char *shndx_list
;
9612 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9613 if (signature_high
!= 0 || signature_low
!= 0)
9615 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9616 shndx_list
= ppool
+ j
* 4;
9617 /* PR 17531: file: 705e010d. */
9618 if (shndx_list
< ppool
)
9620 warn (_("Section index pool located before start of section\n"));
9625 printf (_(" [%3d] Signature: 0x%s Sections: "),
9626 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9627 buf
, sizeof (buf
)));
9630 if (shndx_list
>= limit
)
9632 warn (_("Section %s too small for shndx pool\n"),
9636 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9640 printf (" %d", shndx
);
9642 add_shndx_to_cu_tu_entry (shndx
);
9654 else if (version
== 2)
9657 unsigned int dw_sect
;
9658 unsigned char *ph
= phash
;
9659 unsigned char *pi
= pindex
;
9660 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9661 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9662 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9663 bfd_boolean is_tu_index
;
9664 struct cu_tu_set
*this_set
= NULL
;
9666 unsigned char *prow
;
9668 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9670 /* PR 17531: file: 0dd159bf.
9671 Check for integer overflow (can occur when size_t is 32-bit)
9672 with overlarge ncols or nused values. */
9674 && ((size_t) ncols
* 4 / 4 != ncols
9675 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9676 || poffsets
< ppool
|| poffsets
> limit
9677 || psizes
< poffsets
|| psizes
> limit
9678 || pend
< psizes
|| pend
> limit
))
9680 warn (_("Section %s too small for offset and size tables\n"),
9687 printf (_(" Offset table\n"));
9688 printf (" slot %-16s ",
9689 is_tu_index
? _("signature") : _("dwo_id"));
9696 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9702 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9709 for (j
= 0; j
< ncols
; j
++)
9711 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9712 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9717 for (i
= 0; i
< nslots
; i
++)
9719 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9721 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9724 /* PR 17531: file: a05f6ab3. */
9727 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9734 size_t num_copy
= sizeof (uint64_t);
9736 /* PR 23064: Beware of buffer overflow. */
9737 if (ph
+ num_copy
< limit
)
9738 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9741 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9746 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9747 /* PR 17531: file: b8ce60a8. */
9748 if (prow
< poffsets
|| prow
> limit
)
9750 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9756 printf (_(" [%3d] 0x%s"),
9757 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9758 buf
, sizeof (buf
)));
9759 for (j
= 0; j
< ncols
; j
++)
9761 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9763 printf (" %8d", val
);
9766 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9768 /* PR 17531: file: 10796eb3. */
9769 if (dw_sect
>= DW_SECT_MAX
)
9770 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9772 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9788 printf (_(" Size table\n"));
9789 printf (" slot %-16s ",
9790 is_tu_index
? _("signature") : _("dwo_id"));
9793 for (j
= 0; j
< ncols
; j
++)
9795 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9797 printf (" %8s", get_DW_SECT_short_name (val
));
9803 for (i
= 0; i
< nslots
; i
++)
9805 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9807 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9810 prow
= psizes
+ (row
- 1) * ncols
* 4;
9813 printf (_(" [%3d] 0x%s"),
9814 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9815 buf
, sizeof (buf
)));
9817 for (j
= 0; j
< ncols
; j
++)
9819 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9821 printf (" %8d", val
);
9824 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9825 if (dw_sect
>= DW_SECT_MAX
)
9826 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9828 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9840 else if (do_display
)
9841 printf (_(" Unsupported version (%d)\n"), version
);
9849 /* Load the CU and TU indexes if present. This will build a list of
9850 section sets that we can use to associate a .debug_info.dwo section
9851 with its associated .debug_abbrev.dwo section in a .dwp file. */
9854 load_cu_tu_indexes (void *file
)
9856 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
9858 /* If we have already loaded (or tried to load) the CU and TU indexes
9859 then do not bother to repeat the task. */
9860 if (cu_tu_indexes_read
== -1)
9862 cu_tu_indexes_read
= TRUE
;
9864 if (load_debug_section_with_follow (dwp_cu_index
, file
))
9865 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
9866 cu_tu_indexes_read
= FALSE
;
9868 if (load_debug_section_with_follow (dwp_tu_index
, file
))
9869 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
9870 cu_tu_indexes_read
= FALSE
;
9873 return (bfd_boolean
) cu_tu_indexes_read
;
9876 /* Find the set of sections that includes section SHNDX. */
9879 find_cu_tu_set (void *file
, unsigned int shndx
)
9883 if (! load_cu_tu_indexes (file
))
9886 /* Find SHNDX in the shndx pool. */
9887 for (i
= 0; i
< shndx_pool_used
; i
++)
9888 if (shndx_pool
[i
] == shndx
)
9891 if (i
>= shndx_pool_used
)
9894 /* Now backup to find the first entry in the set. */
9895 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9898 return shndx_pool
+ i
;
9901 /* Display a .debug_cu_index or .debug_tu_index section. */
9904 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9906 return process_cu_tu_index (section
, 1);
9910 display_debug_not_supported (struct dwarf_section
*section
,
9911 void *file ATTRIBUTE_UNUSED
)
9913 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9919 /* Like malloc, but takes two parameters like calloc.
9920 Verifies that the first parameter is not too large.
9921 Note: does *not* initialise the allocated memory to zero. */
9924 cmalloc (size_t nmemb
, size_t size
)
9926 /* Check for overflow. */
9927 if (nmemb
>= ~(size_t) 0 / size
)
9930 return xmalloc (nmemb
* size
);
9933 /* Like xmalloc, but takes two parameters like calloc.
9934 Verifies that the first parameter is not too large.
9935 Note: does *not* initialise the allocated memory to zero. */
9938 xcmalloc (size_t nmemb
, size_t size
)
9940 /* Check for overflow. */
9941 if (nmemb
>= ~(size_t) 0 / size
)
9944 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9949 return xmalloc (nmemb
* size
);
9952 /* Like xrealloc, but takes three parameters.
9953 Verifies that the second parameter is not too large.
9954 Note: does *not* initialise any new memory to zero. */
9957 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9959 /* Check for overflow. */
9960 if (nmemb
>= ~(size_t) 0 / size
)
9962 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9967 return xrealloc (ptr
, nmemb
* size
);
9970 /* Like xcalloc, but verifies that the first parameter is not too large. */
9973 xcalloc2 (size_t nmemb
, size_t size
)
9975 /* Check for overflow. */
9976 if (nmemb
>= ~(size_t) 0 / size
)
9978 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9983 return xcalloc (nmemb
, size
);
9986 static unsigned long
9987 calc_gnu_debuglink_crc32 (unsigned long crc
,
9988 const unsigned char * buf
,
9991 static const unsigned long crc32_table
[256] =
9993 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
9994 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
9995 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
9996 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
9997 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
9998 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
9999 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10000 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10001 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10002 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10003 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10004 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10005 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10006 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10007 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10008 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10009 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10010 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10011 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10012 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10013 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10014 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10015 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10016 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10017 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10018 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10019 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10020 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10021 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10022 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10023 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10024 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10025 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10026 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10027 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10028 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10029 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10030 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10031 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10032 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10033 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10034 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10035 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10036 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10037 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10038 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10039 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10040 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10041 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10042 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10043 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10046 const unsigned char *end
;
10048 crc
= ~crc
& 0xffffffff;
10049 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10050 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10051 return ~crc
& 0xffffffff;
10054 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10055 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10058 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10060 static unsigned char buffer
[8 * 1024];
10062 bfd_size_type count
;
10063 unsigned long crc
= 0;
10066 sep_data
= open_debug_file (pathname
);
10067 if (sep_data
== NULL
)
10070 /* Yes - we are opening the file twice... */
10071 f
= fopen (pathname
, "rb");
10074 /* Paranoia: This should never happen. */
10075 close_debug_file (sep_data
);
10076 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10080 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10081 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10085 if (crc
!= * (unsigned long *) crc_pointer
)
10087 close_debug_file (sep_data
);
10088 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10096 static const char *
10097 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10100 unsigned int crc_offset
;
10101 unsigned long * crc32
= (unsigned long *) data
;
10103 /* The name is first.
10104 The CRC value is stored after the filename, aligned up to 4 bytes. */
10105 name
= (const char *) section
->start
;
10108 crc_offset
= strnlen (name
, section
->size
) + 1;
10109 crc_offset
= (crc_offset
+ 3) & ~3;
10110 if (crc_offset
+ 4 > section
->size
)
10113 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10118 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10120 void * sep_data
= open_debug_file (filename
);
10122 if (sep_data
== NULL
)
10125 /* FIXME: We should now extract the build-id in the separate file
10131 typedef struct build_id_data
10134 const unsigned char * data
;
10137 static const char *
10138 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10141 bfd_size_type namelen
;
10142 bfd_size_type id_len
;
10143 Build_id_data
* build_id_data
;
10145 /* The name is first.
10146 The build-id follows immediately, with no padding, up to the section's end. */
10148 name
= (const char *) section
->start
;
10149 namelen
= strnlen (name
, section
->size
) + 1;
10150 if (namelen
>= section
->size
)
10153 id_len
= section
->size
- namelen
;
10157 build_id_data
= calloc (1, sizeof * build_id_data
);
10158 if (build_id_data
== NULL
)
10161 build_id_data
->len
= id_len
;
10162 build_id_data
->data
= section
->start
+ namelen
;
10164 * (Build_id_data
**) data
= build_id_data
;
10170 add_separate_debug_file (const char * filename
, void * handle
)
10172 separate_info
* i
= xmalloc (sizeof * i
);
10174 i
->filename
= filename
;
10175 i
->handle
= handle
;
10176 i
->next
= first_separate_info
;
10177 first_separate_info
= i
;
10180 #if HAVE_LIBDEBUGINFOD
10181 /* Query debuginfod servers for the target debuglink or debugaltlink
10182 file. If successful, store the path of the file in filename and
10183 return TRUE, otherwise return FALSE. */
10186 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10190 size_t build_id_len
;
10191 unsigned char * build_id
;
10193 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10195 /* Get the build-id of file. */
10196 build_id
= get_build_id (file
);
10199 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10201 /* Get the build-id of the debugaltlink file. */
10202 unsigned int filelen
;
10204 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10205 if (filelen
== section
->size
)
10206 /* Corrupt debugaltlink. */
10209 build_id
= section
->start
+ filelen
+ 1;
10210 build_id_len
= section
->size
- (filelen
+ 1);
10212 if (build_id_len
== 0)
10221 debuginfod_client
* client
;
10223 client
= debuginfod_begin ();
10224 if (client
== NULL
)
10227 /* Query debuginfod servers for the target file. If found its path
10228 will be stored in filename. */
10229 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10230 debuginfod_end (client
);
10232 /* Only free build_id if we allocated space for a hex string
10233 in get_build_id (). */
10234 if (build_id_len
== 0)
10239 /* File successfully retrieved. Close fd since we want to
10240 use open_debug_file () on filename instead. */
10251 load_separate_debug_info (const char * main_filename
,
10252 struct dwarf_section
* xlink
,
10253 parse_func_type parse_func
,
10254 check_func_type check_func
,
10256 void * file ATTRIBUTE_UNUSED
)
10258 const char * separate_filename
;
10259 char * debug_filename
;
10261 size_t canon_dirlen
;
10264 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10266 warn (_("Corrupt debuglink section: %s\n"),
10267 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10271 /* Attempt to locate the separate file.
10272 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10274 canon_dir
= lrealpath (main_filename
);
10276 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10277 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10279 canon_dir
[canon_dirlen
] = '\0';
10282 #define DEBUGDIR "/lib/debug"
10284 #ifndef EXTRA_DEBUG_ROOT1
10285 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10287 #ifndef EXTRA_DEBUG_ROOT2
10288 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10291 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10293 + strlen (".debug/")
10294 #ifdef EXTRA_DEBUG_ROOT1
10295 + strlen (EXTRA_DEBUG_ROOT1
)
10297 #ifdef EXTRA_DEBUG_ROOT2
10298 + strlen (EXTRA_DEBUG_ROOT2
)
10300 + strlen (separate_filename
)
10302 if (debug_filename
== NULL
)
10304 warn (_("Out of memory"));
10309 /* First try in the current directory. */
10310 sprintf (debug_filename
, "%s", separate_filename
);
10311 if (check_func (debug_filename
, func_data
))
10314 /* Then try in a subdirectory called .debug. */
10315 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10316 if (check_func (debug_filename
, func_data
))
10319 /* Then try in the same directory as the original file. */
10320 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10321 if (check_func (debug_filename
, func_data
))
10324 /* And the .debug subdirectory of that directory. */
10325 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10326 if (check_func (debug_filename
, func_data
))
10329 #ifdef EXTRA_DEBUG_ROOT1
10330 /* Try the first extra debug file root. */
10331 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10332 if (check_func (debug_filename
, func_data
))
10335 /* Try the first extra debug file root. */
10336 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10337 if (check_func (debug_filename
, func_data
))
10341 #ifdef EXTRA_DEBUG_ROOT2
10342 /* Try the second extra debug file root. */
10343 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10344 if (check_func (debug_filename
, func_data
))
10348 /* Then try in the global debug_filename directory. */
10349 strcpy (debug_filename
, DEBUGDIR
);
10350 dirlen
= strlen (DEBUGDIR
) - 1;
10351 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10352 strcat (debug_filename
, "/");
10353 strcat (debug_filename
, (const char *) separate_filename
);
10355 if (check_func (debug_filename
, func_data
))
10358 #if HAVE_LIBDEBUGINFOD
10360 char * tmp_filename
;
10362 if (debuginfod_fetch_separate_debug_info (xlink
,
10366 /* File successfully downloaded from server, replace
10367 debug_filename with the file's path. */
10368 free (debug_filename
);
10369 debug_filename
= tmp_filename
;
10375 /* Failed to find the file. */
10376 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10377 warn (_("tried: %s\n"), debug_filename
);
10379 #ifdef EXTRA_DEBUG_ROOT2
10380 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10381 warn (_("tried: %s\n"), debug_filename
);
10384 #ifdef EXTRA_DEBUG_ROOT1
10385 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10386 warn (_("tried: %s\n"), debug_filename
);
10388 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10389 warn (_("tried: %s\n"), debug_filename
);
10392 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10393 warn (_("tried: %s\n"), debug_filename
);
10395 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10396 warn (_("tried: %s\n"), debug_filename
);
10398 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10399 warn (_("tried: %s\n"), debug_filename
);
10401 sprintf (debug_filename
, "%s", separate_filename
);
10402 warn (_("tried: %s\n"), debug_filename
);
10404 #if HAVE_LIBDEBUGINFOD
10406 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
10410 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
10415 free (debug_filename
);
10421 void * debug_handle
;
10423 /* Now open the file.... */
10424 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10426 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10427 free (debug_filename
);
10431 /* FIXME: We do not check to see if there are any other separate debug info
10432 files that would also match. */
10434 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10435 add_separate_debug_file (debug_filename
, debug_handle
);
10437 /* Do not free debug_filename - it might be referenced inside
10438 the structure returned by open_debug_file(). */
10439 return debug_handle
;
10442 /* Attempt to load a separate dwarf object file. */
10445 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10447 char * separate_filename
;
10448 void * separate_handle
;
10450 /* FIXME: Skip adding / if dwo_dir ends in /. */
10451 separate_filename
= concat (dir
, "/", name
, NULL
);
10452 if (separate_filename
== NULL
)
10454 warn (_("Out of memory allocating dwo filename\n"));
10458 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10460 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10461 free (separate_filename
);
10465 /* FIXME: We should check the dwo_id. */
10467 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10468 add_separate_debug_file (separate_filename
, separate_handle
);
10469 /* Note - separate_filename will be freed in free_debug_memory(). */
10470 return separate_handle
;
10473 /* Load the separate debug info file(s) attached to FILE, if any exist.
10474 Returns TRUE if any were found, FALSE otherwise.
10475 If TRUE is returned then the linked list starting at first_separate_info
10476 will be populated with open file handles. */
10479 load_separate_debug_files (void * file
, const char * filename
)
10481 /* Skip this operation if we are not interested in debug links. */
10482 if (! do_follow_links
&& ! do_debug_links
)
10485 /* See if there are any dwo links. */
10486 if (load_debug_section (str
, file
)
10487 && load_debug_section (abbrev
, file
)
10488 && load_debug_section (info
, file
))
10492 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10494 bfd_boolean introduced
= FALSE
;
10496 const char * dir
= NULL
;
10497 const char * id
= NULL
;
10499 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10501 switch (dwinfo
->type
)
10504 if (do_debug_links
)
10508 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10509 debug_displays
[info
].section
.uncompressed_name
);
10513 printf (_(" Name: %s\n"), dwinfo
->value
);
10514 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10516 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10518 printf (_(" ID: <unknown>\n"));
10522 if (do_follow_links
)
10523 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10527 dir
= dwinfo
->value
;
10531 id
= dwinfo
->value
;
10535 error (_("Unexpected DWO INFO type"));
10542 if (! do_follow_links
)
10543 /* The other debug links will be displayed by display_debug_links()
10544 so we do not need to do any further processing here. */
10547 /* FIXME: We do not check for the presence of both link sections in the same file. */
10548 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10549 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10550 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10552 if (load_debug_section (gnu_debugaltlink
, file
))
10554 Build_id_data
* build_id_data
;
10556 load_separate_debug_info (filename
,
10557 & debug_displays
[gnu_debugaltlink
].section
,
10558 parse_gnu_debugaltlink
,
10559 check_gnu_debugaltlink
,
10564 if (load_debug_section (gnu_debuglink
, file
))
10566 unsigned long crc32
;
10568 load_separate_debug_info (filename
,
10569 & debug_displays
[gnu_debuglink
].section
,
10570 parse_gnu_debuglink
,
10571 check_gnu_debuglink
,
10576 if (first_separate_info
!= NULL
)
10579 do_follow_links
= 0;
10584 free_debug_memory (void)
10590 for (i
= 0; i
< max
; i
++)
10591 free_debug_section ((enum dwarf_section_display_enum
) i
);
10593 if (debug_information
!= NULL
)
10595 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10597 for (i
= 0; i
< num_debug_info_entries
; i
++)
10599 if (!debug_information
[i
].max_loc_offsets
)
10601 free (debug_information
[i
].loc_offsets
);
10602 free (debug_information
[i
].have_frame_base
);
10604 if (!debug_information
[i
].max_range_lists
)
10605 free (debug_information
[i
].range_lists
);
10608 free (debug_information
);
10609 debug_information
= NULL
;
10610 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10614 separate_info
* next
;
10616 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10618 close_debug_file (d
->handle
);
10619 free ((void *) d
->filename
);
10623 first_separate_info
= NULL
;
10629 dwarf_select_sections_by_names (const char *names
)
10633 const char * option
;
10637 debug_dump_long_opts
;
10639 static const debug_dump_long_opts opts_table
[] =
10641 /* Please keep this table alpha- sorted. */
10642 { "Ranges", & do_debug_ranges
, 1 },
10643 { "abbrev", & do_debug_abbrevs
, 1 },
10644 { "addr", & do_debug_addr
, 1 },
10645 { "aranges", & do_debug_aranges
, 1 },
10646 { "cu_index", & do_debug_cu_index
, 1 },
10647 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10648 { "follow-links", & do_follow_links
, 1 },
10649 { "frames", & do_debug_frames
, 1 },
10650 { "frames-interp", & do_debug_frames_interp
, 1 },
10651 /* The special .gdb_index section. */
10652 { "gdb_index", & do_gdb_index
, 1 },
10653 { "info", & do_debug_info
, 1 },
10654 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10655 { "links", & do_debug_links
, 1 },
10656 { "loc", & do_debug_loc
, 1 },
10657 { "macro", & do_debug_macinfo
, 1 },
10658 { "pubnames", & do_debug_pubnames
, 1 },
10659 { "pubtypes", & do_debug_pubtypes
, 1 },
10660 /* This entry is for compatibility
10661 with earlier versions of readelf. */
10662 { "ranges", & do_debug_aranges
, 1 },
10663 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10664 { "str", & do_debug_str
, 1 },
10665 /* These trace_* sections are used by Itanium VMS. */
10666 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10667 { "trace_aranges", & do_trace_aranges
, 1 },
10668 { "trace_info", & do_trace_info
, 1 },
10677 const debug_dump_long_opts
* entry
;
10679 for (entry
= opts_table
; entry
->option
; entry
++)
10681 size_t len
= strlen (entry
->option
);
10683 if (strncmp (p
, entry
->option
, len
) == 0
10684 && (p
[len
] == ',' || p
[len
] == '\0'))
10686 * entry
->variable
|= entry
->val
;
10688 /* The --debug-dump=frames-interp option also
10689 enables the --debug-dump=frames option. */
10690 if (do_debug_frames_interp
)
10691 do_debug_frames
= 1;
10698 if (entry
->option
== NULL
)
10700 warn (_("Unrecognized debug option '%s'\n"), p
);
10701 p
= strchr (p
, ',');
10712 dwarf_select_sections_by_letters (const char *letters
)
10714 unsigned int lindex
= 0;
10716 while (letters
[lindex
])
10717 switch (letters
[lindex
++])
10719 case 'A': do_debug_addr
= 1; break;
10720 case 'a': do_debug_abbrevs
= 1; break;
10721 case 'c': do_debug_cu_index
= 1; break;
10722 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10723 case 'f': do_debug_frames
= 1; break;
10724 case 'g': do_gdb_index
= 1; break;
10725 case 'i': do_debug_info
= 1; break;
10726 case 'K': do_follow_links
= 1; break;
10727 case 'k': do_debug_links
= 1; break;
10728 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10729 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10730 case 'm': do_debug_macinfo
= 1; break;
10731 case 'o': do_debug_loc
= 1; break;
10732 case 'p': do_debug_pubnames
= 1; break;
10733 case 'R': do_debug_ranges
= 1; break;
10734 case 'r': do_debug_aranges
= 1; break;
10735 case 's': do_debug_str
= 1; break;
10736 case 'T': do_trace_aranges
= 1; break;
10737 case 't': do_debug_pubtypes
= 1; break;
10738 case 'U': do_trace_info
= 1; break;
10739 case 'u': do_trace_abbrevs
= 1; break;
10742 warn (_("Unrecognized debug option '%s'\n"), letters
);
10748 dwarf_select_sections_all (void)
10751 do_debug_abbrevs
= 1;
10752 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10753 do_debug_pubnames
= 1;
10754 do_debug_pubtypes
= 1;
10755 do_debug_aranges
= 1;
10756 do_debug_ranges
= 1;
10757 do_debug_frames
= 1;
10758 do_debug_macinfo
= 1;
10763 do_trace_abbrevs
= 1;
10764 do_trace_aranges
= 1;
10766 do_debug_cu_index
= 1;
10767 do_follow_links
= 1;
10768 do_debug_links
= 1;
10771 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10772 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10774 /* N.B. The order here must match the order in section_display_enum. */
10776 struct dwarf_section_display debug_displays
[] =
10778 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10779 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10780 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10781 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10782 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10783 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10784 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10785 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10786 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10787 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10788 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10789 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10790 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10791 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10792 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10793 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10794 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10795 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10796 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10797 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10798 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10799 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10800 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10801 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10802 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10803 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10804 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10805 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10806 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10807 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10808 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10809 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10810 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10811 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10812 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10813 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10814 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10815 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10816 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10817 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10818 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10819 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10820 /* Separate debug info files can containt their own .debug_str section,
10821 and this might be in *addition* to a .debug_str section already present
10822 in the main file. Hence we need to have two entries for .debug_str. */
10823 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10826 /* A static assertion. */
10827 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];