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) case VALUE + 4096: name = #NAME; break;
7413 #include "opcode/riscv-opc.h"
7418 static char csr_name
[10];
7419 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7430 init_dwarf_regnames_riscv (void)
7432 dwarf_regnames
= NULL
;
7433 dwarf_regnames_count
= 8192;
7434 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7438 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7440 dwarf_regnames_lookup_func
= NULL
;
7445 init_dwarf_regnames_i386 ();
7449 init_dwarf_regnames_iamcu ();
7455 init_dwarf_regnames_x86_64 ();
7459 init_dwarf_regnames_aarch64 ();
7463 init_dwarf_regnames_s390 ();
7467 init_dwarf_regnames_riscv ();
7475 /* Initialize the DWARF register name lookup state based on the
7476 architecture and specific machine type of a BFD. */
7479 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7482 dwarf_regnames_lookup_func
= NULL
;
7489 case bfd_mach_x86_64
:
7490 case bfd_mach_x86_64_intel_syntax
:
7491 case bfd_mach_x86_64_nacl
:
7492 case bfd_mach_x64_32
:
7493 case bfd_mach_x64_32_intel_syntax
:
7494 case bfd_mach_x64_32_nacl
:
7495 init_dwarf_regnames_x86_64 ();
7499 init_dwarf_regnames_i386 ();
7504 case bfd_arch_iamcu
:
7505 init_dwarf_regnames_iamcu ();
7508 case bfd_arch_aarch64
:
7509 init_dwarf_regnames_aarch64();
7513 init_dwarf_regnames_s390 ();
7516 case bfd_arch_riscv
:
7517 init_dwarf_regnames_riscv ();
7526 regname_internal_by_table_only (unsigned int regno
)
7528 if (dwarf_regnames
!= NULL
7529 && regno
< dwarf_regnames_count
7530 && dwarf_regnames
[regno
] != NULL
)
7531 return dwarf_regnames
[regno
];
7537 regname (unsigned int regno
, int name_only_p
)
7539 static char reg
[64];
7541 const char *name
= NULL
;
7543 if (dwarf_regnames_lookup_func
!= NULL
)
7544 name
= dwarf_regnames_lookup_func (regno
);
7550 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7553 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7558 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7563 if (*max_regs
!= fc
->ncols
)
7564 *max_regs
= fc
->ncols
;
7566 if (*need_col_headers
)
7568 static const char *sloc
= " LOC";
7570 *need_col_headers
= 0;
7572 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7574 for (r
= 0; r
< *max_regs
; r
++)
7575 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7580 printf ("%-5s ", regname (r
, 1));
7586 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7588 strcpy (tmp
, "exp");
7590 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7591 printf ("%-8s ", tmp
);
7593 for (r
= 0; r
< fc
->ncols
; r
++)
7595 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7597 switch (fc
->col_type
[r
])
7599 case DW_CFA_undefined
:
7602 case DW_CFA_same_value
:
7606 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7608 case DW_CFA_val_offset
:
7609 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7611 case DW_CFA_register
:
7612 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7614 case DW_CFA_expression
:
7615 strcpy (tmp
, "exp");
7617 case DW_CFA_val_expression
:
7618 strcpy (tmp
, "vexp");
7621 strcpy (tmp
, "n/a");
7624 printf ("%-5s ", tmp
);
7630 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7632 static unsigned char *
7633 read_cie (unsigned char *start
, unsigned char *end
,
7634 Frame_Chunk
**p_cie
, int *p_version
,
7635 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7639 unsigned char *augmentation_data
= NULL
;
7640 bfd_size_type augmentation_data_len
= 0;
7643 /* PR 17512: file: 001-228113-0.004. */
7647 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7648 memset (fc
, 0, sizeof (Frame_Chunk
));
7650 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7651 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7655 fc
->augmentation
= (char *) start
;
7656 /* PR 17512: file: 001-228113-0.004.
7657 Skip past augmentation name, but avoid running off the end of the data. */
7659 if (* start
++ == '\0')
7663 warn (_("No terminator for augmentation name\n"));
7667 if (strcmp (fc
->augmentation
, "eh") == 0)
7668 start
+= eh_addr_size
;
7672 GET (fc
->ptr_size
, 1);
7673 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7675 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7679 GET (fc
->segment_size
, 1);
7680 /* PR 17512: file: e99d2804. */
7681 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7683 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7687 eh_addr_size
= fc
->ptr_size
;
7691 fc
->ptr_size
= eh_addr_size
;
7692 fc
->segment_size
= 0;
7695 READ_ULEB (fc
->code_factor
, start
, end
);
7696 READ_SLEB (fc
->data_factor
, start
, end
);
7704 READ_ULEB (fc
->ra
, start
, end
);
7707 if (fc
->augmentation
[0] == 'z')
7709 READ_ULEB (augmentation_data_len
, start
, end
);
7710 augmentation_data
= start
;
7711 /* PR 17512: file: 11042-2589-0.004. */
7712 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7714 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7715 dwarf_vmatoa ("x", augmentation_data_len
),
7716 (unsigned long) (end
- start
));
7719 start
+= augmentation_data_len
;
7722 if (augmentation_data_len
)
7726 unsigned char *qend
;
7728 p
= (unsigned char *) fc
->augmentation
+ 1;
7729 q
= augmentation_data
;
7730 qend
= q
+ augmentation_data_len
;
7732 while (p
< end
&& q
< qend
)
7737 q
+= 1 + size_of_encoded_value (*q
);
7739 fc
->fde_encoding
= *q
++;
7748 /* Note - it is OK if this loop terminates with q < qend.
7749 Padding may have been inserted to align the end of the CIE. */
7754 *p_version
= version
;
7757 *p_aug_len
= augmentation_data_len
;
7758 *p_aug
= augmentation_data
;
7763 free (fc
->col_offset
);
7764 free (fc
->col_type
);
7769 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7770 If do_wide is not enabled, then formats the output to fit into 80 columns.
7771 PRINTED contains the number of characters already written to the current
7775 display_data (bfd_size_type printed
,
7776 const unsigned char * data
,
7777 const bfd_size_type len
)
7779 if (do_wide
|| len
< ((80 - printed
) / 3))
7780 for (printed
= 0; printed
< len
; ++printed
)
7781 printf (" %02x", data
[printed
]);
7784 for (printed
= 0; printed
< len
; ++printed
)
7786 if (printed
% (80 / 3) == 0)
7788 printf (" %02x", data
[printed
]);
7793 /* Prints out the contents on the augmentation data array.
7794 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7797 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7801 i
= printf (_(" Augmentation data: "));
7802 display_data (i
, data
, len
);
7806 display_debug_frames (struct dwarf_section
*section
,
7807 void *file ATTRIBUTE_UNUSED
)
7809 unsigned char *start
= section
->start
;
7810 unsigned char *end
= start
+ section
->size
;
7811 unsigned char *section_start
= start
;
7812 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7813 Frame_Chunk
*remembered_state
= NULL
;
7815 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7816 unsigned int max_regs
= 0;
7817 const char *bad_reg
= _("bad register: ");
7818 unsigned int saved_eh_addr_size
= eh_addr_size
;
7820 introduce (section
, FALSE
);
7824 unsigned char *saved_start
;
7825 unsigned char *block_end
;
7830 int need_col_headers
= 1;
7831 unsigned char *augmentation_data
= NULL
;
7832 bfd_size_type augmentation_data_len
= 0;
7833 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7834 unsigned int offset_size
;
7835 unsigned int initial_length_size
;
7836 bfd_boolean all_nops
;
7837 static Frame_Chunk fde_fc
;
7839 saved_start
= start
;
7841 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7845 printf ("\n%08lx ZERO terminator\n\n",
7846 (unsigned long)(saved_start
- section_start
));
7847 /* Skip any zero terminators that directly follow.
7848 A corrupt section size could have loaded a whole
7849 slew of zero filled memory bytes. eg
7850 PR 17512: file: 070-19381-0.004. */
7851 while (start
< end
&& * start
== 0)
7856 if (length
== 0xffffffff)
7858 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7860 initial_length_size
= 12;
7865 initial_length_size
= 4;
7868 block_end
= saved_start
+ length
+ initial_length_size
;
7869 if (block_end
> end
|| block_end
< start
)
7871 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7872 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7873 (unsigned long) (saved_start
- section_start
));
7877 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7879 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7880 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7885 start
= read_cie (start
, end
, &cie
, &version
,
7886 &augmentation_data_len
, &augmentation_data
);
7887 /* PR 17512: file: 027-135133-0.005. */
7894 fc
->chunk_start
= saved_start
;
7895 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7898 if (frame_need_space (fc
, mreg
) < 0)
7900 if (fc
->fde_encoding
)
7901 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7903 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7904 print_dwarf_vma (length
, fc
->ptr_size
);
7905 print_dwarf_vma (cie_id
, offset_size
);
7907 if (do_debug_frames_interp
)
7909 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7910 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7915 printf (" Version: %d\n", version
);
7916 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7919 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7920 printf (" Segment Size: %u\n", fc
->segment_size
);
7922 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7923 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7924 printf (" Return address column: %d\n", fc
->ra
);
7926 if (augmentation_data_len
)
7927 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7934 unsigned char *look_for
;
7935 unsigned long segment_selector
;
7939 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7940 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7943 look_for
= section_start
+ cie_id
;
7945 if (look_for
<= saved_start
)
7947 for (cie
= chunks
; cie
; cie
= cie
->next
)
7948 if (cie
->chunk_start
== look_for
)
7953 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7954 if (cie
->chunk_start
== look_for
)
7958 unsigned int off_size
;
7959 unsigned char *cie_scan
;
7961 cie_scan
= look_for
;
7963 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7964 if (length
== 0xffffffff)
7966 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7973 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7976 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7977 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7982 read_cie (cie_scan
, end
, &cie
, &version
,
7983 &augmentation_data_len
, &augmentation_data
);
7984 /* PR 17512: file: 3450-2098-0.004. */
7987 warn (_("Failed to read CIE information\n"));
7990 cie
->next
= forward_refs
;
7992 cie
->chunk_start
= look_for
;
7993 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7996 if (frame_need_space (cie
, mreg
) < 0)
7998 warn (_("Invalid max register\n"));
8001 if (cie
->fde_encoding
)
8003 = size_of_encoded_value (cie
->fde_encoding
);
8010 memset (fc
, 0, sizeof (Frame_Chunk
));
8014 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8015 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8016 (unsigned long) (saved_start
- section_start
));
8018 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8019 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8020 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8022 warn (_("Invalid max register\n"));
8026 fc
->augmentation
= "";
8027 fc
->fde_encoding
= 0;
8028 fc
->ptr_size
= eh_addr_size
;
8029 fc
->segment_size
= 0;
8033 fc
->ncols
= cie
->ncols
;
8034 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8035 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8036 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8037 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8038 fc
->augmentation
= cie
->augmentation
;
8039 fc
->ptr_size
= cie
->ptr_size
;
8040 eh_addr_size
= cie
->ptr_size
;
8041 fc
->segment_size
= cie
->segment_size
;
8042 fc
->code_factor
= cie
->code_factor
;
8043 fc
->data_factor
= cie
->data_factor
;
8044 fc
->cfa_reg
= cie
->cfa_reg
;
8045 fc
->cfa_offset
= cie
->cfa_offset
;
8047 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8049 warn (_("Invalid max register\n"));
8052 fc
->fde_encoding
= cie
->fde_encoding
;
8055 if (fc
->fde_encoding
)
8056 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8058 segment_selector
= 0;
8059 if (fc
->segment_size
)
8061 if (fc
->segment_size
> sizeof (segment_selector
))
8063 /* PR 17512: file: 9e196b3e. */
8064 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8065 fc
->segment_size
= 4;
8067 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8070 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8072 /* FIXME: It appears that sometimes the final pc_range value is
8073 encoded in less than encoded_ptr_size bytes. See the x86_64
8074 run of the "objcopy on compressed debug sections" test for an
8076 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8078 if (cie
->augmentation
[0] == 'z')
8080 READ_ULEB (augmentation_data_len
, start
, end
);
8081 augmentation_data
= start
;
8082 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8083 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8085 warn (_("Augmentation data too long: 0x%s, "
8086 "expected at most %#lx\n"),
8087 dwarf_vmatoa ("x", augmentation_data_len
),
8088 (unsigned long) (end
- start
));
8090 augmentation_data
= NULL
;
8091 augmentation_data_len
= 0;
8093 start
+= augmentation_data_len
;
8096 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8097 (unsigned long)(saved_start
- section_start
),
8098 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8099 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8100 (unsigned long)(cie
->chunk_start
- section_start
));
8102 if (fc
->segment_size
)
8103 printf ("%04lx:", segment_selector
);
8106 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8107 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8109 if (! do_debug_frames_interp
&& augmentation_data_len
)
8111 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8116 /* At this point, fc is the current chunk, cie (if any) is set, and
8117 we're about to interpret instructions for the chunk. */
8118 /* ??? At present we need to do this always, since this sizes the
8119 fc->col_type and fc->col_offset arrays, which we write into always.
8120 We should probably split the interpreted and non-interpreted bits
8121 into two different routines, since there's so much that doesn't
8122 really overlap between them. */
8123 if (1 || do_debug_frames_interp
)
8125 /* Start by making a pass over the chunk, allocating storage
8126 and taking note of what registers are used. */
8127 unsigned char *tmp
= start
;
8129 while (start
< block_end
)
8131 unsigned int reg
, op
, opa
;
8133 unsigned char * new_start
;
8140 /* Warning: if you add any more cases to this switch, be
8141 sure to add them to the corresponding switch below. */
8144 case DW_CFA_advance_loc
:
8147 SKIP_ULEB (start
, end
);
8148 if (frame_need_space (fc
, opa
) >= 0)
8149 fc
->col_type
[opa
] = DW_CFA_undefined
;
8151 case DW_CFA_restore
:
8152 if (frame_need_space (fc
, opa
) >= 0)
8153 fc
->col_type
[opa
] = DW_CFA_undefined
;
8155 case DW_CFA_set_loc
:
8156 start
+= encoded_ptr_size
;
8158 case DW_CFA_advance_loc1
:
8161 case DW_CFA_advance_loc2
:
8164 case DW_CFA_advance_loc4
:
8167 case DW_CFA_offset_extended
:
8168 case DW_CFA_val_offset
:
8169 READ_ULEB (reg
, start
, end
);
8170 SKIP_ULEB (start
, end
);
8171 if (frame_need_space (fc
, reg
) >= 0)
8172 fc
->col_type
[reg
] = DW_CFA_undefined
;
8174 case DW_CFA_restore_extended
:
8175 READ_ULEB (reg
, start
, end
);
8176 if (frame_need_space (fc
, reg
) >= 0)
8177 fc
->col_type
[reg
] = DW_CFA_undefined
;
8179 case DW_CFA_undefined
:
8180 READ_ULEB (reg
, start
, end
);
8181 if (frame_need_space (fc
, reg
) >= 0)
8182 fc
->col_type
[reg
] = DW_CFA_undefined
;
8184 case DW_CFA_same_value
:
8185 READ_ULEB (reg
, start
, end
);
8186 if (frame_need_space (fc
, reg
) >= 0)
8187 fc
->col_type
[reg
] = DW_CFA_undefined
;
8189 case DW_CFA_register
:
8190 READ_ULEB (reg
, start
, end
);
8191 SKIP_ULEB (start
, end
);
8192 if (frame_need_space (fc
, reg
) >= 0)
8193 fc
->col_type
[reg
] = DW_CFA_undefined
;
8195 case DW_CFA_def_cfa
:
8196 SKIP_ULEB (start
, end
);
8197 SKIP_ULEB (start
, end
);
8199 case DW_CFA_def_cfa_register
:
8200 SKIP_ULEB (start
, end
);
8202 case DW_CFA_def_cfa_offset
:
8203 SKIP_ULEB (start
, end
);
8205 case DW_CFA_def_cfa_expression
:
8206 READ_ULEB (temp
, start
, end
);
8207 new_start
= start
+ temp
;
8208 if (new_start
< start
)
8210 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8216 case DW_CFA_expression
:
8217 case DW_CFA_val_expression
:
8218 READ_ULEB (reg
, start
, end
);
8219 READ_ULEB (temp
, start
, end
);
8220 new_start
= start
+ temp
;
8221 if (new_start
< start
)
8223 /* PR 17512: file:306-192417-0.005. */
8224 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8229 if (frame_need_space (fc
, reg
) >= 0)
8230 fc
->col_type
[reg
] = DW_CFA_undefined
;
8232 case DW_CFA_offset_extended_sf
:
8233 case DW_CFA_val_offset_sf
:
8234 READ_ULEB (reg
, start
, end
);
8235 SKIP_SLEB (start
, end
);
8236 if (frame_need_space (fc
, reg
) >= 0)
8237 fc
->col_type
[reg
] = DW_CFA_undefined
;
8239 case DW_CFA_def_cfa_sf
:
8240 SKIP_ULEB (start
, end
);
8241 SKIP_SLEB (start
, end
);
8243 case DW_CFA_def_cfa_offset_sf
:
8244 SKIP_SLEB (start
, end
);
8246 case DW_CFA_MIPS_advance_loc8
:
8249 case DW_CFA_GNU_args_size
:
8250 SKIP_ULEB (start
, end
);
8252 case DW_CFA_GNU_negative_offset_extended
:
8253 READ_ULEB (reg
, start
, end
);
8254 SKIP_ULEB (start
, end
);
8255 if (frame_need_space (fc
, reg
) >= 0)
8256 fc
->col_type
[reg
] = DW_CFA_undefined
;
8267 /* Now we know what registers are used, make a second pass over
8268 the chunk, this time actually printing out the info. */
8270 while (start
< block_end
)
8272 unsigned char * tmp
;
8274 unsigned long ul
, roffs
;
8275 /* Note: It is tempting to use an unsigned long for 'reg' but there
8276 are various functions, notably frame_space_needed() that assume that
8277 reg is an unsigned int. */
8282 const char *reg_prefix
= "";
8289 /* Make a note if something other than DW_CFA_nop happens. */
8290 if (op
!= DW_CFA_nop
)
8293 /* Warning: if you add any more cases to this switch, be
8294 sure to add them to the corresponding switch above. */
8297 case DW_CFA_advance_loc
:
8298 if (do_debug_frames_interp
)
8299 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8301 printf (" DW_CFA_advance_loc: %d to %s\n",
8302 opa
* fc
->code_factor
,
8303 dwarf_vmatoa_1 (NULL
,
8304 fc
->pc_begin
+ opa
* fc
->code_factor
,
8306 fc
->pc_begin
+= opa
* fc
->code_factor
;
8310 READ_ULEB (roffs
, start
, end
);
8311 if (opa
>= (unsigned int) fc
->ncols
)
8312 reg_prefix
= bad_reg
;
8313 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8314 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8315 reg_prefix
, regname (opa
, 0),
8316 roffs
* fc
->data_factor
);
8317 if (*reg_prefix
== '\0')
8319 fc
->col_type
[opa
] = DW_CFA_offset
;
8320 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8324 case DW_CFA_restore
:
8325 if (opa
>= (unsigned int) fc
->ncols
)
8326 reg_prefix
= bad_reg
;
8327 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8328 printf (" DW_CFA_restore: %s%s\n",
8329 reg_prefix
, regname (opa
, 0));
8330 if (*reg_prefix
!= '\0')
8333 if (opa
>= (unsigned int) cie
->ncols
8334 || (do_debug_frames_interp
8335 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8337 fc
->col_type
[opa
] = DW_CFA_undefined
;
8338 fc
->col_offset
[opa
] = 0;
8342 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8343 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8347 case DW_CFA_set_loc
:
8348 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8349 if (do_debug_frames_interp
)
8350 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8352 printf (" DW_CFA_set_loc: %s\n",
8353 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8357 case DW_CFA_advance_loc1
:
8358 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8359 if (do_debug_frames_interp
)
8360 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8362 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8363 (unsigned long) (ofs
* fc
->code_factor
),
8364 dwarf_vmatoa_1 (NULL
,
8365 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8367 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8370 case DW_CFA_advance_loc2
:
8371 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8372 if (do_debug_frames_interp
)
8373 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8375 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8376 (unsigned long) (ofs
* fc
->code_factor
),
8377 dwarf_vmatoa_1 (NULL
,
8378 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8380 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8383 case DW_CFA_advance_loc4
:
8384 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8385 if (do_debug_frames_interp
)
8386 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8388 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8389 (unsigned long) (ofs
* fc
->code_factor
),
8390 dwarf_vmatoa_1 (NULL
,
8391 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8393 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8396 case DW_CFA_offset_extended
:
8397 READ_ULEB (reg
, start
, end
);
8398 READ_ULEB (roffs
, start
, end
);
8399 if (reg
>= (unsigned int) fc
->ncols
)
8400 reg_prefix
= bad_reg
;
8401 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8402 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8403 reg_prefix
, regname (reg
, 0),
8404 roffs
* fc
->data_factor
);
8405 if (*reg_prefix
== '\0')
8407 fc
->col_type
[reg
] = DW_CFA_offset
;
8408 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8412 case DW_CFA_val_offset
:
8413 READ_ULEB (reg
, start
, end
);
8414 READ_ULEB (roffs
, start
, end
);
8415 if (reg
>= (unsigned int) fc
->ncols
)
8416 reg_prefix
= bad_reg
;
8417 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8418 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8419 reg_prefix
, regname (reg
, 0),
8420 roffs
* fc
->data_factor
);
8421 if (*reg_prefix
== '\0')
8423 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8424 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8428 case DW_CFA_restore_extended
:
8429 READ_ULEB (reg
, start
, end
);
8430 if (reg
>= (unsigned int) fc
->ncols
)
8431 reg_prefix
= bad_reg
;
8432 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8433 printf (" DW_CFA_restore_extended: %s%s\n",
8434 reg_prefix
, regname (reg
, 0));
8435 if (*reg_prefix
!= '\0')
8438 if (reg
>= (unsigned int) cie
->ncols
)
8440 fc
->col_type
[reg
] = DW_CFA_undefined
;
8441 fc
->col_offset
[reg
] = 0;
8445 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8446 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8450 case DW_CFA_undefined
:
8451 READ_ULEB (reg
, start
, end
);
8452 if (reg
>= (unsigned int) fc
->ncols
)
8453 reg_prefix
= bad_reg
;
8454 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8455 printf (" DW_CFA_undefined: %s%s\n",
8456 reg_prefix
, regname (reg
, 0));
8457 if (*reg_prefix
== '\0')
8459 fc
->col_type
[reg
] = DW_CFA_undefined
;
8460 fc
->col_offset
[reg
] = 0;
8464 case DW_CFA_same_value
:
8465 READ_ULEB (reg
, start
, end
);
8466 if (reg
>= (unsigned int) fc
->ncols
)
8467 reg_prefix
= bad_reg
;
8468 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8469 printf (" DW_CFA_same_value: %s%s\n",
8470 reg_prefix
, regname (reg
, 0));
8471 if (*reg_prefix
== '\0')
8473 fc
->col_type
[reg
] = DW_CFA_same_value
;
8474 fc
->col_offset
[reg
] = 0;
8478 case DW_CFA_register
:
8479 READ_ULEB (reg
, start
, end
);
8480 READ_ULEB (roffs
, start
, end
);
8481 if (reg
>= (unsigned int) fc
->ncols
)
8482 reg_prefix
= bad_reg
;
8483 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8485 printf (" DW_CFA_register: %s%s in ",
8486 reg_prefix
, regname (reg
, 0));
8487 puts (regname (roffs
, 0));
8489 if (*reg_prefix
== '\0')
8491 fc
->col_type
[reg
] = DW_CFA_register
;
8492 fc
->col_offset
[reg
] = roffs
;
8496 case DW_CFA_remember_state
:
8497 if (! do_debug_frames_interp
)
8498 printf (" DW_CFA_remember_state\n");
8499 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8500 rs
->cfa_offset
= fc
->cfa_offset
;
8501 rs
->cfa_reg
= fc
->cfa_reg
;
8503 rs
->cfa_exp
= fc
->cfa_exp
;
8504 rs
->ncols
= fc
->ncols
;
8505 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8506 sizeof (* rs
->col_type
));
8507 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8508 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8509 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8510 rs
->next
= remembered_state
;
8511 remembered_state
= rs
;
8514 case DW_CFA_restore_state
:
8515 if (! do_debug_frames_interp
)
8516 printf (" DW_CFA_restore_state\n");
8517 rs
= remembered_state
;
8520 remembered_state
= rs
->next
;
8521 fc
->cfa_offset
= rs
->cfa_offset
;
8522 fc
->cfa_reg
= rs
->cfa_reg
;
8524 fc
->cfa_exp
= rs
->cfa_exp
;
8525 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8527 warn (_("Invalid column number in saved frame state\n"));
8531 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8532 memcpy (fc
->col_offset
, rs
->col_offset
,
8533 rs
->ncols
* sizeof (* rs
->col_offset
));
8534 free (rs
->col_type
);
8535 free (rs
->col_offset
);
8538 else if (do_debug_frames_interp
)
8539 printf ("Mismatched DW_CFA_restore_state\n");
8542 case DW_CFA_def_cfa
:
8543 READ_ULEB (fc
->cfa_reg
, start
, end
);
8544 READ_ULEB (fc
->cfa_offset
, start
, end
);
8546 if (! do_debug_frames_interp
)
8547 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8548 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8551 case DW_CFA_def_cfa_register
:
8552 READ_ULEB (fc
->cfa_reg
, start
, end
);
8554 if (! do_debug_frames_interp
)
8555 printf (" DW_CFA_def_cfa_register: %s\n",
8556 regname (fc
->cfa_reg
, 0));
8559 case DW_CFA_def_cfa_offset
:
8560 READ_ULEB (fc
->cfa_offset
, start
, end
);
8561 if (! do_debug_frames_interp
)
8562 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8566 if (! do_debug_frames_interp
)
8567 printf (" DW_CFA_nop\n");
8570 case DW_CFA_def_cfa_expression
:
8571 READ_ULEB (ul
, start
, end
);
8572 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8574 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8577 if (! do_debug_frames_interp
)
8579 printf (" DW_CFA_def_cfa_expression (");
8580 decode_location_expression (start
, eh_addr_size
, 0, -1,
8588 case DW_CFA_expression
:
8589 READ_ULEB (reg
, start
, end
);
8590 READ_ULEB (ul
, start
, end
);
8591 if (reg
>= (unsigned int) fc
->ncols
)
8592 reg_prefix
= bad_reg
;
8593 /* PR 17512: file: 069-133014-0.006. */
8594 /* PR 17512: file: 98c02eb4. */
8596 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8598 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8601 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8603 printf (" DW_CFA_expression: %s%s (",
8604 reg_prefix
, regname (reg
, 0));
8605 decode_location_expression (start
, eh_addr_size
, 0, -1,
8609 if (*reg_prefix
== '\0')
8610 fc
->col_type
[reg
] = DW_CFA_expression
;
8614 case DW_CFA_val_expression
:
8615 READ_ULEB (reg
, start
, end
);
8616 READ_ULEB (ul
, start
, end
);
8617 if (reg
>= (unsigned int) fc
->ncols
)
8618 reg_prefix
= bad_reg
;
8620 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8622 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8625 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8627 printf (" DW_CFA_val_expression: %s%s (",
8628 reg_prefix
, regname (reg
, 0));
8629 decode_location_expression (start
, eh_addr_size
, 0, -1,
8633 if (*reg_prefix
== '\0')
8634 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8638 case DW_CFA_offset_extended_sf
:
8639 READ_ULEB (reg
, start
, end
);
8640 READ_SLEB (l
, start
, end
);
8641 if (frame_need_space (fc
, reg
) < 0)
8642 reg_prefix
= bad_reg
;
8643 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8644 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8645 reg_prefix
, regname (reg
, 0),
8646 (long)(l
* fc
->data_factor
));
8647 if (*reg_prefix
== '\0')
8649 fc
->col_type
[reg
] = DW_CFA_offset
;
8650 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8654 case DW_CFA_val_offset_sf
:
8655 READ_ULEB (reg
, start
, end
);
8656 READ_SLEB (l
, start
, end
);
8657 if (frame_need_space (fc
, reg
) < 0)
8658 reg_prefix
= bad_reg
;
8659 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8660 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8661 reg_prefix
, regname (reg
, 0),
8662 (long)(l
* fc
->data_factor
));
8663 if (*reg_prefix
== '\0')
8665 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8666 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8670 case DW_CFA_def_cfa_sf
:
8671 READ_ULEB (fc
->cfa_reg
, start
, end
);
8672 READ_ULEB (fc
->cfa_offset
, start
, end
);
8673 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8675 if (! do_debug_frames_interp
)
8676 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8677 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8680 case DW_CFA_def_cfa_offset_sf
:
8681 READ_ULEB (fc
->cfa_offset
, start
, end
);
8682 fc
->cfa_offset
*= fc
->data_factor
;
8683 if (! do_debug_frames_interp
)
8684 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8687 case DW_CFA_MIPS_advance_loc8
:
8688 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8689 if (do_debug_frames_interp
)
8690 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8692 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8693 (unsigned long) (ofs
* fc
->code_factor
),
8694 dwarf_vmatoa_1 (NULL
,
8695 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8697 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8700 case DW_CFA_GNU_window_save
:
8701 if (! do_debug_frames_interp
)
8702 printf (" DW_CFA_GNU_window_save\n");
8705 case DW_CFA_GNU_args_size
:
8706 READ_ULEB (ul
, start
, end
);
8707 if (! do_debug_frames_interp
)
8708 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8711 case DW_CFA_GNU_negative_offset_extended
:
8712 READ_ULEB (reg
, start
, end
);
8713 READ_SLEB (l
, start
, end
);
8715 if (frame_need_space (fc
, reg
) < 0)
8716 reg_prefix
= bad_reg
;
8717 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8718 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8719 reg_prefix
, regname (reg
, 0),
8720 (long)(l
* fc
->data_factor
));
8721 if (*reg_prefix
== '\0')
8723 fc
->col_type
[reg
] = DW_CFA_offset
;
8724 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8729 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8730 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8732 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8737 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8738 if (do_debug_frames_interp
&& ! all_nops
)
8739 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8741 if (fde_fc
.col_type
!= NULL
)
8743 free (fde_fc
.col_type
);
8744 fde_fc
.col_type
= NULL
;
8746 if (fde_fc
.col_offset
!= NULL
)
8748 free (fde_fc
.col_offset
);
8749 fde_fc
.col_offset
= NULL
;
8753 eh_addr_size
= saved_eh_addr_size
;
8758 while (remembered_state
!= NULL
)
8760 rs
= remembered_state
;
8761 remembered_state
= rs
->next
;
8762 free (rs
->col_type
);
8763 free (rs
->col_offset
);
8764 rs
->next
= NULL
; /* Paranoia. */
8768 while (chunks
!= NULL
)
8772 free (rs
->col_type
);
8773 free (rs
->col_offset
);
8774 rs
->next
= NULL
; /* Paranoia. */
8778 while (forward_refs
!= NULL
)
8781 forward_refs
= rs
->next
;
8782 free (rs
->col_type
);
8783 free (rs
->col_offset
);
8784 rs
->next
= NULL
; /* Paranoia. */
8794 display_debug_names (struct dwarf_section
*section
, void *file
)
8796 unsigned char *hdrptr
= section
->start
;
8797 dwarf_vma unit_length
;
8798 unsigned char *unit_start
;
8799 const unsigned char *const section_end
= section
->start
+ section
->size
;
8800 unsigned char *unit_end
;
8802 introduce (section
, FALSE
);
8804 load_debug_section_with_follow (str
, file
);
8806 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8808 unsigned int offset_size
;
8809 uint16_t dwarf_version
, padding
;
8810 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8811 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8812 uint32_t augmentation_string_size
;
8814 unsigned long sec_off
;
8815 bfd_boolean augmentation_printable
;
8816 const char *augmentation_string
;
8818 unit_start
= hdrptr
;
8820 /* Get and check the length of the block. */
8821 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8823 if (unit_length
== 0xffffffff)
8825 /* This section is 64-bit DWARF. */
8826 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8831 unit_end
= hdrptr
+ unit_length
;
8833 sec_off
= hdrptr
- section
->start
;
8834 if (sec_off
+ unit_length
< sec_off
8835 || sec_off
+ unit_length
> section
->size
)
8837 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8839 (unsigned long) (unit_start
- section
->start
),
8840 dwarf_vmatoa ("x", unit_length
));
8844 /* Get and check the version number. */
8845 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8846 printf (_("Version %ld\n"), (long) dwarf_version
);
8848 /* Prior versions did not exist, and future versions may not be
8849 backwards compatible. */
8850 if (dwarf_version
!= 5)
8852 warn (_("Only DWARF version 5 .debug_names "
8853 "is currently supported.\n"));
8857 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8859 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8862 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8863 if (comp_unit_count
== 0)
8864 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8866 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8867 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8868 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8869 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8870 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8872 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8873 if (augmentation_string_size
% 4 != 0)
8875 warn (_("Augmentation string length %u must be rounded up "
8876 "to a multiple of 4 in .debug_names.\n"),
8877 augmentation_string_size
);
8878 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8881 printf (_("Augmentation string:"));
8883 augmentation_printable
= TRUE
;
8884 augmentation_string
= (const char *) hdrptr
;
8886 for (i
= 0; i
< augmentation_string_size
; i
++)
8890 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8891 printf (" %02x", uc
);
8893 if (uc
!= 0 && !ISPRINT (uc
))
8894 augmentation_printable
= FALSE
;
8897 if (augmentation_printable
)
8901 i
< augmentation_string_size
&& augmentation_string
[i
];
8903 putchar (augmentation_string
[i
]);
8908 printf (_("CU table:\n"));
8909 for (i
= 0; i
< comp_unit_count
; i
++)
8913 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8914 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8918 printf (_("TU table:\n"));
8919 for (i
= 0; i
< local_type_unit_count
; i
++)
8923 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8924 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8928 printf (_("Foreign TU table:\n"));
8929 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8933 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8934 printf (_("[%3u] "), i
);
8935 print_dwarf_vma (signature
, 8);
8940 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8941 hdrptr
+= bucket_count
* sizeof (uint32_t);
8942 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8943 hdrptr
+= name_count
* sizeof (uint32_t);
8944 unsigned char *const name_table_string_offsets
= hdrptr
;
8945 hdrptr
+= name_count
* offset_size
;
8946 unsigned char *const name_table_entry_offsets
= hdrptr
;
8947 hdrptr
+= name_count
* offset_size
;
8948 unsigned char *const abbrev_table
= hdrptr
;
8949 hdrptr
+= abbrev_table_size
;
8950 const unsigned char *const abbrev_table_end
= hdrptr
;
8951 unsigned char *const entry_pool
= hdrptr
;
8952 if (hdrptr
> unit_end
)
8954 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8955 "for unit 0x%lx in the debug_names\n"),
8956 (long) (hdrptr
- section
->start
),
8957 (long) (unit_end
- section
->start
),
8958 (long) (unit_start
- section
->start
));
8962 size_t buckets_filled
= 0;
8964 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8966 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8971 printf (ngettext ("Used %zu of %lu bucket.\n",
8972 "Used %zu of %lu buckets.\n",
8974 buckets_filled
, (unsigned long) bucket_count
);
8976 uint32_t hash_prev
= 0;
8977 size_t hash_clash_count
= 0;
8978 size_t longest_clash
= 0;
8979 size_t this_length
= 0;
8981 for (hashi
= 0; hashi
< name_count
; hashi
++)
8983 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8987 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8991 longest_clash
= MAX (longest_clash
, this_length
);
8996 hash_prev
= hash_this
;
8998 printf (_("Out of %lu items there are %zu bucket clashes"
8999 " (longest of %zu entries).\n"),
9000 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9001 assert (name_count
== buckets_filled
+ hash_clash_count
);
9003 struct abbrev_lookup_entry
9005 dwarf_vma abbrev_tag
;
9006 unsigned char *abbrev_lookup_ptr
;
9008 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9009 size_t abbrev_lookup_used
= 0;
9010 size_t abbrev_lookup_allocated
= 0;
9012 unsigned char *abbrevptr
= abbrev_table
;
9015 dwarf_vma abbrev_tag
;
9017 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9018 if (abbrev_tag
== 0)
9020 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9022 abbrev_lookup_allocated
= MAX (0x100,
9023 abbrev_lookup_allocated
* 2);
9024 abbrev_lookup
= xrealloc (abbrev_lookup
,
9025 (abbrev_lookup_allocated
9026 * sizeof (*abbrev_lookup
)));
9028 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9029 struct abbrev_lookup_entry
*entry
;
9030 for (entry
= abbrev_lookup
;
9031 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9033 if (entry
->abbrev_tag
== abbrev_tag
)
9035 warn (_("Duplicate abbreviation tag %lu "
9036 "in unit 0x%lx in the debug_names\n"),
9037 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9040 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9041 entry
->abbrev_tag
= abbrev_tag
;
9042 entry
->abbrev_lookup_ptr
= abbrevptr
;
9044 /* Skip DWARF tag. */
9045 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9048 dwarf_vma xindex
, form
;
9050 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9051 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9052 if (xindex
== 0 && form
== 0)
9057 printf (_("\nSymbol table:\n"));
9059 for (namei
= 0; namei
< name_count
; ++namei
)
9061 uint64_t string_offset
, entry_offset
;
9063 SAFE_BYTE_GET (string_offset
,
9064 name_table_string_offsets
+ namei
* offset_size
,
9065 offset_size
, unit_end
);
9066 SAFE_BYTE_GET (entry_offset
,
9067 name_table_entry_offsets
+ namei
* offset_size
,
9068 offset_size
, unit_end
);
9070 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9071 fetch_indirect_string (string_offset
));
9073 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9075 // We need to scan first whether there is a single or multiple
9076 // entries. TAGNO is -2 for the first entry, it is -1 for the
9077 // initial tag read of the second entry, then it becomes 0 for the
9078 // first entry for real printing etc.
9080 /* Initialize it due to a false compiler warning. */
9081 dwarf_vma second_abbrev_tag
= -1;
9084 dwarf_vma abbrev_tag
;
9085 dwarf_vma dwarf_tag
;
9086 const struct abbrev_lookup_entry
*entry
;
9088 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9091 second_abbrev_tag
= abbrev_tag
;
9093 entryptr
= entry_pool
+ entry_offset
;
9096 if (abbrev_tag
== 0)
9100 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9101 (unsigned long) abbrev_tag
);
9103 for (entry
= abbrev_lookup
;
9104 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9106 if (entry
->abbrev_tag
== abbrev_tag
)
9108 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9110 warn (_("Undefined abbreviation tag %lu "
9111 "in unit 0x%lx in the debug_names\n"),
9113 (long) (unit_start
- section
->start
));
9116 abbrevptr
= entry
->abbrev_lookup_ptr
;
9117 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9119 printf (" %s", get_TAG_name (dwarf_tag
));
9122 dwarf_vma xindex
, form
;
9124 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9125 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9126 if (xindex
== 0 && form
== 0)
9130 printf (" %s", get_IDX_name (xindex
));
9131 entryptr
= read_and_display_attr_value (0, form
, 0,
9132 unit_start
, entryptr
, unit_end
,
9134 dwarf_version
, NULL
,
9141 printf (_(" <no entries>"));
9145 free (abbrev_lookup
);
9152 display_debug_links (struct dwarf_section
* section
,
9153 void * file ATTRIBUTE_UNUSED
)
9155 const unsigned char * filename
;
9156 unsigned int filelen
;
9158 introduce (section
, FALSE
);
9160 /* The .gnu_debuglink section is formatted as:
9161 (c-string) Filename.
9162 (padding) If needed to reach a 4 byte boundary.
9163 (uint32_t) CRC32 value.
9165 The .gun_debugaltlink section is formatted as:
9166 (c-string) Filename.
9167 (binary) Build-ID. */
9169 filename
= section
->start
;
9170 filelen
= strnlen ((const char *) filename
, section
->size
);
9171 if (filelen
== section
->size
)
9173 warn (_("The debuglink filename is corrupt/missing\n"));
9177 printf (_(" Separate debug info file: %s\n"), filename
);
9179 if (const_strneq (section
->name
, ".gnu_debuglink"))
9182 unsigned int crc_offset
;
9184 crc_offset
= filelen
+ 1;
9185 crc_offset
= (crc_offset
+ 3) & ~3;
9186 if (crc_offset
+ 4 > section
->size
)
9188 warn (_("CRC offset missing/truncated\n"));
9192 crc32
= byte_get (filename
+ crc_offset
, 4);
9194 printf (_(" CRC value: %#x\n"), crc32
);
9196 if (crc_offset
+ 4 < section
->size
)
9198 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9199 (long)(section
->size
- (crc_offset
+ 4)));
9203 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9205 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9206 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9207 bfd_size_type printed
;
9209 /* FIXME: Should we support smaller build-id notes ? */
9210 if (build_id_len
< 0x14)
9212 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9216 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9217 display_data (printed
, build_id
, build_id_len
);
9226 display_gdb_index (struct dwarf_section
*section
,
9227 void *file ATTRIBUTE_UNUSED
)
9229 unsigned char *start
= section
->start
;
9231 uint32_t cu_list_offset
, tu_list_offset
;
9232 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9233 unsigned int cu_list_elements
, tu_list_elements
;
9234 unsigned int address_table_size
, symbol_table_slots
;
9235 unsigned char *cu_list
, *tu_list
;
9236 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9239 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9241 introduce (section
, FALSE
);
9243 if (section
->size
< 6 * sizeof (uint32_t))
9245 warn (_("Truncated header in the %s section.\n"), section
->name
);
9249 version
= byte_get_little_endian (start
, 4);
9250 printf (_("Version %ld\n"), (long) version
);
9252 /* Prior versions are obsolete, and future versions may not be
9253 backwards compatible. */
9254 if (version
< 3 || version
> 8)
9256 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9260 warn (_("The address table data in version 3 may be wrong.\n"));
9262 warn (_("Version 4 does not support case insensitive lookups.\n"));
9264 warn (_("Version 5 does not include inlined functions.\n"));
9266 warn (_("Version 6 does not include symbol attributes.\n"));
9267 /* Version 7 indices generated by Gold have bad type unit references,
9268 PR binutils/15021. But we don't know if the index was generated by
9269 Gold or not, so to avoid worrying users with gdb-generated indices
9270 we say nothing for version 7 here. */
9272 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9273 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9274 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9275 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9276 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9278 if (cu_list_offset
> section
->size
9279 || tu_list_offset
> section
->size
9280 || address_table_offset
> section
->size
9281 || symbol_table_offset
> section
->size
9282 || constant_pool_offset
> section
->size
)
9284 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9288 /* PR 17531: file: 418d0a8a. */
9289 if (tu_list_offset
< cu_list_offset
)
9291 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9292 tu_list_offset
, cu_list_offset
);
9296 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9298 if (address_table_offset
< tu_list_offset
)
9300 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9301 address_table_offset
, tu_list_offset
);
9305 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9307 /* PR 17531: file: 18a47d3d. */
9308 if (symbol_table_offset
< address_table_offset
)
9310 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9311 symbol_table_offset
, address_table_offset
);
9315 address_table_size
= symbol_table_offset
- address_table_offset
;
9317 if (constant_pool_offset
< symbol_table_offset
)
9319 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9320 constant_pool_offset
, symbol_table_offset
);
9324 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9326 cu_list
= start
+ cu_list_offset
;
9327 tu_list
= start
+ tu_list_offset
;
9328 address_table
= start
+ address_table_offset
;
9329 symbol_table
= start
+ symbol_table_offset
;
9330 constant_pool
= start
+ constant_pool_offset
;
9332 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9334 warn (_("Address table extends beyond end of section.\n"));
9338 printf (_("\nCU table:\n"));
9339 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9341 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9342 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9344 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9345 (unsigned long) cu_offset
,
9346 (unsigned long) (cu_offset
+ cu_length
- 1));
9349 printf (_("\nTU table:\n"));
9350 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9352 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9353 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9354 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9356 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9357 (unsigned long) tu_offset
,
9358 (unsigned long) type_offset
);
9359 print_dwarf_vma (signature
, 8);
9363 printf (_("\nAddress table:\n"));
9364 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9367 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9368 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9369 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9371 print_dwarf_vma (low
, 8);
9372 print_dwarf_vma (high
, 8);
9373 printf (_("%lu\n"), (unsigned long) cu_index
);
9376 printf (_("\nSymbol table:\n"));
9377 for (i
= 0; i
< symbol_table_slots
; ++i
)
9379 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9380 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9381 uint32_t num_cus
, cu
;
9383 if (name_offset
!= 0
9384 || cu_vector_offset
!= 0)
9387 unsigned char * adr
;
9389 adr
= constant_pool
+ name_offset
;
9390 /* PR 17531: file: 5b7b07ad. */
9391 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9393 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9394 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9398 printf ("[%3u] %.*s:", i
,
9399 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9400 constant_pool
+ name_offset
);
9402 adr
= constant_pool
+ cu_vector_offset
;
9403 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9405 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9406 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9407 cu_vector_offset
, i
);
9411 num_cus
= byte_get_little_endian (adr
, 4);
9413 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9414 if (num_cus
* 4 < num_cus
9415 || adr
>= section
->start
+ section
->size
9416 || adr
< constant_pool
)
9418 printf ("<invalid number of CUs: %d>\n", num_cus
);
9419 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9427 for (j
= 0; j
< num_cus
; ++j
)
9430 gdb_index_symbol_kind kind
;
9432 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9433 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9434 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9435 cu
= GDB_INDEX_CU_VALUE (cu
);
9436 /* Convert to TU number if it's for a type unit. */
9437 if (cu
>= cu_list_elements
/ 2)
9438 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9439 (unsigned long) (cu
- cu_list_elements
/ 2));
9441 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9443 printf (" [%s, %s]",
9444 is_static
? _("static") : _("global"),
9445 get_gdb_index_symbol_kind_name (kind
));
9457 /* Pre-allocate enough space for the CU/TU sets needed. */
9460 prealloc_cu_tu_list (unsigned int nshndx
)
9462 if (shndx_pool
== NULL
)
9464 shndx_pool_size
= nshndx
;
9465 shndx_pool_used
= 0;
9466 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9467 sizeof (unsigned int));
9471 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9472 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9473 sizeof (unsigned int));
9478 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9480 if (shndx_pool_used
>= shndx_pool_size
)
9482 error (_("Internal error: out of space in the shndx pool.\n"));
9485 shndx_pool
[shndx_pool_used
++] = shndx
;
9489 end_cu_tu_entry (void)
9491 if (shndx_pool_used
>= shndx_pool_size
)
9493 error (_("Internal error: out of space in the shndx pool.\n"));
9496 shndx_pool
[shndx_pool_used
++] = 0;
9499 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9502 get_DW_SECT_short_name (unsigned int dw_sect
)
9504 static char buf
[16];
9512 case DW_SECT_ABBREV
:
9518 case DW_SECT_STR_OFFSETS
:
9520 case DW_SECT_MACINFO
:
9528 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9532 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9533 These sections are extensions for Fission.
9534 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9537 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9539 unsigned char *phdr
= section
->start
;
9540 unsigned char *limit
= phdr
+ section
->size
;
9541 unsigned char *phash
;
9542 unsigned char *pindex
;
9543 unsigned char *ppool
;
9544 unsigned int version
;
9545 unsigned int ncols
= 0;
9547 unsigned int nslots
;
9550 dwarf_vma signature_high
;
9551 dwarf_vma signature_low
;
9554 /* PR 17512: file: 002-168123-0.004. */
9557 warn (_("Section %s is empty\n"), section
->name
);
9560 /* PR 17512: file: 002-376-0.004. */
9561 if (section
->size
< 24)
9563 warn (_("Section %s is too small to contain a CU/TU header\n"),
9568 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9570 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9571 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9572 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9575 pindex
= phash
+ (size_t) nslots
* 8;
9576 ppool
= pindex
+ (size_t) nslots
* 4;
9580 introduce (section
, FALSE
);
9582 printf (_(" Version: %u\n"), version
);
9584 printf (_(" Number of columns: %u\n"), ncols
);
9585 printf (_(" Number of used entries: %u\n"), nused
);
9586 printf (_(" Number of slots: %u\n\n"), nslots
);
9589 /* PR 17531: file: 45d69832. */
9590 if ((size_t) nslots
* 8 / 8 != nslots
9591 || phash
< phdr
|| phash
> limit
9592 || pindex
< phash
|| pindex
> limit
9593 || ppool
< pindex
|| ppool
> limit
)
9595 warn (ngettext ("Section %s is too small for %u slot\n",
9596 "Section %s is too small for %u slots\n",
9598 section
->name
, nslots
);
9605 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9606 for (i
= 0; i
< nslots
; i
++)
9608 unsigned char *shndx_list
;
9611 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9612 if (signature_high
!= 0 || signature_low
!= 0)
9614 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9615 shndx_list
= ppool
+ j
* 4;
9616 /* PR 17531: file: 705e010d. */
9617 if (shndx_list
< ppool
)
9619 warn (_("Section index pool located before start of section\n"));
9624 printf (_(" [%3d] Signature: 0x%s Sections: "),
9625 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9626 buf
, sizeof (buf
)));
9629 if (shndx_list
>= limit
)
9631 warn (_("Section %s too small for shndx pool\n"),
9635 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9639 printf (" %d", shndx
);
9641 add_shndx_to_cu_tu_entry (shndx
);
9653 else if (version
== 2)
9656 unsigned int dw_sect
;
9657 unsigned char *ph
= phash
;
9658 unsigned char *pi
= pindex
;
9659 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9660 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9661 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9662 bfd_boolean is_tu_index
;
9663 struct cu_tu_set
*this_set
= NULL
;
9665 unsigned char *prow
;
9667 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9669 /* PR 17531: file: 0dd159bf.
9670 Check for integer overflow (can occur when size_t is 32-bit)
9671 with overlarge ncols or nused values. */
9673 && ((size_t) ncols
* 4 / 4 != ncols
9674 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9675 || poffsets
< ppool
|| poffsets
> limit
9676 || psizes
< poffsets
|| psizes
> limit
9677 || pend
< psizes
|| pend
> limit
))
9679 warn (_("Section %s too small for offset and size tables\n"),
9686 printf (_(" Offset table\n"));
9687 printf (" slot %-16s ",
9688 is_tu_index
? _("signature") : _("dwo_id"));
9695 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9701 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9708 for (j
= 0; j
< ncols
; j
++)
9710 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9711 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9716 for (i
= 0; i
< nslots
; i
++)
9718 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9720 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9723 /* PR 17531: file: a05f6ab3. */
9726 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9733 size_t num_copy
= sizeof (uint64_t);
9735 /* PR 23064: Beware of buffer overflow. */
9736 if (ph
+ num_copy
< limit
)
9737 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9740 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9745 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9746 /* PR 17531: file: b8ce60a8. */
9747 if (prow
< poffsets
|| prow
> limit
)
9749 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9755 printf (_(" [%3d] 0x%s"),
9756 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9757 buf
, sizeof (buf
)));
9758 for (j
= 0; j
< ncols
; j
++)
9760 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9762 printf (" %8d", val
);
9765 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9767 /* PR 17531: file: 10796eb3. */
9768 if (dw_sect
>= DW_SECT_MAX
)
9769 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9771 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9787 printf (_(" Size table\n"));
9788 printf (" slot %-16s ",
9789 is_tu_index
? _("signature") : _("dwo_id"));
9792 for (j
= 0; j
< ncols
; j
++)
9794 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9796 printf (" %8s", get_DW_SECT_short_name (val
));
9802 for (i
= 0; i
< nslots
; i
++)
9804 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9806 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9809 prow
= psizes
+ (row
- 1) * ncols
* 4;
9812 printf (_(" [%3d] 0x%s"),
9813 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9814 buf
, sizeof (buf
)));
9816 for (j
= 0; j
< ncols
; j
++)
9818 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9820 printf (" %8d", val
);
9823 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9824 if (dw_sect
>= DW_SECT_MAX
)
9825 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9827 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9839 else if (do_display
)
9840 printf (_(" Unsupported version (%d)\n"), version
);
9848 /* Load the CU and TU indexes if present. This will build a list of
9849 section sets that we can use to associate a .debug_info.dwo section
9850 with its associated .debug_abbrev.dwo section in a .dwp file. */
9853 load_cu_tu_indexes (void *file
)
9855 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
9857 /* If we have already loaded (or tried to load) the CU and TU indexes
9858 then do not bother to repeat the task. */
9859 if (cu_tu_indexes_read
== -1)
9861 cu_tu_indexes_read
= TRUE
;
9863 if (load_debug_section_with_follow (dwp_cu_index
, file
))
9864 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
9865 cu_tu_indexes_read
= FALSE
;
9867 if (load_debug_section_with_follow (dwp_tu_index
, file
))
9868 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
9869 cu_tu_indexes_read
= FALSE
;
9872 return (bfd_boolean
) cu_tu_indexes_read
;
9875 /* Find the set of sections that includes section SHNDX. */
9878 find_cu_tu_set (void *file
, unsigned int shndx
)
9882 if (! load_cu_tu_indexes (file
))
9885 /* Find SHNDX in the shndx pool. */
9886 for (i
= 0; i
< shndx_pool_used
; i
++)
9887 if (shndx_pool
[i
] == shndx
)
9890 if (i
>= shndx_pool_used
)
9893 /* Now backup to find the first entry in the set. */
9894 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9897 return shndx_pool
+ i
;
9900 /* Display a .debug_cu_index or .debug_tu_index section. */
9903 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9905 return process_cu_tu_index (section
, 1);
9909 display_debug_not_supported (struct dwarf_section
*section
,
9910 void *file ATTRIBUTE_UNUSED
)
9912 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9918 /* Like malloc, but takes two parameters like calloc.
9919 Verifies that the first parameter is not too large.
9920 Note: does *not* initialise the allocated memory to zero. */
9923 cmalloc (size_t nmemb
, size_t size
)
9925 /* Check for overflow. */
9926 if (nmemb
>= ~(size_t) 0 / size
)
9929 return xmalloc (nmemb
* size
);
9932 /* Like xmalloc, but takes two parameters like calloc.
9933 Verifies that the first parameter is not too large.
9934 Note: does *not* initialise the allocated memory to zero. */
9937 xcmalloc (size_t nmemb
, size_t size
)
9939 /* Check for overflow. */
9940 if (nmemb
>= ~(size_t) 0 / size
)
9943 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9948 return xmalloc (nmemb
* size
);
9951 /* Like xrealloc, but takes three parameters.
9952 Verifies that the second parameter is not too large.
9953 Note: does *not* initialise any new memory to zero. */
9956 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9958 /* Check for overflow. */
9959 if (nmemb
>= ~(size_t) 0 / size
)
9961 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9966 return xrealloc (ptr
, nmemb
* size
);
9969 /* Like xcalloc, but verifies that the first parameter is not too large. */
9972 xcalloc2 (size_t nmemb
, size_t size
)
9974 /* Check for overflow. */
9975 if (nmemb
>= ~(size_t) 0 / size
)
9977 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9982 return xcalloc (nmemb
, size
);
9985 static unsigned long
9986 calc_gnu_debuglink_crc32 (unsigned long crc
,
9987 const unsigned char * buf
,
9990 static const unsigned long crc32_table
[256] =
9992 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
9993 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
9994 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
9995 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
9996 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
9997 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
9998 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
9999 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10000 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10001 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10002 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10003 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10004 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10005 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10006 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10007 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10008 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10009 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10010 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10011 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10012 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10013 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10014 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10015 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10016 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10017 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10018 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10019 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10020 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10021 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10022 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10023 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10024 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10025 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10026 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10027 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10028 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10029 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10030 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10031 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10032 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10033 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10034 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10035 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10036 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10037 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10038 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10039 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10040 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10041 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10042 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10045 const unsigned char *end
;
10047 crc
= ~crc
& 0xffffffff;
10048 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10049 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10050 return ~crc
& 0xffffffff;
10053 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10054 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10057 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10059 static unsigned char buffer
[8 * 1024];
10061 bfd_size_type count
;
10062 unsigned long crc
= 0;
10065 sep_data
= open_debug_file (pathname
);
10066 if (sep_data
== NULL
)
10069 /* Yes - we are opening the file twice... */
10070 f
= fopen (pathname
, "rb");
10073 /* Paranoia: This should never happen. */
10074 close_debug_file (sep_data
);
10075 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10079 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10080 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10084 if (crc
!= * (unsigned long *) crc_pointer
)
10086 close_debug_file (sep_data
);
10087 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10095 static const char *
10096 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10099 unsigned int crc_offset
;
10100 unsigned long * crc32
= (unsigned long *) data
;
10102 /* The name is first.
10103 The CRC value is stored after the filename, aligned up to 4 bytes. */
10104 name
= (const char *) section
->start
;
10107 crc_offset
= strnlen (name
, section
->size
) + 1;
10108 crc_offset
= (crc_offset
+ 3) & ~3;
10109 if (crc_offset
+ 4 > section
->size
)
10112 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10117 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10119 void * sep_data
= open_debug_file (filename
);
10121 if (sep_data
== NULL
)
10124 /* FIXME: We should now extract the build-id in the separate file
10130 typedef struct build_id_data
10133 const unsigned char * data
;
10136 static const char *
10137 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10140 bfd_size_type namelen
;
10141 bfd_size_type id_len
;
10142 Build_id_data
* build_id_data
;
10144 /* The name is first.
10145 The build-id follows immediately, with no padding, up to the section's end. */
10147 name
= (const char *) section
->start
;
10148 namelen
= strnlen (name
, section
->size
) + 1;
10149 if (namelen
>= section
->size
)
10152 id_len
= section
->size
- namelen
;
10156 build_id_data
= calloc (1, sizeof * build_id_data
);
10157 if (build_id_data
== NULL
)
10160 build_id_data
->len
= id_len
;
10161 build_id_data
->data
= section
->start
+ namelen
;
10163 * (Build_id_data
**) data
= build_id_data
;
10169 add_separate_debug_file (const char * filename
, void * handle
)
10171 separate_info
* i
= xmalloc (sizeof * i
);
10173 i
->filename
= filename
;
10174 i
->handle
= handle
;
10175 i
->next
= first_separate_info
;
10176 first_separate_info
= i
;
10179 #if HAVE_LIBDEBUGINFOD
10180 /* Query debuginfod servers for the target debuglink or debugaltlink
10181 file. If successful, store the path of the file in filename and
10182 return TRUE, otherwise return FALSE. */
10185 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10189 size_t build_id_len
;
10190 unsigned char * build_id
;
10192 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10194 /* Get the build-id of file. */
10195 build_id
= get_build_id (file
);
10198 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10200 /* Get the build-id of the debugaltlink file. */
10201 unsigned int filelen
;
10203 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10204 if (filelen
== section
->size
)
10205 /* Corrupt debugaltlink. */
10208 build_id
= section
->start
+ filelen
+ 1;
10209 build_id_len
= section
->size
- (filelen
+ 1);
10211 if (build_id_len
== 0)
10220 debuginfod_client
* client
;
10222 client
= debuginfod_begin ();
10223 if (client
== NULL
)
10226 /* Query debuginfod servers for the target file. If found its path
10227 will be stored in filename. */
10228 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10229 debuginfod_end (client
);
10231 /* Only free build_id if we allocated space for a hex string
10232 in get_build_id (). */
10233 if (build_id_len
== 0)
10238 /* File successfully retrieved. Close fd since we want to
10239 use open_debug_file () on filename instead. */
10250 load_separate_debug_info (const char * main_filename
,
10251 struct dwarf_section
* xlink
,
10252 parse_func_type parse_func
,
10253 check_func_type check_func
,
10255 void * file ATTRIBUTE_UNUSED
)
10257 const char * separate_filename
;
10258 char * debug_filename
;
10260 size_t canon_dirlen
;
10263 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10265 warn (_("Corrupt debuglink section: %s\n"),
10266 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10270 /* Attempt to locate the separate file.
10271 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10273 canon_dir
= lrealpath (main_filename
);
10275 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10276 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10278 canon_dir
[canon_dirlen
] = '\0';
10281 #define DEBUGDIR "/lib/debug"
10283 #ifndef EXTRA_DEBUG_ROOT1
10284 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10286 #ifndef EXTRA_DEBUG_ROOT2
10287 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10290 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10292 + strlen (".debug/")
10293 #ifdef EXTRA_DEBUG_ROOT1
10294 + strlen (EXTRA_DEBUG_ROOT1
)
10296 #ifdef EXTRA_DEBUG_ROOT2
10297 + strlen (EXTRA_DEBUG_ROOT2
)
10299 + strlen (separate_filename
)
10301 if (debug_filename
== NULL
)
10303 warn (_("Out of memory"));
10308 /* First try in the current directory. */
10309 sprintf (debug_filename
, "%s", separate_filename
);
10310 if (check_func (debug_filename
, func_data
))
10313 /* Then try in a subdirectory called .debug. */
10314 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10315 if (check_func (debug_filename
, func_data
))
10318 /* Then try in the same directory as the original file. */
10319 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10320 if (check_func (debug_filename
, func_data
))
10323 /* And the .debug subdirectory of that directory. */
10324 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10325 if (check_func (debug_filename
, func_data
))
10328 #ifdef EXTRA_DEBUG_ROOT1
10329 /* Try the first extra debug file root. */
10330 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10331 if (check_func (debug_filename
, func_data
))
10334 /* Try the first extra debug file root. */
10335 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10336 if (check_func (debug_filename
, func_data
))
10340 #ifdef EXTRA_DEBUG_ROOT2
10341 /* Try the second extra debug file root. */
10342 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10343 if (check_func (debug_filename
, func_data
))
10347 /* Then try in the global debug_filename directory. */
10348 strcpy (debug_filename
, DEBUGDIR
);
10349 dirlen
= strlen (DEBUGDIR
) - 1;
10350 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10351 strcat (debug_filename
, "/");
10352 strcat (debug_filename
, (const char *) separate_filename
);
10354 if (check_func (debug_filename
, func_data
))
10357 #if HAVE_LIBDEBUGINFOD
10359 char * tmp_filename
;
10361 if (debuginfod_fetch_separate_debug_info (xlink
,
10365 /* File successfully downloaded from server, replace
10366 debug_filename with the file's path. */
10367 free (debug_filename
);
10368 debug_filename
= tmp_filename
;
10374 /* Failed to find the file. */
10375 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10376 warn (_("tried: %s\n"), debug_filename
);
10378 #ifdef EXTRA_DEBUG_ROOT2
10379 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10380 warn (_("tried: %s\n"), debug_filename
);
10383 #ifdef EXTRA_DEBUG_ROOT1
10384 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10385 warn (_("tried: %s\n"), debug_filename
);
10387 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10388 warn (_("tried: %s\n"), debug_filename
);
10391 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10392 warn (_("tried: %s\n"), debug_filename
);
10394 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10395 warn (_("tried: %s\n"), debug_filename
);
10397 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10398 warn (_("tried: %s\n"), debug_filename
);
10400 sprintf (debug_filename
, "%s", separate_filename
);
10401 warn (_("tried: %s\n"), debug_filename
);
10403 #if HAVE_LIBDEBUGINFOD
10405 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
10409 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
10414 free (debug_filename
);
10420 void * debug_handle
;
10422 /* Now open the file.... */
10423 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10425 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10426 free (debug_filename
);
10430 /* FIXME: We do not check to see if there are any other separate debug info
10431 files that would also match. */
10433 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10434 add_separate_debug_file (debug_filename
, debug_handle
);
10436 /* Do not free debug_filename - it might be referenced inside
10437 the structure returned by open_debug_file(). */
10438 return debug_handle
;
10441 /* Attempt to load a separate dwarf object file. */
10444 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10446 char * separate_filename
;
10447 void * separate_handle
;
10449 /* FIXME: Skip adding / if dwo_dir ends in /. */
10450 separate_filename
= concat (dir
, "/", name
, NULL
);
10451 if (separate_filename
== NULL
)
10453 warn (_("Out of memory allocating dwo filename\n"));
10457 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10459 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10460 free (separate_filename
);
10464 /* FIXME: We should check the dwo_id. */
10466 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10467 add_separate_debug_file (separate_filename
, separate_handle
);
10468 /* Note - separate_filename will be freed in free_debug_memory(). */
10469 return separate_handle
;
10472 /* Load the separate debug info file(s) attached to FILE, if any exist.
10473 Returns TRUE if any were found, FALSE otherwise.
10474 If TRUE is returned then the linked list starting at first_separate_info
10475 will be populated with open file handles. */
10478 load_separate_debug_files (void * file
, const char * filename
)
10480 /* Skip this operation if we are not interested in debug links. */
10481 if (! do_follow_links
&& ! do_debug_links
)
10484 /* See if there are any dwo links. */
10485 if (load_debug_section (str
, file
)
10486 && load_debug_section (abbrev
, file
)
10487 && load_debug_section (info
, file
))
10491 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10493 bfd_boolean introduced
= FALSE
;
10495 const char * dir
= NULL
;
10496 const char * id
= NULL
;
10498 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10500 switch (dwinfo
->type
)
10503 if (do_debug_links
)
10507 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10508 debug_displays
[info
].section
.uncompressed_name
);
10512 printf (_(" Name: %s\n"), dwinfo
->value
);
10513 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10515 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10517 printf (_(" ID: <unknown>\n"));
10521 if (do_follow_links
)
10522 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10526 dir
= dwinfo
->value
;
10530 id
= dwinfo
->value
;
10534 error (_("Unexpected DWO INFO type"));
10541 if (! do_follow_links
)
10542 /* The other debug links will be displayed by display_debug_links()
10543 so we do not need to do any further processing here. */
10546 /* FIXME: We do not check for the presence of both link sections in the same file. */
10547 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10548 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10549 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10551 if (load_debug_section (gnu_debugaltlink
, file
))
10553 Build_id_data
* build_id_data
;
10555 load_separate_debug_info (filename
,
10556 & debug_displays
[gnu_debugaltlink
].section
,
10557 parse_gnu_debugaltlink
,
10558 check_gnu_debugaltlink
,
10563 if (load_debug_section (gnu_debuglink
, file
))
10565 unsigned long crc32
;
10567 load_separate_debug_info (filename
,
10568 & debug_displays
[gnu_debuglink
].section
,
10569 parse_gnu_debuglink
,
10570 check_gnu_debuglink
,
10575 if (first_separate_info
!= NULL
)
10578 do_follow_links
= 0;
10583 free_debug_memory (void)
10589 for (i
= 0; i
< max
; i
++)
10590 free_debug_section ((enum dwarf_section_display_enum
) i
);
10592 if (debug_information
!= NULL
)
10594 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10596 for (i
= 0; i
< num_debug_info_entries
; i
++)
10598 if (!debug_information
[i
].max_loc_offsets
)
10600 free (debug_information
[i
].loc_offsets
);
10601 free (debug_information
[i
].have_frame_base
);
10603 if (!debug_information
[i
].max_range_lists
)
10604 free (debug_information
[i
].range_lists
);
10607 free (debug_information
);
10608 debug_information
= NULL
;
10609 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10613 separate_info
* next
;
10615 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10617 close_debug_file (d
->handle
);
10618 free ((void *) d
->filename
);
10622 first_separate_info
= NULL
;
10628 dwarf_select_sections_by_names (const char *names
)
10632 const char * option
;
10636 debug_dump_long_opts
;
10638 static const debug_dump_long_opts opts_table
[] =
10640 /* Please keep this table alpha- sorted. */
10641 { "Ranges", & do_debug_ranges
, 1 },
10642 { "abbrev", & do_debug_abbrevs
, 1 },
10643 { "addr", & do_debug_addr
, 1 },
10644 { "aranges", & do_debug_aranges
, 1 },
10645 { "cu_index", & do_debug_cu_index
, 1 },
10646 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10647 { "follow-links", & do_follow_links
, 1 },
10648 { "frames", & do_debug_frames
, 1 },
10649 { "frames-interp", & do_debug_frames_interp
, 1 },
10650 /* The special .gdb_index section. */
10651 { "gdb_index", & do_gdb_index
, 1 },
10652 { "info", & do_debug_info
, 1 },
10653 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10654 { "links", & do_debug_links
, 1 },
10655 { "loc", & do_debug_loc
, 1 },
10656 { "macro", & do_debug_macinfo
, 1 },
10657 { "pubnames", & do_debug_pubnames
, 1 },
10658 { "pubtypes", & do_debug_pubtypes
, 1 },
10659 /* This entry is for compatibility
10660 with earlier versions of readelf. */
10661 { "ranges", & do_debug_aranges
, 1 },
10662 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10663 { "str", & do_debug_str
, 1 },
10664 /* These trace_* sections are used by Itanium VMS. */
10665 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10666 { "trace_aranges", & do_trace_aranges
, 1 },
10667 { "trace_info", & do_trace_info
, 1 },
10676 const debug_dump_long_opts
* entry
;
10678 for (entry
= opts_table
; entry
->option
; entry
++)
10680 size_t len
= strlen (entry
->option
);
10682 if (strncmp (p
, entry
->option
, len
) == 0
10683 && (p
[len
] == ',' || p
[len
] == '\0'))
10685 * entry
->variable
|= entry
->val
;
10687 /* The --debug-dump=frames-interp option also
10688 enables the --debug-dump=frames option. */
10689 if (do_debug_frames_interp
)
10690 do_debug_frames
= 1;
10697 if (entry
->option
== NULL
)
10699 warn (_("Unrecognized debug option '%s'\n"), p
);
10700 p
= strchr (p
, ',');
10711 dwarf_select_sections_by_letters (const char *letters
)
10713 unsigned int lindex
= 0;
10715 while (letters
[lindex
])
10716 switch (letters
[lindex
++])
10718 case 'A': do_debug_addr
= 1; break;
10719 case 'a': do_debug_abbrevs
= 1; break;
10720 case 'c': do_debug_cu_index
= 1; break;
10721 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10722 case 'f': do_debug_frames
= 1; break;
10723 case 'g': do_gdb_index
= 1; break;
10724 case 'i': do_debug_info
= 1; break;
10725 case 'K': do_follow_links
= 1; break;
10726 case 'k': do_debug_links
= 1; break;
10727 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10728 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10729 case 'm': do_debug_macinfo
= 1; break;
10730 case 'o': do_debug_loc
= 1; break;
10731 case 'p': do_debug_pubnames
= 1; break;
10732 case 'R': do_debug_ranges
= 1; break;
10733 case 'r': do_debug_aranges
= 1; break;
10734 case 's': do_debug_str
= 1; break;
10735 case 'T': do_trace_aranges
= 1; break;
10736 case 't': do_debug_pubtypes
= 1; break;
10737 case 'U': do_trace_info
= 1; break;
10738 case 'u': do_trace_abbrevs
= 1; break;
10741 warn (_("Unrecognized debug option '%s'\n"), letters
);
10747 dwarf_select_sections_all (void)
10750 do_debug_abbrevs
= 1;
10751 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10752 do_debug_pubnames
= 1;
10753 do_debug_pubtypes
= 1;
10754 do_debug_aranges
= 1;
10755 do_debug_ranges
= 1;
10756 do_debug_frames
= 1;
10757 do_debug_macinfo
= 1;
10762 do_trace_abbrevs
= 1;
10763 do_trace_aranges
= 1;
10765 do_debug_cu_index
= 1;
10766 do_follow_links
= 1;
10767 do_debug_links
= 1;
10770 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10771 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10773 /* N.B. The order here must match the order in section_display_enum. */
10775 struct dwarf_section_display debug_displays
[] =
10777 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10778 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10779 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10780 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10781 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10782 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10783 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10784 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10785 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10786 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10787 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10788 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10789 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10790 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10791 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10792 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10793 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10794 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10795 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10796 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10797 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10798 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10799 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10800 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10801 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10802 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10803 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10804 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10805 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10806 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10807 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10808 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10809 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10810 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10811 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10812 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10813 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10814 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10815 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10816 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10817 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10818 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10819 /* Separate debug info files can containt their own .debug_str section,
10820 and this might be in *addition* to a .debug_str section already present
10821 in the main file. Hence we need to have two entries for .debug_str. */
10822 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10825 /* A static assertion. */
10826 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];