1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2019 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"
37 #define MAX(a, b) ((a) > (b) ? (a) : (b))
38 #define MIN(a, b) ((a) < (b) ? (a) : (b))
40 static const char *regname (unsigned int regno
, int row
);
41 static const char *regname_internal_by_table_only (unsigned int regno
);
43 static int have_frame_base
;
44 static int need_base_address
;
46 static unsigned int num_debug_info_entries
= 0;
47 static unsigned int alloc_num_debug_info_entries
= 0;
48 static debug_info
*debug_information
= NULL
;
49 /* Special value for num_debug_info_entries to indicate
50 that the .debug_info section could not be loaded/parsed. */
51 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
53 /* A .debug_info section can contain multiple links to separate
54 DWO object files. We use these structures to record these links. */
62 typedef struct dwo_info
66 struct dwo_info
* next
;
69 static dwo_info
* first_dwo_info
= NULL
;
70 static bfd_boolean need_dwo_info
;
72 separate_info
* first_separate_info
= NULL
;
74 unsigned int eh_addr_size
;
79 int do_debug_pubnames
;
80 int do_debug_pubtypes
;
84 int do_debug_frames_interp
;
93 int do_debug_cu_index
;
98 int dwarf_cutoff_level
= -1;
99 unsigned long dwarf_start_die
;
103 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
104 testing whether e.g. a locview list is present. */
105 static const dwarf_vma vm1
= -1;
107 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
108 sections. For version 1 package files, each set is stored in SHNDX_POOL
109 as a zero-terminated list of section indexes comprising one set of debug
110 sections from a .dwo file. */
112 static unsigned int *shndx_pool
= NULL
;
113 static unsigned int shndx_pool_size
= 0;
114 static unsigned int shndx_pool_used
= 0;
116 /* For version 2 package files, each set contains an array of section offsets
117 and an array of section sizes, giving the offset and size of the
118 contribution from a CU or TU within one of the debug sections.
119 When displaying debug info from a package file, we need to use these
120 tables to locate the corresponding contributions to each section. */
125 dwarf_vma section_offsets
[DW_SECT_MAX
];
126 size_t section_sizes
[DW_SECT_MAX
];
129 static int cu_count
= 0;
130 static int tu_count
= 0;
131 static struct cu_tu_set
*cu_sets
= NULL
;
132 static struct cu_tu_set
*tu_sets
= NULL
;
134 static bfd_boolean
load_cu_tu_indexes (void *);
136 /* An array that indicates for a given level of CU nesting whether
137 the latest DW_AT_type seen for that level was a signed type or
139 #define MAX_CU_NESTING (1 << 8)
140 static bfd_boolean level_type_signed
[MAX_CU_NESTING
];
142 /* Values for do_debug_lines. */
143 #define FLAG_DEBUG_LINES_RAW 1
144 #define FLAG_DEBUG_LINES_DECODED 2
147 size_of_encoded_value (int encoding
)
149 switch (encoding
& 0x7)
152 case 0: return eh_addr_size
;
160 get_encoded_value (unsigned char **pdata
,
162 struct dwarf_section
*section
,
165 unsigned char * data
= * pdata
;
166 unsigned int size
= size_of_encoded_value (encoding
);
169 if (data
+ size
>= end
)
171 warn (_("Encoded value extends past end of section\n"));
176 /* PR 17512: file: 002-829853-0.004. */
179 warn (_("Encoded size of %d is too large to read\n"), size
);
184 /* PR 17512: file: 1085-5603-0.004. */
187 warn (_("Encoded size of 0 is too small to read\n"));
192 if (encoding
& DW_EH_PE_signed
)
193 val
= byte_get_signed (data
, size
);
195 val
= byte_get (data
, size
);
197 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
198 val
+= section
->address
+ (data
- section
->start
);
200 * pdata
= data
+ size
;
204 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
206 # define DWARF_VMA_FMT "ll"
207 # define DWARF_VMA_FMT_LONG "%16.16llx"
209 # define DWARF_VMA_FMT "I64"
210 # define DWARF_VMA_FMT_LONG "%016I64x"
213 # define DWARF_VMA_FMT "l"
214 # define DWARF_VMA_FMT_LONG "%16.16lx"
217 /* Convert a dwarf vma value into a string. Returns a pointer to a static
218 buffer containing the converted VALUE. The value is converted according
219 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
220 it specifies the maximum number of bytes to be displayed in the converted
221 value and FMTCH is ignored - hex is always used. */
224 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
226 /* As dwarf_vmatoa is used more then once in a printf call
227 for output, we are cycling through an fixed array of pointers
228 for return address. */
229 static int buf_pos
= 0;
230 static struct dwarf_vmatoa_buf
236 ret
= buf
[buf_pos
++].place
;
237 buf_pos
%= ARRAY_SIZE (buf
);
241 /* Printf does not have a way of specifying a maximum field width for an
242 integer value, so we print the full value into a buffer and then select
243 the precision we need. */
244 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
247 return ret
+ (16 - 2 * num_bytes
);
254 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
256 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
257 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
262 static inline const char *
263 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
265 return dwarf_vmatoa_1 (fmtch
, value
, 0);
268 /* Print a dwarf_vma value (typically an address, offset or length) in
269 hexadecimal format, followed by a space. The length of the VALUE (and
270 hence the precision displayed) is determined by the NUM_BYTES parameter. */
273 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
275 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
278 /* Print a view number in hexadecimal value, with the same width
279 print_dwarf_vma would have printed it with the same num_bytes.
280 Print blanks for zero view, unless force is nonzero. */
283 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
291 assert (value
== (unsigned long) value
);
293 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
295 printf ("%*s", len
+ 1, "");
298 /* Format a 64-bit value, given as two 32-bit values, in hex.
299 For reentrancy, this uses a buffer provided by the caller. */
302 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
303 unsigned int buf_len
)
308 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
311 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
312 snprintf (buf
+ len
, buf_len
- len
,
313 "%08" DWARF_VMA_FMT
"x", lvalue
);
319 /* Read in a LEB128 encoded value starting at address DATA.
320 If SIGN is true, return a signed LEB128 value.
321 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
322 If STATUS_RETURN in not NULL, return with bit 0 (LSB) set if the
323 terminating byte was not found and with bit 1 set if the value
324 overflows a dwarf_vma.
325 No bytes will be read at address END or beyond. */
328 read_leb128 (unsigned char *data
,
329 const unsigned char *const end
,
331 unsigned int *length_return
,
334 dwarf_vma result
= 0;
335 unsigned int num_read
= 0;
336 unsigned int shift
= 0;
341 unsigned char byte
= *data
++;
344 if (shift
< sizeof (result
) * 8)
346 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
347 if ((result
>> shift
) != (byte
& 0x7f))
352 else if ((byte
& 0x7f) != 0)
355 if ((byte
& 0x80) == 0)
358 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
359 result
|= -((dwarf_vma
) 1 << shift
);
364 if (length_return
!= NULL
)
365 *length_return
= num_read
;
366 if (status_return
!= NULL
)
367 *status_return
= status
;
372 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
373 Checks to make sure that the read will not reach or pass END
374 and that VAL is big enough to hold AMOUNT bytes. */
375 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
378 unsigned int amount = (AMOUNT); \
379 if (sizeof (VAL) < amount) \
381 error (ngettext ("internal error: attempt to read %d byte " \
382 "of data in to %d sized variable", \
383 "internal error: attempt to read %d bytes " \
384 "of data in to %d sized variable", \
386 amount, (int) sizeof (VAL)); \
387 amount = sizeof (VAL); \
389 if (((PTR) + amount) >= (END)) \
392 amount = (END) - (PTR); \
396 if (amount == 0 || amount > 8) \
399 VAL = byte_get ((PTR), amount); \
403 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */
404 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
407 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
412 /* Like SAFE_BYTE_GET, but reads a signed value. */
413 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
416 unsigned int amount = (AMOUNT); \
417 if (((PTR) + amount) >= (END)) \
420 amount = (END) - (PTR); \
425 VAL = byte_get_signed ((PTR), amount); \
431 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */
432 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
435 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
440 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
443 if (((PTR) + 8) <= (END)) \
445 byte_get_64 ((PTR), (HIGH), (LOW)); \
449 * (LOW) = * (HIGH) = 0; \
454 typedef struct State_Machine_Registers
463 unsigned char op_index
;
464 unsigned char end_sequence
;
465 /* This variable hold the number of the last entry seen
466 in the File Table. */
467 unsigned int last_file_entry
;
470 static SMR state_machine_regs
;
473 reset_state_machine (int is_stmt
)
475 state_machine_regs
.address
= 0;
476 state_machine_regs
.view
= 0;
477 state_machine_regs
.op_index
= 0;
478 state_machine_regs
.file
= 1;
479 state_machine_regs
.line
= 1;
480 state_machine_regs
.column
= 0;
481 state_machine_regs
.is_stmt
= is_stmt
;
482 state_machine_regs
.basic_block
= 0;
483 state_machine_regs
.end_sequence
= 0;
484 state_machine_regs
.last_file_entry
= 0;
487 /* Handled an extend line op.
488 Returns the number of bytes read. */
491 process_extended_line_op (unsigned char * data
,
495 unsigned char op_code
;
496 size_t len
, header_len
;
498 unsigned char *orig_data
= data
;
501 READ_ULEB (len
, data
, end
);
502 header_len
= data
- orig_data
;
504 if (len
== 0 || data
== end
|| len
> (size_t) (end
- data
))
506 warn (_("Badly formed extended line op encountered!\n"));
512 printf (_(" Extended opcode %d: "), op_code
);
516 case DW_LNE_end_sequence
:
517 printf (_("End of Sequence\n\n"));
518 reset_state_machine (is_stmt
);
521 case DW_LNE_set_address
:
522 /* PR 17512: file: 002-100480-0.004. */
525 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
526 (unsigned long) len
- 1);
530 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
531 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
532 state_machine_regs
.address
= adr
;
533 state_machine_regs
.view
= 0;
534 state_machine_regs
.op_index
= 0;
537 case DW_LNE_define_file
:
538 printf (_("define new File Table entry\n"));
539 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
540 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
546 l
= strnlen ((char *) data
, end
- data
);
548 READ_ULEB (val
, data
, end
);
549 printf ("%s\t", dwarf_vmatoa ("u", val
));
550 READ_ULEB (val
, data
, end
);
551 printf ("%s\t", dwarf_vmatoa ("u", val
));
552 READ_ULEB (val
, data
, end
);
553 printf ("%s\t", dwarf_vmatoa ("u", val
));
554 printf ("%.*s\n\n", (int) l
, name
);
557 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
== end
)
558 warn (_("DW_LNE_define_file: Bad opcode length\n"));
561 case DW_LNE_set_discriminator
:
562 READ_ULEB (val
, data
, end
);
563 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val
));
567 case DW_LNE_HP_negate_is_UV_update
:
568 printf ("DW_LNE_HP_negate_is_UV_update\n");
570 case DW_LNE_HP_push_context
:
571 printf ("DW_LNE_HP_push_context\n");
573 case DW_LNE_HP_pop_context
:
574 printf ("DW_LNE_HP_pop_context\n");
576 case DW_LNE_HP_set_file_line_column
:
577 printf ("DW_LNE_HP_set_file_line_column\n");
579 case DW_LNE_HP_set_routine_name
:
580 printf ("DW_LNE_HP_set_routine_name\n");
582 case DW_LNE_HP_set_sequence
:
583 printf ("DW_LNE_HP_set_sequence\n");
585 case DW_LNE_HP_negate_post_semantics
:
586 printf ("DW_LNE_HP_negate_post_semantics\n");
588 case DW_LNE_HP_negate_function_exit
:
589 printf ("DW_LNE_HP_negate_function_exit\n");
591 case DW_LNE_HP_negate_front_end_logical
:
592 printf ("DW_LNE_HP_negate_front_end_logical\n");
594 case DW_LNE_HP_define_proc
:
595 printf ("DW_LNE_HP_define_proc\n");
597 case DW_LNE_HP_source_file_correlation
:
599 unsigned char *edata
= data
+ len
- 1;
601 printf ("DW_LNE_HP_source_file_correlation\n");
607 READ_ULEB (opc
, data
, edata
);
611 case DW_LNE_HP_SFC_formfeed
:
612 printf (" DW_LNE_HP_SFC_formfeed\n");
614 case DW_LNE_HP_SFC_set_listing_line
:
615 READ_ULEB (val
, data
, edata
);
616 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
617 dwarf_vmatoa ("u", val
));
619 case DW_LNE_HP_SFC_associate
:
620 printf (" DW_LNE_HP_SFC_associate ");
621 READ_ULEB (val
, data
, edata
);
622 printf ("(%s", dwarf_vmatoa ("u", val
));
623 READ_ULEB (val
, data
, edata
);
624 printf (",%s", dwarf_vmatoa ("u", val
));
625 READ_ULEB (val
, data
, edata
);
626 printf (",%s)\n", dwarf_vmatoa ("u", val
));
629 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
639 unsigned int rlen
= len
- 1;
641 if (op_code
>= DW_LNE_lo_user
642 /* The test against DW_LNW_hi_user is redundant due to
643 the limited range of the unsigned char data type used
645 /*&& op_code <= DW_LNE_hi_user*/)
646 printf (_("user defined: "));
648 printf (_("UNKNOWN: "));
649 printf (_("length %d ["), rlen
);
651 printf (" %02x", *data
++);
657 return len
+ header_len
;
660 static const unsigned char *
661 fetch_indirect_string (dwarf_vma offset
)
663 struct dwarf_section
*section
= &debug_displays
[str
].section
;
664 const unsigned char * ret
;
666 if (section
->start
== NULL
)
667 return (const unsigned char *) _("<no .debug_str section>");
669 if (offset
>= section
->size
)
671 warn (_("DW_FORM_strp offset too big: %s\n"),
672 dwarf_vmatoa ("x", offset
));
673 return (const unsigned char *) _("<offset is too big>");
676 ret
= section
->start
+ offset
;
677 /* Unfortunately we cannot rely upon the .debug_str section ending with a
678 NUL byte. Since our caller is expecting to receive a well formed C
679 string we test for the lack of a terminating byte here. */
680 if (strnlen ((const char *) ret
, section
->size
- offset
)
681 == section
->size
- offset
)
682 ret
= (const unsigned char *)
683 _("<no NUL byte at end of .debug_str section>");
688 static const unsigned char *
689 fetch_indirect_line_string (dwarf_vma offset
)
691 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
692 const unsigned char * ret
;
694 if (section
->start
== NULL
)
695 return (const unsigned char *) _("<no .debug_line_str section>");
697 if (offset
>= section
->size
)
699 warn (_("DW_FORM_line_strp offset too big: %s\n"),
700 dwarf_vmatoa ("x", offset
));
701 return (const unsigned char *) _("<offset is too big>");
704 ret
= section
->start
+ offset
;
705 /* Unfortunately we cannot rely upon the .debug_line_str section ending
706 with a NUL byte. Since our caller is expecting to receive a well formed
707 C string we test for the lack of a terminating byte here. */
708 if (strnlen ((const char *) ret
, section
->size
- offset
)
709 == section
->size
- offset
)
710 ret
= (const unsigned char *)
711 _("<no NUL byte at end of .debug_line_str section>");
717 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
718 dwarf_vma offset_size
, bfd_boolean dwo
)
720 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
721 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
722 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
723 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
724 dwarf_vma index_offset
= idx
* offset_size
;
725 dwarf_vma str_offset
;
728 if (index_section
->start
== NULL
)
729 return (dwo
? _("<no .debug_str_offsets.dwo section>")
730 : _("<no .debug_str_offsets section>"));
732 if (this_set
!= NULL
)
733 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
734 if (index_offset
>= index_section
->size
)
736 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
737 dwarf_vmatoa ("x", index_offset
));
738 return _("<index offset is too big>");
741 if (str_section
->start
== NULL
)
742 return (dwo
? _("<no .debug_str.dwo section>")
743 : _("<no .debug_str section>"));
745 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
746 str_offset
-= str_section
->address
;
747 if (str_offset
>= str_section
->size
)
749 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
750 dwarf_vmatoa ("x", str_offset
));
751 return _("<indirect index offset is too big>");
754 ret
= (const char *) str_section
->start
+ str_offset
;
755 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
756 Since our caller is expecting to receive a well formed C string we test
757 for the lack of a terminating byte here. */
758 if (strnlen (ret
, str_section
->size
- str_offset
)
759 == str_section
->size
- str_offset
)
760 ret
= (const char *) _("<no NUL byte at end of section>");
766 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
768 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
770 if (section
->start
== NULL
)
771 return (_("<no .debug_addr section>"));
773 if (offset
+ bytes
> section
->size
)
775 warn (_("Offset into section %s too big: %s\n"),
776 section
->name
, dwarf_vmatoa ("x", offset
));
777 return "<offset too big>";
780 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
784 /* FIXME: There are better and more efficient ways to handle
785 these structures. For now though, I just want something that
786 is simple to implement. */
787 typedef struct abbrev_attr
789 unsigned long attribute
;
791 bfd_signed_vma implicit_const
;
792 struct abbrev_attr
*next
;
796 typedef struct abbrev_entry
801 struct abbrev_attr
*first_attr
;
802 struct abbrev_attr
*last_attr
;
803 struct abbrev_entry
*next
;
807 static abbrev_entry
*first_abbrev
= NULL
;
808 static abbrev_entry
*last_abbrev
= NULL
;
815 for (abbrv
= first_abbrev
; abbrv
;)
817 abbrev_entry
*next_abbrev
= abbrv
->next
;
820 for (attr
= abbrv
->first_attr
; attr
;)
822 abbrev_attr
*next_attr
= attr
->next
;
832 last_abbrev
= first_abbrev
= NULL
;
836 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
840 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
845 entry
->entry
= number
;
847 entry
->children
= children
;
848 entry
->first_attr
= NULL
;
849 entry
->last_attr
= NULL
;
852 if (first_abbrev
== NULL
)
853 first_abbrev
= entry
;
855 last_abbrev
->next
= entry
;
861 add_abbrev_attr (unsigned long attribute
, unsigned long form
,
862 bfd_signed_vma implicit_const
)
866 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
871 attr
->attribute
= attribute
;
873 attr
->implicit_const
= implicit_const
;
876 if (last_abbrev
->first_attr
== NULL
)
877 last_abbrev
->first_attr
= attr
;
879 last_abbrev
->last_attr
->next
= attr
;
881 last_abbrev
->last_attr
= attr
;
884 /* Processes the (partial) contents of a .debug_abbrev section.
885 Returns NULL if the end of the section was encountered.
886 Returns the address after the last byte read if the end of
887 an abbreviation set was found. */
889 static unsigned char *
890 process_abbrev_section (unsigned char *start
, unsigned char *end
)
892 if (first_abbrev
!= NULL
)
899 unsigned long attribute
;
902 READ_ULEB (entry
, start
, end
);
904 /* A single zero is supposed to end the section according
905 to the standard. If there's more, then signal that to
912 READ_ULEB (tag
, start
, end
);
918 add_abbrev (entry
, tag
, children
);
923 /* Initialize it due to a false compiler warning. */
924 bfd_signed_vma implicit_const
= -1;
926 READ_ULEB (attribute
, start
, end
);
930 READ_ULEB (form
, start
, end
);
934 if (form
== DW_FORM_implicit_const
)
936 READ_SLEB (implicit_const
, start
, end
);
941 add_abbrev_attr (attribute
, form
, implicit_const
);
943 while (attribute
!= 0);
946 /* Report the missing single zero which ends the section. */
947 error (_(".debug_abbrev section not zero terminated\n"));
953 get_TAG_name (unsigned long tag
)
955 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
959 static char buffer
[100];
961 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
962 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
964 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
972 get_FORM_name (unsigned long form
)
977 return "DW_FORM value: 0";
979 name
= get_DW_FORM_name (form
);
982 static char buffer
[100];
984 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
992 get_IDX_name (unsigned long idx
)
994 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
998 static char buffer
[100];
1000 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1007 static unsigned char *
1008 display_block (unsigned char *data
,
1010 const unsigned char * const end
, char delimiter
)
1014 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1016 return (unsigned char *) end
;
1018 maxlen
= (dwarf_vma
) (end
- data
);
1019 length
= length
> maxlen
? maxlen
: length
;
1022 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1028 decode_location_expression (unsigned char * data
,
1029 unsigned int pointer_size
,
1030 unsigned int offset_size
,
1033 dwarf_vma cu_offset
,
1034 struct dwarf_section
* section
)
1038 dwarf_signed_vma svalue
;
1039 unsigned char *end
= data
+ length
;
1040 int need_frame_base
= 0;
1049 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1050 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1053 printf ("DW_OP_deref");
1056 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1057 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1060 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1061 printf ("DW_OP_const1s: %ld", (long) svalue
);
1064 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1065 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1068 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1069 printf ("DW_OP_const2s: %ld", (long) svalue
);
1072 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1073 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1076 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1077 printf ("DW_OP_const4s: %ld", (long) svalue
);
1080 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1081 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1082 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1083 printf ("%lu", (unsigned long) uvalue
);
1086 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1087 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1088 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1089 printf ("%ld", (long) svalue
);
1092 READ_ULEB (uvalue
, data
, end
);
1093 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue
));
1096 READ_SLEB (svalue
, data
, end
);
1097 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue
));
1100 printf ("DW_OP_dup");
1103 printf ("DW_OP_drop");
1106 printf ("DW_OP_over");
1109 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1110 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1113 printf ("DW_OP_swap");
1116 printf ("DW_OP_rot");
1119 printf ("DW_OP_xderef");
1122 printf ("DW_OP_abs");
1125 printf ("DW_OP_and");
1128 printf ("DW_OP_div");
1131 printf ("DW_OP_minus");
1134 printf ("DW_OP_mod");
1137 printf ("DW_OP_mul");
1140 printf ("DW_OP_neg");
1143 printf ("DW_OP_not");
1146 printf ("DW_OP_or");
1149 printf ("DW_OP_plus");
1151 case DW_OP_plus_uconst
:
1152 READ_ULEB (uvalue
, data
, end
);
1153 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue
));
1156 printf ("DW_OP_shl");
1159 printf ("DW_OP_shr");
1162 printf ("DW_OP_shra");
1165 printf ("DW_OP_xor");
1168 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1169 printf ("DW_OP_bra: %ld", (long) svalue
);
1172 printf ("DW_OP_eq");
1175 printf ("DW_OP_ge");
1178 printf ("DW_OP_gt");
1181 printf ("DW_OP_le");
1184 printf ("DW_OP_lt");
1187 printf ("DW_OP_ne");
1190 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1191 printf ("DW_OP_skip: %ld", (long) svalue
);
1226 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1261 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1262 regname (op
- DW_OP_reg0
, 1));
1297 READ_SLEB (svalue
, data
, end
);
1298 printf ("DW_OP_breg%d (%s): %s", op
- DW_OP_breg0
,
1299 regname (op
- DW_OP_breg0
, 1), dwarf_vmatoa ("d", svalue
));
1303 READ_ULEB (uvalue
, data
, end
);
1304 printf ("DW_OP_regx: %s (%s)",
1305 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1308 need_frame_base
= 1;
1309 READ_SLEB (svalue
, data
, end
);
1310 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue
));
1313 READ_ULEB (uvalue
, data
, end
);
1314 READ_SLEB (svalue
, data
, end
);
1315 printf ("DW_OP_bregx: %s (%s) %s",
1316 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1317 dwarf_vmatoa ("d", svalue
));
1320 READ_ULEB (uvalue
, data
, end
);
1321 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue
));
1323 case DW_OP_deref_size
:
1324 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1325 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1327 case DW_OP_xderef_size
:
1328 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1329 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1332 printf ("DW_OP_nop");
1335 /* DWARF 3 extensions. */
1336 case DW_OP_push_object_address
:
1337 printf ("DW_OP_push_object_address");
1340 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1341 this ought to be an 8-byte wide computation. */
1342 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1343 printf ("DW_OP_call2: <0x%s>",
1344 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1347 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1348 this ought to be an 8-byte wide computation. */
1349 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1350 printf ("DW_OP_call4: <0x%s>",
1351 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1353 case DW_OP_call_ref
:
1354 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1355 this ought to be an 8-byte wide computation. */
1356 if (dwarf_version
== -1)
1358 printf (_("(DW_OP_call_ref in frame info)"));
1359 /* No way to tell where the next op is, so just bail. */
1360 return need_frame_base
;
1362 if (dwarf_version
== 2)
1364 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1368 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1370 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1372 case DW_OP_form_tls_address
:
1373 printf ("DW_OP_form_tls_address");
1375 case DW_OP_call_frame_cfa
:
1376 printf ("DW_OP_call_frame_cfa");
1378 case DW_OP_bit_piece
:
1379 printf ("DW_OP_bit_piece: ");
1380 READ_ULEB (uvalue
, data
, end
);
1381 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue
));
1382 READ_ULEB (uvalue
, data
, end
);
1383 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue
));
1386 /* DWARF 4 extensions. */
1387 case DW_OP_stack_value
:
1388 printf ("DW_OP_stack_value");
1391 case DW_OP_implicit_value
:
1392 printf ("DW_OP_implicit_value");
1393 READ_ULEB (uvalue
, data
, end
);
1394 data
= display_block (data
, uvalue
, end
, ' ');
1397 /* GNU extensions. */
1398 case DW_OP_GNU_push_tls_address
:
1399 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1401 case DW_OP_GNU_uninit
:
1402 printf ("DW_OP_GNU_uninit");
1403 /* FIXME: Is there data associated with this OP ? */
1405 case DW_OP_GNU_encoded_addr
:
1412 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1414 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1415 print_dwarf_vma (addr
, pointer_size
);
1418 case DW_OP_implicit_pointer
:
1419 case DW_OP_GNU_implicit_pointer
:
1420 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1421 this ought to be an 8-byte wide computation. */
1422 if (dwarf_version
== -1)
1424 printf (_("(%s in frame info)"),
1425 (op
== DW_OP_implicit_pointer
1426 ? "DW_OP_implicit_pointer"
1427 : "DW_OP_GNU_implicit_pointer"));
1428 /* No way to tell where the next op is, so just bail. */
1429 return need_frame_base
;
1431 if (dwarf_version
== 2)
1433 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1437 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1439 READ_SLEB (svalue
, data
, end
);
1440 printf ("%s: <0x%s> %s",
1441 (op
== DW_OP_implicit_pointer
1442 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1443 dwarf_vmatoa ("x", uvalue
),
1444 dwarf_vmatoa ("d", svalue
));
1446 case DW_OP_entry_value
:
1447 case DW_OP_GNU_entry_value
:
1448 READ_ULEB (uvalue
, data
, end
);
1449 /* PR 17531: file: 0cc9cd00. */
1450 if (uvalue
> (dwarf_vma
) (end
- data
))
1451 uvalue
= end
- data
;
1452 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1453 : "DW_OP_GNU_entry_value"));
1454 if (decode_location_expression (data
, pointer_size
, offset_size
,
1455 dwarf_version
, uvalue
,
1456 cu_offset
, section
))
1457 need_frame_base
= 1;
1463 case DW_OP_const_type
:
1464 case DW_OP_GNU_const_type
:
1465 READ_ULEB (uvalue
, data
, end
);
1466 printf ("%s: <0x%s> ",
1467 (op
== DW_OP_const_type
? "DW_OP_const_type"
1468 : "DW_OP_GNU_const_type"),
1469 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1470 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1471 data
= display_block (data
, uvalue
, end
, ' ');
1473 case DW_OP_regval_type
:
1474 case DW_OP_GNU_regval_type
:
1475 READ_ULEB (uvalue
, data
, end
);
1476 printf ("%s: %s (%s)",
1477 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1478 : "DW_OP_GNU_regval_type"),
1479 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1480 READ_ULEB (uvalue
, data
, end
);
1481 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1483 case DW_OP_deref_type
:
1484 case DW_OP_GNU_deref_type
:
1485 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1487 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1488 : "DW_OP_GNU_deref_type"),
1490 READ_ULEB (uvalue
, data
, end
);
1491 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1494 case DW_OP_GNU_convert
:
1495 READ_ULEB (uvalue
, data
, end
);
1496 printf ("%s <0x%s>",
1497 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1498 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1500 case DW_OP_reinterpret
:
1501 case DW_OP_GNU_reinterpret
:
1502 READ_ULEB (uvalue
, data
, end
);
1503 printf ("%s <0x%s>",
1504 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1505 : "DW_OP_GNU_reinterpret"),
1506 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1508 case DW_OP_GNU_parameter_ref
:
1509 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1510 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1511 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1513 case DW_OP_GNU_addr_index
:
1514 READ_ULEB (uvalue
, data
, end
);
1515 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1517 case DW_OP_GNU_const_index
:
1518 READ_ULEB (uvalue
, data
, end
);
1519 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1521 case DW_OP_GNU_variable_value
:
1522 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1523 this ought to be an 8-byte wide computation. */
1524 if (dwarf_version
== -1)
1526 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1527 /* No way to tell where the next op is, so just bail. */
1528 return need_frame_base
;
1530 if (dwarf_version
== 2)
1532 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1536 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1538 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1541 /* HP extensions. */
1542 case DW_OP_HP_is_value
:
1543 printf ("DW_OP_HP_is_value");
1544 /* FIXME: Is there data associated with this OP ? */
1546 case DW_OP_HP_fltconst4
:
1547 printf ("DW_OP_HP_fltconst4");
1548 /* FIXME: Is there data associated with this OP ? */
1550 case DW_OP_HP_fltconst8
:
1551 printf ("DW_OP_HP_fltconst8");
1552 /* FIXME: Is there data associated with this OP ? */
1554 case DW_OP_HP_mod_range
:
1555 printf ("DW_OP_HP_mod_range");
1556 /* FIXME: Is there data associated with this OP ? */
1558 case DW_OP_HP_unmod_range
:
1559 printf ("DW_OP_HP_unmod_range");
1560 /* FIXME: Is there data associated with this OP ? */
1563 printf ("DW_OP_HP_tls");
1564 /* FIXME: Is there data associated with this OP ? */
1567 /* PGI (STMicroelectronics) extensions. */
1568 case DW_OP_PGI_omp_thread_num
:
1569 /* Pushes the thread number for the current thread as it would be
1570 returned by the standard OpenMP library function:
1571 omp_get_thread_num(). The "current thread" is the thread for
1572 which the expression is being evaluated. */
1573 printf ("DW_OP_PGI_omp_thread_num");
1577 if (op
>= DW_OP_lo_user
1578 && op
<= DW_OP_hi_user
)
1579 printf (_("(User defined location op 0x%x)"), op
);
1581 printf (_("(Unknown location op 0x%x)"), op
);
1582 /* No way to tell where the next op is, so just bail. */
1583 return need_frame_base
;
1586 /* Separate the ops. */
1591 return need_frame_base
;
1594 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1595 This is used for DWARF package files. */
1597 static struct cu_tu_set
*
1598 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1600 struct cu_tu_set
*p
;
1602 unsigned int dw_sect
;
1608 dw_sect
= DW_SECT_TYPES
;
1614 dw_sect
= DW_SECT_INFO
;
1618 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1626 /* Add INC to HIGH_BITS:LOW_BITS. */
1628 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1630 dwarf_vma tmp
= * low_bits
;
1634 /* FIXME: There is probably a better way of handling this:
1636 We need to cope with dwarf_vma being a 32-bit or 64-bit
1637 type. Plus regardless of its size LOW_BITS is meant to
1638 only hold 32-bits, so if there is overflow or wrap around
1639 we must propagate into HIGH_BITS. */
1640 if (tmp
< * low_bits
)
1644 else if (sizeof (tmp
) > 8
1655 fetch_alt_indirect_string (dwarf_vma offset
)
1659 if (! do_follow_links
)
1662 if (first_separate_info
== NULL
)
1663 return _("<no links available>");
1665 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1667 struct dwarf_section
* section
;
1670 if (! load_debug_section (separate_debug_str
, i
->handle
))
1673 section
= &debug_displays
[separate_debug_str
].section
;
1675 if (section
->start
== NULL
)
1678 if (offset
>= section
->size
)
1681 ret
= (const char *) (section
->start
+ offset
);
1682 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1683 NUL byte. Since our caller is expecting to receive a well formed C
1684 string we test for the lack of a terminating byte here. */
1685 if (strnlen ((const char *) ret
, section
->size
- offset
)
1686 == section
->size
- offset
)
1687 return _("<no NUL byte at end of alt .debug_str section>");
1692 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1693 dwarf_vmatoa ("x", offset
));
1694 return _("<offset is too big>");
1698 get_AT_name (unsigned long attribute
)
1703 return "DW_AT value: 0";
1705 /* One value is shared by the MIPS and HP extensions: */
1706 if (attribute
== DW_AT_MIPS_fde
)
1707 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1709 name
= get_DW_AT_name (attribute
);
1713 static char buffer
[100];
1715 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1724 add_dwo_info (const char * field
, dwo_type type
)
1726 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1728 dwinfo
->type
= type
;
1729 dwinfo
->value
= field
;
1730 dwinfo
->next
= first_dwo_info
;
1731 first_dwo_info
= dwinfo
;
1735 add_dwo_name (const char * name
)
1737 add_dwo_info (name
, DWO_NAME
);
1741 add_dwo_dir (const char * dir
)
1743 add_dwo_info (dir
, DWO_DIR
);
1747 add_dwo_id (const char * id
)
1749 add_dwo_info (id
, DWO_ID
);
1753 free_dwo_info (void)
1758 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1760 next
= dwinfo
->next
;
1763 first_dwo_info
= NULL
;
1766 /* Ensure that START + UVALUE is less than END.
1767 Return an adjusted UVALUE if necessary to ensure this relationship. */
1769 static inline dwarf_vma
1770 check_uvalue (const unsigned char * start
,
1772 const unsigned char * end
)
1774 dwarf_vma max_uvalue
= end
- start
;
1776 /* See PR 17512: file: 008-103549-0.001:0.1.
1777 and PR 24829 for examples of where these tests are triggered. */
1778 if (uvalue
> max_uvalue
)
1780 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1781 uvalue
= max_uvalue
;
1787 static unsigned char *
1788 skip_attr_bytes (unsigned long form
,
1789 unsigned char * data
,
1790 unsigned const char * end
,
1791 dwarf_vma pointer_size
,
1792 dwarf_vma offset_size
,
1794 dwarf_vma
* value_return
)
1796 dwarf_signed_vma svalue
;
1797 dwarf_vma uvalue
= 0;
1803 case DW_FORM_ref_addr
:
1804 if (dwarf_version
== 2)
1805 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1806 else if (dwarf_version
== 3 || dwarf_version
== 4)
1807 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1813 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1817 case DW_FORM_line_strp
:
1818 case DW_FORM_sec_offset
:
1819 case DW_FORM_GNU_ref_alt
:
1820 case DW_FORM_GNU_strp_alt
:
1821 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1824 case DW_FORM_flag_present
:
1831 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1836 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1841 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1845 READ_SLEB (svalue
, data
, end
);
1849 case DW_FORM_ref_udata
:
1851 case DW_FORM_GNU_str_index
:
1852 case DW_FORM_GNU_addr_index
:
1853 READ_ULEB (uvalue
, data
, end
);
1861 case DW_FORM_data16
:
1865 case DW_FORM_string
:
1866 data
+= strnlen ((char *) data
, end
- data
) + 1;
1870 case DW_FORM_exprloc
:
1871 READ_ULEB (uvalue
, data
, end
);
1874 case DW_FORM_block1
:
1875 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1879 case DW_FORM_block2
:
1880 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1884 case DW_FORM_block4
:
1885 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1889 case DW_FORM_ref_sig8
:
1893 case DW_FORM_indirect
:
1894 /* FIXME: Handle this form. */
1899 * value_return
= uvalue
;
1901 data
= (unsigned char *) end
;
1905 /* Return IS_SIGNED set to TRUE if the type at
1906 DATA can be determined to be a signed type. */
1909 get_type_signedness (unsigned char * start
,
1910 unsigned char * data
,
1911 unsigned const char * end
,
1912 dwarf_vma pointer_size
,
1913 dwarf_vma offset_size
,
1915 bfd_boolean
* is_signed
,
1916 bfd_boolean is_nested
)
1918 unsigned long abbrev_number
;
1919 abbrev_entry
* entry
;
1922 * is_signed
= FALSE
;
1924 READ_ULEB (abbrev_number
, data
, end
);
1926 for (entry
= first_abbrev
;
1927 entry
!= NULL
&& entry
->entry
!= abbrev_number
;
1928 entry
= entry
->next
)
1932 /* FIXME: Issue a warning ? */
1935 for (attr
= entry
->first_attr
;
1936 attr
!= NULL
&& attr
->attribute
;
1939 dwarf_vma uvalue
= 0;
1941 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
1942 offset_size
, dwarf_version
, & uvalue
);
1946 switch (attr
->attribute
)
1948 #if 0 /* FIXME: It would be nice to print the name of the type,
1949 but this would mean updating a lot of binutils tests. */
1951 if (attr
->form
== DW_FORM_strp
)
1952 printf ("%s", fetch_indirect_string (uvalue
));
1959 /* FIXME: Warn - or is this expected ?
1960 NB/ We need to avoid infinite recursion. */
1963 if (uvalue
>= (size_t) (end
- start
))
1965 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
1966 offset_size
, dwarf_version
, is_signed
, TRUE
);
1969 case DW_AT_encoding
:
1970 /* Determine signness. */
1973 case DW_ATE_address
:
1974 /* FIXME - some architectures have signed addresses. */
1975 case DW_ATE_boolean
:
1976 case DW_ATE_unsigned
:
1977 case DW_ATE_unsigned_char
:
1978 case DW_ATE_unsigned_fixed
:
1979 * is_signed
= FALSE
;
1983 case DW_ATE_complex_float
:
1986 case DW_ATE_signed_char
:
1987 case DW_ATE_imaginary_float
:
1988 case DW_ATE_decimal_float
:
1989 case DW_ATE_signed_fixed
:
1999 read_and_print_leb128 (unsigned char * data
,
2000 unsigned int * bytes_read
,
2001 unsigned const char * end
,
2002 bfd_boolean is_signed
)
2005 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2007 report_leb_status (status
);
2009 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2013 display_discr_list (unsigned long form
,
2015 unsigned char * data
,
2016 unsigned const char * end
,
2021 printf ("[default]");
2028 case DW_FORM_block1
:
2029 case DW_FORM_block2
:
2030 case DW_FORM_block4
:
2031 /* Move data pointer back to the start of the byte array. */
2035 printf ("<corrupt>\n");
2036 warn (_("corrupt discr_list - not using a block form\n"));
2042 printf ("<corrupt>\n");
2043 warn (_("corrupt discr_list - block not long enough\n"));
2047 bfd_boolean is_signed
=
2048 (level
> 0 && level
<= MAX_CU_NESTING
)
2049 ? level_type_signed
[level
- 1] : FALSE
;
2054 unsigned char discriminant
;
2055 unsigned int bytes_read
;
2057 SAFE_BYTE_GET (discriminant
, data
, 1, end
);
2061 assert (uvalue
> 0);
2062 switch (discriminant
)
2066 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2067 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2068 uvalue
-= bytes_read
;
2074 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2075 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2076 uvalue
-= bytes_read
;
2080 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2081 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2082 uvalue
-= bytes_read
;
2087 printf ("<corrupt>\n");
2088 warn (_("corrupt discr_list - unrecognised discriminant byte %#x\n"),
2098 printf (")(signed)");
2100 printf (")(unsigned)");
2103 static unsigned char *
2104 read_and_display_attr_value (unsigned long attribute
,
2106 dwarf_signed_vma implicit_const
,
2107 unsigned char * start
,
2108 unsigned char * data
,
2109 unsigned char * end
,
2110 dwarf_vma cu_offset
,
2111 dwarf_vma pointer_size
,
2112 dwarf_vma offset_size
,
2114 debug_info
* debug_info_p
,
2116 struct dwarf_section
* section
,
2117 struct cu_tu_set
* this_set
,
2121 dwarf_signed_vma svalue
;
2122 dwarf_vma uvalue
= 0;
2123 unsigned char * block_start
= NULL
;
2124 unsigned char * orig_data
= data
;
2126 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2128 warn (_("Corrupt attribute\n"));
2137 case DW_FORM_ref_addr
:
2138 if (dwarf_version
== 2)
2139 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2140 else if (dwarf_version
== 3 || dwarf_version
== 4)
2141 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2143 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
2148 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2152 case DW_FORM_line_strp
:
2153 case DW_FORM_sec_offset
:
2154 case DW_FORM_GNU_ref_alt
:
2155 case DW_FORM_GNU_strp_alt
:
2156 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2159 case DW_FORM_flag_present
:
2166 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2171 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2176 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2180 READ_SLEB (svalue
, data
, end
);
2184 case DW_FORM_GNU_str_index
:
2185 case DW_FORM_ref_udata
:
2187 case DW_FORM_GNU_addr_index
:
2188 READ_ULEB (uvalue
, data
, end
);
2191 case DW_FORM_indirect
:
2192 READ_ULEB (form
, data
, end
);
2194 printf ("%c%s", delimiter
, get_FORM_name (form
));
2195 if (form
== DW_FORM_implicit_const
)
2196 READ_SLEB (implicit_const
, data
, end
);
2197 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2199 cu_offset
, pointer_size
,
2200 offset_size
, dwarf_version
,
2201 debug_info_p
, do_loc
,
2202 section
, this_set
, delimiter
, level
);
2207 case DW_FORM_ref_addr
:
2209 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2212 case DW_FORM_GNU_ref_alt
:
2214 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2215 /* FIXME: Follow the reference... */
2221 case DW_FORM_ref_udata
:
2223 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2228 case DW_FORM_sec_offset
:
2230 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2233 case DW_FORM_flag_present
:
2240 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2243 case DW_FORM_implicit_const
:
2245 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2252 dwarf_vma high_bits
;
2256 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2258 if (form
== DW_FORM_ref8
)
2259 add64 (& high_bits
, & utmp
, cu_offset
);
2260 printf ("%c0x%s", delimiter
,
2261 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
2264 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2265 && num_debug_info_entries
== 0)
2267 if (sizeof (uvalue
) == 8)
2268 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
2270 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
2276 case DW_FORM_data16
:
2279 dwarf_vma left_high_bits
, left_low_bits
;
2280 dwarf_vma right_high_bits
, right_low_bits
;
2282 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
2283 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
2284 if (byte_get
== byte_get_little_endian
)
2287 left_high_bits
^= right_high_bits
;
2288 right_high_bits
^= left_high_bits
;
2289 left_high_bits
^= right_high_bits
;
2290 left_low_bits
^= right_low_bits
;
2291 right_low_bits
^= left_low_bits
;
2292 left_low_bits
^= right_low_bits
;
2294 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
2295 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
2296 left_high_bits
, left_low_bits
, right_high_bits
,
2302 case DW_FORM_string
:
2304 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2305 data
+= strnlen ((char *) data
, end
- data
) + 1;
2309 case DW_FORM_exprloc
:
2310 READ_ULEB (uvalue
, data
, end
);
2313 if (block_start
>= end
)
2315 warn (_("Block ends prematurely\n"));
2320 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2323 data
= block_start
+ uvalue
;
2325 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2328 case DW_FORM_block1
:
2329 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2332 case DW_FORM_block2
:
2333 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2336 case DW_FORM_block4
:
2337 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2342 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2343 dwarf_vmatoa ("x", uvalue
),
2344 fetch_indirect_string (uvalue
));
2347 case DW_FORM_line_strp
:
2349 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2350 dwarf_vmatoa ("x", uvalue
),
2351 fetch_indirect_line_string (uvalue
));
2354 case DW_FORM_GNU_str_index
:
2357 const char * suffix
= strrchr (section
->name
, '.');
2358 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
2360 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2361 dwarf_vmatoa ("x", uvalue
),
2362 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2366 case DW_FORM_GNU_strp_alt
:
2369 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2370 dwarf_vmatoa ("x", uvalue
),
2371 fetch_alt_indirect_string (uvalue
));
2375 case DW_FORM_indirect
:
2376 /* Handled above. */
2379 case DW_FORM_ref_sig8
:
2382 dwarf_vma high_bits
;
2385 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2386 printf ("%csignature: 0x%s", delimiter
,
2387 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2392 case DW_FORM_GNU_addr_index
:
2394 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2395 dwarf_vmatoa ("x", uvalue
),
2396 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2400 warn (_("Unrecognized form: %lu\n"), form
);
2404 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2405 && num_debug_info_entries
== 0
2406 && debug_info_p
!= NULL
)
2410 case DW_AT_frame_base
:
2411 have_frame_base
= 1;
2413 case DW_AT_location
:
2414 case DW_AT_GNU_locviews
:
2415 case DW_AT_string_length
:
2416 case DW_AT_return_addr
:
2417 case DW_AT_data_member_location
:
2418 case DW_AT_vtable_elem_location
:
2420 case DW_AT_static_link
:
2421 case DW_AT_use_location
:
2422 case DW_AT_call_value
:
2423 case DW_AT_GNU_call_site_value
:
2424 case DW_AT_call_data_value
:
2425 case DW_AT_GNU_call_site_data_value
:
2426 case DW_AT_call_target
:
2427 case DW_AT_GNU_call_site_target
:
2428 case DW_AT_call_target_clobbered
:
2429 case DW_AT_GNU_call_site_target_clobbered
:
2430 if ((dwarf_version
< 4
2431 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2432 || form
== DW_FORM_sec_offset
)
2434 /* Process location list. */
2435 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2436 unsigned int num
= debug_info_p
->num_loc_offsets
;
2438 if (lmax
== 0 || num
>= lmax
)
2441 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2442 xcrealloc (debug_info_p
->loc_offsets
,
2443 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2444 debug_info_p
->loc_views
= (dwarf_vma
*)
2445 xcrealloc (debug_info_p
->loc_views
,
2446 lmax
, sizeof (*debug_info_p
->loc_views
));
2447 debug_info_p
->have_frame_base
= (int *)
2448 xcrealloc (debug_info_p
->have_frame_base
,
2449 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2450 debug_info_p
->max_loc_offsets
= lmax
;
2452 if (this_set
!= NULL
)
2453 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2454 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2455 if (attribute
!= DW_AT_GNU_locviews
)
2457 /* Corrupt DWARF info can produce more offsets than views.
2458 See PR 23062 for an example. */
2459 if (debug_info_p
->num_loc_offsets
2460 > debug_info_p
->num_loc_views
)
2461 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2464 debug_info_p
->loc_offsets
[num
] = uvalue
;
2465 debug_info_p
->num_loc_offsets
++;
2470 assert (debug_info_p
->num_loc_views
<= num
);
2471 num
= debug_info_p
->num_loc_views
;
2472 if (num
> debug_info_p
->num_loc_offsets
)
2473 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2476 debug_info_p
->loc_views
[num
] = uvalue
;
2477 debug_info_p
->num_loc_views
++;
2484 if (need_base_address
)
2485 debug_info_p
->base_address
= uvalue
;
2488 case DW_AT_GNU_addr_base
:
2489 debug_info_p
->addr_base
= uvalue
;
2492 case DW_AT_GNU_ranges_base
:
2493 debug_info_p
->ranges_base
= uvalue
;
2497 if ((dwarf_version
< 4
2498 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2499 || form
== DW_FORM_sec_offset
)
2501 /* Process range list. */
2502 unsigned int lmax
= debug_info_p
->max_range_lists
;
2503 unsigned int num
= debug_info_p
->num_range_lists
;
2505 if (lmax
== 0 || num
>= lmax
)
2508 debug_info_p
->range_lists
= (dwarf_vma
*)
2509 xcrealloc (debug_info_p
->range_lists
,
2510 lmax
, sizeof (*debug_info_p
->range_lists
));
2511 debug_info_p
->max_range_lists
= lmax
;
2513 debug_info_p
->range_lists
[num
] = uvalue
;
2514 debug_info_p
->num_range_lists
++;
2518 case DW_AT_GNU_dwo_name
:
2519 case DW_AT_dwo_name
:
2524 add_dwo_name ((const char *) fetch_indirect_string (uvalue
));
2526 case DW_FORM_GNU_str_index
:
2527 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2529 case DW_FORM_string
:
2530 add_dwo_name ((const char *) orig_data
);
2533 warn (_("Unsupported form (%s) for attribute %s\n"),
2534 get_FORM_name (form
), get_AT_name (attribute
));
2539 case DW_AT_comp_dir
:
2540 /* FIXME: Also extract a build-id in a CU/TU. */
2545 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
));
2547 case DW_FORM_line_strp
:
2548 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
));
2550 case DW_FORM_GNU_str_index
:
2551 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2553 case DW_FORM_string
:
2554 add_dwo_dir ((const char *) orig_data
);
2557 warn (_("Unsupported form (%s) for attribute %s\n"),
2558 get_FORM_name (form
), get_AT_name (attribute
));
2563 case DW_AT_GNU_dwo_id
:
2568 /* FIXME: Record the length of the ID as well ? */
2569 add_dwo_id ((const char *) (data
- 8));
2572 warn (_("Unsupported form (%s) for attribute %s\n"),
2573 get_FORM_name (form
), get_AT_name (attribute
));
2583 if (do_loc
|| attribute
== 0)
2586 /* For some attributes we can display further information. */
2590 if (level
>= 0 && level
< MAX_CU_NESTING
2591 && uvalue
< (size_t) (end
- start
))
2593 bfd_boolean is_signed
= FALSE
;
2595 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
2596 offset_size
, dwarf_version
, & is_signed
, FALSE
);
2597 level_type_signed
[level
] = is_signed
;
2605 case DW_INL_not_inlined
:
2606 printf (_("(not inlined)"));
2608 case DW_INL_inlined
:
2609 printf (_("(inlined)"));
2611 case DW_INL_declared_not_inlined
:
2612 printf (_("(declared as inline but ignored)"));
2614 case DW_INL_declared_inlined
:
2615 printf (_("(declared as inline and inlined)"));
2618 printf (_(" (Unknown inline attribute value: %s)"),
2619 dwarf_vmatoa ("x", uvalue
));
2624 case DW_AT_language
:
2628 /* Ordered by the numeric value of these constants. */
2629 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2630 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2631 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2632 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2633 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2634 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2635 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2636 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2637 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2638 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2639 /* DWARF 2.1 values. */
2640 case DW_LANG_Java
: printf ("(Java)"); break;
2641 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2642 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2643 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2644 /* DWARF 3 values. */
2645 case DW_LANG_PLI
: printf ("(PLI)"); break;
2646 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2647 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2648 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2649 case DW_LANG_D
: printf ("(D)"); break;
2650 /* DWARF 4 values. */
2651 case DW_LANG_Python
: printf ("(Python)"); break;
2652 /* DWARF 5 values. */
2653 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
2654 case DW_LANG_Go
: printf ("(Go)"); break;
2655 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
2656 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
2657 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
2658 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2659 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
2660 case DW_LANG_Rust
: printf ("(Rust)"); break;
2661 case DW_LANG_C11
: printf ("(C11)"); break;
2662 case DW_LANG_Swift
: printf ("(Swift)"); break;
2663 case DW_LANG_Julia
: printf ("(Julia)"); break;
2664 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
2665 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2666 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2667 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2668 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
2669 /* MIPS extension. */
2670 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2671 /* UPC extension. */
2672 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2674 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2675 printf (_("(implementation defined: %s)"),
2676 dwarf_vmatoa ("x", uvalue
));
2678 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2683 case DW_AT_encoding
:
2687 case DW_ATE_void
: printf ("(void)"); break;
2688 case DW_ATE_address
: printf ("(machine address)"); break;
2689 case DW_ATE_boolean
: printf ("(boolean)"); break;
2690 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2691 case DW_ATE_float
: printf ("(float)"); break;
2692 case DW_ATE_signed
: printf ("(signed)"); break;
2693 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2694 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2695 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2696 /* DWARF 2.1 values: */
2697 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2698 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2699 /* DWARF 3 values: */
2700 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2701 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2702 case DW_ATE_edited
: printf ("(edited)"); break;
2703 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2704 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2705 /* DWARF 4 values: */
2706 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2707 /* DWARF 5 values: */
2708 case DW_ATE_UCS
: printf ("(UCS)"); break;
2709 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2711 /* HP extensions: */
2712 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2713 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2714 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2715 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2716 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2717 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2718 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2721 if (uvalue
>= DW_ATE_lo_user
2722 && uvalue
<= DW_ATE_hi_user
)
2723 printf (_("(user defined type)"));
2725 printf (_("(unknown type)"));
2730 case DW_AT_accessibility
:
2734 case DW_ACCESS_public
: printf ("(public)"); break;
2735 case DW_ACCESS_protected
: printf ("(protected)"); break;
2736 case DW_ACCESS_private
: printf ("(private)"); break;
2738 printf (_("(unknown accessibility)"));
2743 case DW_AT_visibility
:
2747 case DW_VIS_local
: printf ("(local)"); break;
2748 case DW_VIS_exported
: printf ("(exported)"); break;
2749 case DW_VIS_qualified
: printf ("(qualified)"); break;
2750 default: printf (_("(unknown visibility)")); break;
2754 case DW_AT_endianity
:
2758 case DW_END_default
: printf ("(default)"); break;
2759 case DW_END_big
: printf ("(big)"); break;
2760 case DW_END_little
: printf ("(little)"); break;
2762 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2763 printf (_("(user specified)"));
2765 printf (_("(unknown endianity)"));
2770 case DW_AT_virtuality
:
2774 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2775 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2776 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2777 default: printf (_("(unknown virtuality)")); break;
2781 case DW_AT_identifier_case
:
2785 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2786 case DW_ID_up_case
: printf ("(up_case)"); break;
2787 case DW_ID_down_case
: printf ("(down_case)"); break;
2788 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2789 default: printf (_("(unknown case)")); break;
2793 case DW_AT_calling_convention
:
2797 case DW_CC_normal
: printf ("(normal)"); break;
2798 case DW_CC_program
: printf ("(program)"); break;
2799 case DW_CC_nocall
: printf ("(nocall)"); break;
2800 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2801 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2802 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2803 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2805 if (uvalue
>= DW_CC_lo_user
2806 && uvalue
<= DW_CC_hi_user
)
2807 printf (_("(user defined)"));
2809 printf (_("(unknown convention)"));
2813 case DW_AT_ordering
:
2818 case -1: printf (_("(undefined)")); break;
2819 case 0: printf ("(row major)"); break;
2820 case 1: printf ("(column major)"); break;
2824 case DW_AT_decimal_sign
:
2828 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2829 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2830 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2831 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2832 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2833 default: printf (_("(unrecognised)")); break;
2837 case DW_AT_defaulted
:
2841 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2842 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2843 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2844 default: printf (_("(unrecognised)")); break;
2848 case DW_AT_discr_list
:
2850 display_discr_list (form
, uvalue
, data
, end
, level
);
2853 case DW_AT_frame_base
:
2854 have_frame_base
= 1;
2856 case DW_AT_location
:
2857 case DW_AT_string_length
:
2858 case DW_AT_return_addr
:
2859 case DW_AT_data_member_location
:
2860 case DW_AT_vtable_elem_location
:
2862 case DW_AT_static_link
:
2863 case DW_AT_use_location
:
2864 case DW_AT_call_value
:
2865 case DW_AT_GNU_call_site_value
:
2866 case DW_AT_call_data_value
:
2867 case DW_AT_GNU_call_site_data_value
:
2868 case DW_AT_call_target
:
2869 case DW_AT_GNU_call_site_target
:
2870 case DW_AT_call_target_clobbered
:
2871 case DW_AT_GNU_call_site_target_clobbered
:
2872 if ((dwarf_version
< 4
2873 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2874 || form
== DW_FORM_sec_offset
)
2875 printf (_(" (location list)"));
2877 case DW_AT_allocated
:
2878 case DW_AT_associated
:
2879 case DW_AT_data_location
:
2881 case DW_AT_upper_bound
:
2882 case DW_AT_lower_bound
:
2885 int need_frame_base
;
2888 need_frame_base
= decode_location_expression (block_start
,
2893 cu_offset
, section
);
2895 if (need_frame_base
&& !have_frame_base
)
2896 printf (_(" [without DW_AT_frame_base]"));
2900 case DW_AT_data_bit_offset
:
2901 case DW_AT_byte_size
:
2902 case DW_AT_bit_size
:
2903 case DW_AT_string_length_byte_size
:
2904 case DW_AT_string_length_bit_size
:
2905 case DW_AT_bit_stride
:
2906 if (form
== DW_FORM_exprloc
)
2909 (void) decode_location_expression (block_start
, pointer_size
,
2910 offset_size
, dwarf_version
,
2911 uvalue
, cu_offset
, section
);
2918 if (form
== DW_FORM_ref_sig8
2919 || form
== DW_FORM_GNU_ref_alt
)
2922 if (form
== DW_FORM_ref1
2923 || form
== DW_FORM_ref2
2924 || form
== DW_FORM_ref4
2925 || form
== DW_FORM_ref_udata
)
2926 uvalue
+= cu_offset
;
2928 if (uvalue
>= section
->size
)
2929 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2930 dwarf_vmatoa ("x", uvalue
),
2931 (unsigned long) (orig_data
- section
->start
));
2934 unsigned long abbrev_number
;
2935 abbrev_entry
*entry
;
2936 unsigned char *p
= section
->start
+ uvalue
;
2938 READ_ULEB (abbrev_number
, p
, end
);
2940 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2941 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2942 use different abbrev table, and we don't track .debug_info chunks
2944 if (form
!= DW_FORM_ref_addr
)
2946 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2947 if (entry
->entry
== abbrev_number
)
2950 printf (" (%s)", get_TAG_name (entry
->tag
));
2964 static unsigned char *
2965 read_and_display_attr (unsigned long attribute
,
2967 dwarf_signed_vma implicit_const
,
2968 unsigned char * start
,
2969 unsigned char * data
,
2970 unsigned char * end
,
2971 dwarf_vma cu_offset
,
2972 dwarf_vma pointer_size
,
2973 dwarf_vma offset_size
,
2975 debug_info
* debug_info_p
,
2977 struct dwarf_section
* section
,
2978 struct cu_tu_set
* this_set
,
2982 printf (" %-18s:", get_AT_name (attribute
));
2983 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
2985 cu_offset
, pointer_size
, offset_size
,
2986 dwarf_version
, debug_info_p
,
2987 do_loc
, section
, this_set
, ' ', level
);
2993 /* Like load_debug_section, but if the ordinary call fails, and we are
2994 following debug links, then attempt to load the requested section
2995 from one of the separate debug info files. */
2998 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3001 if (load_debug_section (sec_enum
, handle
))
3003 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3005 /* See if we can associate a filename with this section. */
3008 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3009 if (i
->handle
== handle
)
3011 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3019 if (do_follow_links
)
3023 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3025 if (load_debug_section (sec_enum
, i
->handle
))
3027 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3029 /* FIXME: We should check to see if any of the remaining debug info
3030 files also contain this section, and, umm, do something about it. */
3040 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
3044 if (do_follow_links
&& section
->filename
)
3045 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3046 section
->name
, section
->filename
);
3048 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3052 if (do_follow_links
&& section
->filename
)
3053 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3054 section
->name
, section
->filename
);
3056 printf (_("Contents of the %s section:\n\n"), section
->name
);
3060 /* Process the contents of a .debug_info section.
3061 If do_loc is TRUE then we are scanning for location lists and dwo tags
3062 and we do not want to display anything to the user.
3063 If do_types is TRUE, we are processing a .debug_types section instead of
3064 a .debug_info section.
3065 The information displayed is restricted by the values in DWARF_START_DIE
3066 and DWARF_CUTOFF_LEVEL.
3067 Returns TRUE upon success. Otherwise an error or warning message is
3068 printed and FALSE is returned. */
3071 process_debug_info (struct dwarf_section
* section
,
3073 enum dwarf_section_display_enum abbrev_sec
,
3075 bfd_boolean do_types
)
3077 unsigned char *start
= section
->start
;
3078 unsigned char *end
= start
+ section
->size
;
3079 unsigned char *section_begin
;
3081 unsigned int num_units
= 0;
3083 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3084 && num_debug_info_entries
== 0
3089 /* First scan the section to get the number of comp units. */
3090 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3093 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3094 will be the length. For a 64-bit DWARF section, it'll be
3095 the escape code 0xffffffff followed by an 8 byte length. */
3096 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
3098 if (length
== 0xffffffff)
3100 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
3101 section_begin
+= length
+ 12;
3103 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3105 warn (_("Reserved length value (0x%s) found in section %s\n"),
3106 dwarf_vmatoa ("x", length
), section
->name
);
3110 section_begin
+= length
+ 4;
3112 /* Negative values are illegal, they may even cause infinite
3113 looping. This can happen if we can't accurately apply
3114 relocations to an object file, or if the file is corrupt. */
3115 if ((signed long) length
<= 0 || section_begin
< start
)
3117 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3118 dwarf_vmatoa ("x", length
), section
->name
);
3125 error (_("No comp units in %s section ?\n"), section
->name
);
3129 /* Then allocate an array to hold the information. */
3130 debug_information
= (debug_info
*) cmalloc (num_units
,
3131 sizeof (* debug_information
));
3132 if (debug_information
== NULL
)
3134 error (_("Not enough memory for a debug info array of %u entries\n"),
3136 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3140 /* PR 17531: file: 92ca3797.
3141 We cannot rely upon the debug_information array being initialised
3142 before it is used. A corrupt file could easily contain references
3143 to a unit for which information has not been made available. So
3144 we ensure that the array is zeroed here. */
3145 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3147 alloc_num_debug_info_entries
= num_units
;
3152 load_debug_section_with_follow (str
, file
);
3153 load_debug_section_with_follow (line_str
, file
);
3154 load_debug_section_with_follow (str_dwo
, file
);
3155 load_debug_section_with_follow (str_index
, file
);
3156 load_debug_section_with_follow (str_index_dwo
, file
);
3157 load_debug_section_with_follow (debug_addr
, file
);
3160 load_debug_section_with_follow (abbrev_sec
, file
);
3161 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3163 warn (_("Unable to locate %s section!\n"),
3164 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3168 if (!do_loc
&& dwarf_start_die
== 0)
3169 introduce (section
, FALSE
);
3171 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
3173 DWARF2_Internal_CompUnit compunit
;
3174 unsigned char *hdrptr
;
3175 unsigned char *tags
;
3176 int level
, last_level
, saved_level
;
3177 dwarf_vma cu_offset
;
3178 unsigned long sec_off
;
3179 unsigned int offset_size
;
3180 unsigned int initial_length_size
;
3181 dwarf_vma signature_high
= 0;
3182 dwarf_vma signature_low
= 0;
3183 dwarf_vma type_offset
= 0;
3184 struct cu_tu_set
*this_set
;
3185 dwarf_vma abbrev_base
;
3190 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3192 if (compunit
.cu_length
== 0xffffffff)
3194 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3196 initial_length_size
= 12;
3201 initial_length_size
= 4;
3204 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3206 cu_offset
= start
- section_begin
;
3208 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3210 if (compunit
.cu_version
< 5)
3212 compunit
.cu_unit_type
= DW_UT_compile
;
3213 /* Initialize it due to a false compiler warning. */
3214 compunit
.cu_pointer_size
= -1;
3218 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3219 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3221 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3224 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3226 if (this_set
== NULL
)
3229 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3233 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3234 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3237 if (compunit
.cu_version
< 5)
3238 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3240 /* PR 17512: file: 001-108546-0.001:0.1. */
3241 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3243 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3244 compunit
.cu_pointer_size
, offset_size
);
3245 compunit
.cu_pointer_size
= offset_size
;
3250 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
3252 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
3255 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
3256 + initial_length_size
))
3258 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3259 + initial_length_size
;
3263 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3264 && num_debug_info_entries
== 0
3267 debug_information
[unit
].cu_offset
= cu_offset
;
3268 debug_information
[unit
].pointer_size
3269 = compunit
.cu_pointer_size
;
3270 debug_information
[unit
].offset_size
= offset_size
;
3271 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3272 debug_information
[unit
].base_address
= 0;
3273 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3274 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3275 debug_information
[unit
].loc_offsets
= NULL
;
3276 debug_information
[unit
].have_frame_base
= NULL
;
3277 debug_information
[unit
].max_loc_offsets
= 0;
3278 debug_information
[unit
].num_loc_offsets
= 0;
3279 debug_information
[unit
].range_lists
= NULL
;
3280 debug_information
[unit
].max_range_lists
= 0;
3281 debug_information
[unit
].num_range_lists
= 0;
3284 if (!do_loc
&& dwarf_start_die
== 0)
3286 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3287 dwarf_vmatoa ("x", cu_offset
));
3288 printf (_(" Length: 0x%s (%s)\n"),
3289 dwarf_vmatoa ("x", compunit
.cu_length
),
3290 offset_size
== 8 ? "64-bit" : "32-bit");
3291 printf (_(" Version: %d\n"), compunit
.cu_version
);
3292 printf (_(" Abbrev Offset: 0x%s\n"),
3293 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3294 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3299 printf (_(" Signature: 0x%s\n"),
3300 dwarf_vmatoa64 (signature_high
, signature_low
,
3301 buf
, sizeof (buf
)));
3302 printf (_(" Type Offset: 0x%s\n"),
3303 dwarf_vmatoa ("x", type_offset
));
3305 if (this_set
!= NULL
)
3307 dwarf_vma
*offsets
= this_set
->section_offsets
;
3308 size_t *sizes
= this_set
->section_sizes
;
3310 printf (_(" Section contributions:\n"));
3311 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3312 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3313 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3314 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3315 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3316 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3317 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3318 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3319 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3320 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3321 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3322 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3326 sec_off
= cu_offset
+ initial_length_size
;
3327 if (sec_off
+ compunit
.cu_length
< sec_off
3328 || sec_off
+ compunit
.cu_length
> section
->size
)
3330 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3332 (unsigned long) cu_offset
,
3333 dwarf_vmatoa ("x", compunit
.cu_length
));
3339 start
+= compunit
.cu_length
+ initial_length_size
;
3341 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3343 warn (_("CU at offset %s contains corrupt or "
3344 "unsupported version number: %d.\n"),
3345 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3349 if (compunit
.cu_unit_type
!= DW_UT_compile
3350 && compunit
.cu_unit_type
!= DW_UT_type
)
3352 warn (_("CU at offset %s contains corrupt or "
3353 "unsupported unit type: %d.\n"),
3354 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3360 /* Process the abbrevs used by this compilation unit. */
3361 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3362 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3363 (unsigned long) compunit
.cu_abbrev_offset
,
3364 (unsigned long) abbrev_size
);
3365 /* PR 17531: file:4bcd9ce9. */
3366 else if ((abbrev_base
+ abbrev_size
)
3367 > debug_displays
[abbrev_sec
].section
.size
)
3368 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3369 (unsigned long) abbrev_base
+ abbrev_size
,
3370 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3372 process_abbrev_section
3373 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3374 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3375 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3376 + abbrev_base
+ abbrev_size
));
3381 while (tags
< start
)
3383 unsigned long abbrev_number
;
3384 unsigned long die_offset
;
3385 abbrev_entry
*entry
;
3387 int do_printing
= 1;
3389 die_offset
= tags
- section_begin
;
3391 READ_ULEB (abbrev_number
, tags
, start
);
3393 /* A null DIE marks the end of a list of siblings or it may also be
3394 a section padding. */
3395 if (abbrev_number
== 0)
3397 /* Check if it can be a section padding for the last CU. */
3398 if (level
== 0 && start
== end
)
3402 for (chk
= tags
; chk
< start
; chk
++)
3409 if (!do_loc
&& die_offset
>= dwarf_start_die
3410 && (dwarf_cutoff_level
== -1
3411 || level
< dwarf_cutoff_level
))
3412 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3418 static unsigned num_bogus_warns
= 0;
3420 if (num_bogus_warns
< 3)
3422 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3423 die_offset
, section
->name
);
3425 if (num_bogus_warns
== 3)
3426 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3429 if (dwarf_start_die
!= 0 && level
< saved_level
)
3436 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3440 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3441 saved_level
= level
;
3442 do_printing
= (dwarf_cutoff_level
== -1
3443 || level
< dwarf_cutoff_level
);
3445 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3446 level
, die_offset
, abbrev_number
);
3447 else if (dwarf_cutoff_level
== -1
3448 || last_level
< dwarf_cutoff_level
)
3449 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3454 /* Scan through the abbreviation list until we reach the
3456 for (entry
= first_abbrev
;
3457 entry
&& entry
->entry
!= abbrev_number
;
3458 entry
= entry
->next
)
3463 if (!do_loc
&& do_printing
)
3468 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3469 die_offset
, abbrev_number
);
3473 if (!do_loc
&& do_printing
)
3474 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3479 need_base_address
= 0;
3481 case DW_TAG_compile_unit
:
3482 need_base_address
= 1;
3483 need_dwo_info
= do_loc
;
3485 case DW_TAG_entry_point
:
3486 case DW_TAG_subprogram
:
3487 need_base_address
= 0;
3488 /* Assuming that there is no DW_AT_frame_base. */
3489 have_frame_base
= 0;
3493 debug_info
*debug_info_p
=
3494 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3495 ? debug_information
+ unit
: NULL
;
3497 assert (!debug_info_p
3498 || (debug_info_p
->num_loc_offsets
3499 == debug_info_p
->num_loc_views
));
3501 for (attr
= entry
->first_attr
;
3502 attr
&& attr
->attribute
;
3505 if (! do_loc
&& do_printing
)
3506 /* Show the offset from where the tag was extracted. */
3507 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3508 tags
= read_and_display_attr (attr
->attribute
,
3510 attr
->implicit_const
,
3515 compunit
.cu_pointer_size
,
3517 compunit
.cu_version
,
3519 do_loc
|| ! do_printing
,
3525 /* If a locview attribute appears before a location one,
3526 make sure we don't associate it with an earlier
3529 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3532 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3533 debug_info_p
->num_loc_views
++;
3534 assert (debug_info_p
->num_loc_views
3535 == debug_info_p
->num_loc_offsets
);
3542 warn(_("DIE has locviews without loclist\n"));
3543 debug_info_p
->num_loc_views
--;
3550 if (entry
->children
)
3555 /* Set num_debug_info_entries here so that it can be used to check if
3556 we need to process .debug_loc and .debug_ranges sections. */
3557 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3558 && num_debug_info_entries
== 0
3561 if (num_units
> alloc_num_debug_info_entries
)
3562 num_debug_info_entries
= alloc_num_debug_info_entries
;
3564 num_debug_info_entries
= num_units
;
3573 /* Locate and scan the .debug_info section in the file and record the pointer
3574 sizes and offsets for the compilation units in it. Usually an executable
3575 will have just one pointer size, but this is not guaranteed, and so we try
3576 not to make any assumptions. Returns zero upon failure, or the number of
3577 compilation units upon success. */
3580 load_debug_info (void * file
)
3582 /* If we have already tried and failed to load the .debug_info
3583 section then do not bother to repeat the task. */
3584 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3587 /* If we already have the information there is nothing else to do. */
3588 if (num_debug_info_entries
> 0)
3589 return num_debug_info_entries
;
3591 /* If this is a DWARF package file, load the CU and TU indexes. */
3592 (void) load_cu_tu_indexes (file
);
3594 if (load_debug_section_with_follow (info
, file
)
3595 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3596 return num_debug_info_entries
;
3598 if (load_debug_section_with_follow (info_dwo
, file
)
3599 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3600 abbrev_dwo
, TRUE
, FALSE
))
3601 return num_debug_info_entries
;
3603 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3607 /* Read a DWARF .debug_line section header starting at DATA.
3608 Upon success returns an updated DATA pointer and the LINFO
3609 structure and the END_OF_SEQUENCE pointer will be filled in.
3610 Otherwise returns NULL. */
3612 static unsigned char *
3613 read_debug_line_header (struct dwarf_section
* section
,
3614 unsigned char * data
,
3615 unsigned char * end
,
3616 DWARF2_Internal_LineInfo
* linfo
,
3617 unsigned char ** end_of_sequence
)
3619 unsigned char *hdrptr
;
3620 unsigned int initial_length_size
;
3621 unsigned char address_size
, segment_selector_size
;
3623 /* Extract information from the Line Number Program Header.
3624 (section 6.2.4 in the Dwarf3 doc). */
3627 /* Get and check the length of the block. */
3628 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3630 if (linfo
->li_length
== 0xffffffff)
3632 /* This section is 64-bit DWARF 3. */
3633 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3634 linfo
->li_offset_size
= 8;
3635 initial_length_size
= 12;
3639 linfo
->li_offset_size
= 4;
3640 initial_length_size
= 4;
3643 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3645 /* If the length field has a relocation against it, then we should
3646 not complain if it is inaccurate (and probably negative). This
3647 happens in object files when the .debug_line section is actually
3648 comprised of several different .debug_line.* sections, (some of
3649 which may be removed by linker garbage collection), and a relocation
3650 is used to compute the correct length once that is done. */
3651 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3653 linfo
->li_length
= (end
- data
) - initial_length_size
;
3657 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3658 (long) linfo
->li_length
);
3663 /* Get and check the version number. */
3664 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3666 if (linfo
->li_version
!= 2
3667 && linfo
->li_version
!= 3
3668 && linfo
->li_version
!= 4
3669 && linfo
->li_version
!= 5)
3671 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3672 "is currently supported.\n"));
3676 if (linfo
->li_version
>= 5)
3678 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
3680 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
3681 if (segment_selector_size
!= 0)
3683 warn (_("The %s section contains "
3684 "unsupported segment selector size: %d.\n"),
3685 section
->name
, segment_selector_size
);
3690 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3691 linfo
->li_offset_size
, end
);
3692 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3694 if (linfo
->li_version
>= 4)
3696 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3698 if (linfo
->li_max_ops_per_insn
== 0)
3700 warn (_("Invalid maximum operations per insn.\n"));
3705 linfo
->li_max_ops_per_insn
= 1;
3707 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3708 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3709 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3710 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3712 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3713 /* PR 17512: file:002-117414-0.004. */
3714 if (* end_of_sequence
> end
)
3716 warn (_("Line length %s extends beyond end of section\n"),
3717 dwarf_vmatoa ("u", linfo
->li_length
));
3718 * end_of_sequence
= end
;
3725 static unsigned char *
3726 display_formatted_table (unsigned char * data
,
3727 unsigned char * start
,
3728 unsigned char * end
,
3729 const DWARF2_Internal_LineInfo
* linfo
,
3730 struct dwarf_section
* section
,
3733 unsigned char *format_start
, format_count
, *format
, formati
;
3734 dwarf_vma data_count
, datai
;
3735 unsigned int namepass
, last_entry
= 0;
3737 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3738 format_start
= data
;
3739 for (formati
= 0; formati
< format_count
; formati
++)
3741 SKIP_ULEB (data
, end
);
3742 SKIP_ULEB (data
, end
);
3746 warn (_("Corrupt directory format table entry\n"));
3748 warn (_("Corrupt file name format table entry\n"));
3753 READ_ULEB (data_count
, data
, end
);
3757 warn (_("Corrupt directory list\n"));
3759 warn (_("Corrupt file name list\n"));
3763 if (data_count
== 0)
3766 printf (_("\n The Directory Table is empty.\n"));
3768 printf (_("\n The File Name Table is empty.\n"));
3773 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3774 (long) (data
- start
));
3776 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3777 (long) (data
- start
));
3779 printf (_(" Entry"));
3780 /* Delay displaying name as the last entry for better screen layout. */
3781 for (namepass
= 0; namepass
< 2; namepass
++)
3783 format
= format_start
;
3784 for (formati
= 0; formati
< format_count
; formati
++)
3786 dwarf_vma content_type
;
3788 READ_ULEB (content_type
, format
, end
);
3789 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3790 switch (content_type
)
3793 printf (_("\tName"));
3795 case DW_LNCT_directory_index
:
3796 printf (_("\tDir"));
3798 case DW_LNCT_timestamp
:
3799 printf (_("\tTime"));
3802 printf (_("\tSize"));
3805 printf (_("\tMD5"));
3808 printf (_("\t(Unknown format content type %s)"),
3809 dwarf_vmatoa ("u", content_type
));
3811 SKIP_ULEB (format
, end
);
3816 for (datai
= 0; datai
< data_count
; datai
++)
3818 unsigned char *datapass
= data
;
3820 printf (" %d", last_entry
++);
3821 /* Delay displaying name as the last entry for better screen layout. */
3822 for (namepass
= 0; namepass
< 2; namepass
++)
3824 format
= format_start
;
3826 for (formati
= 0; formati
< format_count
; formati
++)
3828 dwarf_vma content_type
, form
;
3830 READ_ULEB (content_type
, format
, end
);
3831 READ_ULEB (form
, format
, end
);
3832 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
3833 0, 0, linfo
->li_offset_size
,
3834 linfo
->li_version
, NULL
,
3835 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3836 section
, NULL
, '\t', -1);
3842 warn (_("Corrupt directory entries list\n"));
3844 warn (_("Corrupt file name entries list\n"));
3853 display_debug_lines_raw (struct dwarf_section
* section
,
3854 unsigned char * data
,
3855 unsigned char * end
,
3858 unsigned char *start
= section
->start
;
3859 int verbose_view
= 0;
3861 introduce (section
, TRUE
);
3865 static DWARF2_Internal_LineInfo saved_linfo
;
3866 DWARF2_Internal_LineInfo linfo
;
3867 unsigned char *standard_opcodes
;
3868 unsigned char *end_of_sequence
;
3871 if (const_strneq (section
->name
, ".debug_line.")
3872 /* Note: the following does not apply to .debug_line.dwo sections.
3873 These are full debug_line sections. */
3874 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3876 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3877 section containing just the Line Number Statements. They are
3878 created by the assembler and intended to be used alongside gcc's
3879 -ffunction-sections command line option. When the linker's
3880 garbage collection decides to discard a .text.<foo> section it
3881 can then also discard the line number information in .debug_line.<foo>.
3883 Since the section is a fragment it does not have the details
3884 needed to fill out a LineInfo structure, so instead we use the
3885 details from the last full debug_line section that we processed. */
3886 end_of_sequence
= end
;
3887 standard_opcodes
= NULL
;
3888 linfo
= saved_linfo
;
3889 /* PR 17531: file: 0522b371. */
3890 if (linfo
.li_line_range
== 0)
3892 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3895 reset_state_machine (linfo
.li_default_is_stmt
);
3899 unsigned char * hdrptr
;
3901 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3902 & end_of_sequence
)) == NULL
)
3905 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3906 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3907 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3908 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3909 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3910 if (linfo
.li_version
>= 4)
3911 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3912 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3913 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3914 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3915 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3917 /* PR 17512: file: 1665-6428-0.004. */
3918 if (linfo
.li_line_range
== 0)
3920 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3921 linfo
.li_line_range
= 1;
3924 reset_state_machine (linfo
.li_default_is_stmt
);
3926 /* Display the contents of the Opcodes table. */
3927 standard_opcodes
= hdrptr
;
3929 /* PR 17512: file: 002-417945-0.004. */
3930 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3932 warn (_("Line Base extends beyond end of section\n"));
3936 printf (_("\n Opcodes:\n"));
3938 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3939 printf (ngettext (" Opcode %d has %d arg\n",
3940 " Opcode %d has %d args\n",
3941 standard_opcodes
[i
- 1]),
3942 i
, standard_opcodes
[i
- 1]);
3944 /* Display the contents of the Directory table. */
3945 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3947 if (linfo
.li_version
>= 5)
3949 load_debug_section_with_follow (line_str
, file
);
3951 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3953 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3959 printf (_("\n The Directory Table is empty.\n"));
3962 unsigned int last_dir_entry
= 0;
3964 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3965 (long)(data
- start
));
3967 while (data
< end
&& *data
!= 0)
3969 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
3971 data
+= strnlen ((char *) data
, end
- data
) + 1;
3974 /* PR 17512: file: 002-132094-0.004. */
3975 if (data
>= end
- 1)
3979 /* Skip the NUL at the end of the table. */
3982 /* Display the contents of the File Name table. */
3984 printf (_("\n The File Name Table is empty.\n"));
3987 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3988 (long)(data
- start
));
3989 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3991 while (data
< end
&& *data
!= 0)
3993 unsigned char *name
;
3996 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
3998 data
+= strnlen ((char *) data
, end
- data
) + 1;
4000 READ_ULEB (val
, data
, end
);
4001 printf ("%s\t", dwarf_vmatoa ("u", val
));
4002 READ_ULEB (val
, data
, end
);
4003 printf ("%s\t", dwarf_vmatoa ("u", val
));
4004 READ_ULEB (val
, data
, end
);
4005 printf ("%s\t", dwarf_vmatoa ("u", val
));
4006 printf ("%.*s\n", (int)(end
- name
), name
);
4010 warn (_("Corrupt file name table entry\n"));
4016 /* Skip the NUL at the end of the table. */
4021 saved_linfo
= linfo
;
4024 /* Now display the statements. */
4025 if (data
>= end_of_sequence
)
4026 printf (_(" No Line Number Statements.\n"));
4029 printf (_(" Line Number Statements:\n"));
4031 while (data
< end_of_sequence
)
4033 unsigned char op_code
;
4034 dwarf_signed_vma adv
;
4037 printf (" [0x%08lx]", (long)(data
- start
));
4041 if (op_code
>= linfo
.li_opcode_base
)
4043 op_code
-= linfo
.li_opcode_base
;
4044 uladv
= (op_code
/ linfo
.li_line_range
);
4045 if (linfo
.li_max_ops_per_insn
== 1)
4047 uladv
*= linfo
.li_min_insn_length
;
4048 state_machine_regs
.address
+= uladv
;
4050 state_machine_regs
.view
= 0;
4051 printf (_(" Special opcode %d: "
4052 "advance Address by %s to 0x%s%s"),
4053 op_code
, dwarf_vmatoa ("u", uladv
),
4054 dwarf_vmatoa ("x", state_machine_regs
.address
),
4055 verbose_view
&& uladv
4056 ? _(" (reset view)") : "");
4061 = ((state_machine_regs
.op_index
+ uladv
)
4062 / linfo
.li_max_ops_per_insn
)
4063 * linfo
.li_min_insn_length
;
4065 state_machine_regs
.address
+= addrdelta
;
4066 state_machine_regs
.op_index
4067 = (state_machine_regs
.op_index
+ uladv
)
4068 % linfo
.li_max_ops_per_insn
;
4070 state_machine_regs
.view
= 0;
4071 printf (_(" Special opcode %d: "
4072 "advance Address by %s to 0x%s[%d]%s"),
4073 op_code
, dwarf_vmatoa ("u", uladv
),
4074 dwarf_vmatoa ("x", state_machine_regs
.address
),
4075 state_machine_regs
.op_index
,
4076 verbose_view
&& addrdelta
4077 ? _(" (reset view)") : "");
4079 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4080 state_machine_regs
.line
+= adv
;
4081 printf (_(" and Line by %s to %d"),
4082 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4083 if (verbose_view
|| state_machine_regs
.view
)
4084 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4087 state_machine_regs
.view
++;
4092 case DW_LNS_extended_op
:
4093 data
+= process_extended_line_op (data
,
4094 linfo
.li_default_is_stmt
,
4099 printf (_(" Copy"));
4100 if (verbose_view
|| state_machine_regs
.view
)
4101 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4104 state_machine_regs
.view
++;
4107 case DW_LNS_advance_pc
:
4108 READ_ULEB (uladv
, data
, end
);
4109 if (linfo
.li_max_ops_per_insn
== 1)
4111 uladv
*= linfo
.li_min_insn_length
;
4112 state_machine_regs
.address
+= uladv
;
4114 state_machine_regs
.view
= 0;
4115 printf (_(" Advance PC by %s to 0x%s%s\n"),
4116 dwarf_vmatoa ("u", uladv
),
4117 dwarf_vmatoa ("x", state_machine_regs
.address
),
4118 verbose_view
&& uladv
4119 ? _(" (reset view)") : "");
4124 = ((state_machine_regs
.op_index
+ uladv
)
4125 / linfo
.li_max_ops_per_insn
)
4126 * linfo
.li_min_insn_length
;
4127 state_machine_regs
.address
4129 state_machine_regs
.op_index
4130 = (state_machine_regs
.op_index
+ uladv
)
4131 % linfo
.li_max_ops_per_insn
;
4133 state_machine_regs
.view
= 0;
4134 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4135 dwarf_vmatoa ("u", uladv
),
4136 dwarf_vmatoa ("x", state_machine_regs
.address
),
4137 state_machine_regs
.op_index
,
4138 verbose_view
&& addrdelta
4139 ? _(" (reset view)") : "");
4143 case DW_LNS_advance_line
:
4144 READ_SLEB (adv
, data
, end
);
4145 state_machine_regs
.line
+= adv
;
4146 printf (_(" Advance Line by %s to %d\n"),
4147 dwarf_vmatoa ("d", adv
),
4148 state_machine_regs
.line
);
4151 case DW_LNS_set_file
:
4152 READ_ULEB (uladv
, data
, end
);
4153 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4154 dwarf_vmatoa ("u", uladv
));
4155 state_machine_regs
.file
= uladv
;
4158 case DW_LNS_set_column
:
4159 READ_ULEB (uladv
, data
, end
);
4160 printf (_(" Set column to %s\n"),
4161 dwarf_vmatoa ("u", uladv
));
4162 state_machine_regs
.column
= uladv
;
4165 case DW_LNS_negate_stmt
:
4166 adv
= state_machine_regs
.is_stmt
;
4168 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4169 state_machine_regs
.is_stmt
= adv
;
4172 case DW_LNS_set_basic_block
:
4173 printf (_(" Set basic block\n"));
4174 state_machine_regs
.basic_block
= 1;
4177 case DW_LNS_const_add_pc
:
4178 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4179 if (linfo
.li_max_ops_per_insn
)
4181 uladv
*= linfo
.li_min_insn_length
;
4182 state_machine_regs
.address
+= uladv
;
4184 state_machine_regs
.view
= 0;
4185 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4186 dwarf_vmatoa ("u", uladv
),
4187 dwarf_vmatoa ("x", state_machine_regs
.address
),
4188 verbose_view
&& uladv
4189 ? _(" (reset view)") : "");
4194 = ((state_machine_regs
.op_index
+ uladv
)
4195 / linfo
.li_max_ops_per_insn
)
4196 * linfo
.li_min_insn_length
;
4197 state_machine_regs
.address
4199 state_machine_regs
.op_index
4200 = (state_machine_regs
.op_index
+ uladv
)
4201 % linfo
.li_max_ops_per_insn
;
4203 state_machine_regs
.view
= 0;
4204 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4205 dwarf_vmatoa ("u", uladv
),
4206 dwarf_vmatoa ("x", state_machine_regs
.address
),
4207 state_machine_regs
.op_index
,
4208 verbose_view
&& addrdelta
4209 ? _(" (reset view)") : "");
4213 case DW_LNS_fixed_advance_pc
:
4214 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4215 state_machine_regs
.address
+= uladv
;
4216 state_machine_regs
.op_index
= 0;
4217 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4218 dwarf_vmatoa ("u", uladv
),
4219 dwarf_vmatoa ("x", state_machine_regs
.address
));
4220 /* Do NOT reset view. */
4223 case DW_LNS_set_prologue_end
:
4224 printf (_(" Set prologue_end to true\n"));
4227 case DW_LNS_set_epilogue_begin
:
4228 printf (_(" Set epilogue_begin to true\n"));
4231 case DW_LNS_set_isa
:
4232 READ_ULEB (uladv
, data
, end
);
4233 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4237 printf (_(" Unknown opcode %d with operands: "), op_code
);
4239 if (standard_opcodes
!= NULL
)
4240 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4242 READ_ULEB (uladv
, data
, end
);
4243 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4244 i
== 1 ? "" : ", ");
4259 unsigned char *name
;
4260 unsigned int directory_index
;
4261 unsigned int modification_date
;
4262 unsigned int length
;
4265 /* Output a decoded representation of the .debug_line section. */
4268 display_debug_lines_decoded (struct dwarf_section
* section
,
4269 unsigned char * start
,
4270 unsigned char * data
,
4271 unsigned char * end
,
4274 static DWARF2_Internal_LineInfo saved_linfo
;
4276 introduce (section
, FALSE
);
4280 /* This loop amounts to one iteration per compilation unit. */
4281 DWARF2_Internal_LineInfo linfo
;
4282 unsigned char *standard_opcodes
;
4283 unsigned char *end_of_sequence
;
4285 File_Entry
*file_table
= NULL
;
4286 unsigned int n_files
= 0;
4287 unsigned char **directory_table
= NULL
;
4288 dwarf_vma n_directories
= 0;
4290 if (const_strneq (section
->name
, ".debug_line.")
4291 /* Note: the following does not apply to .debug_line.dwo sections.
4292 These are full debug_line sections. */
4293 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4295 /* See comment in display_debug_lines_raw(). */
4296 end_of_sequence
= end
;
4297 standard_opcodes
= NULL
;
4298 linfo
= saved_linfo
;
4299 /* PR 17531: file: 0522b371. */
4300 if (linfo
.li_line_range
== 0)
4302 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4305 reset_state_machine (linfo
.li_default_is_stmt
);
4309 unsigned char *hdrptr
;
4311 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4312 & end_of_sequence
)) == NULL
)
4315 /* PR 17531: file: 0522b371. */
4316 if (linfo
.li_line_range
== 0)
4318 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4319 linfo
.li_line_range
= 1;
4321 reset_state_machine (linfo
.li_default_is_stmt
);
4323 /* Save a pointer to the contents of the Opcodes table. */
4324 standard_opcodes
= hdrptr
;
4326 /* Traverse the Directory table just to count entries. */
4327 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4331 warn (_("opcode base of %d extends beyond end of section\n"),
4332 linfo
.li_opcode_base
);
4336 if (linfo
.li_version
>= 5)
4338 unsigned char *format_start
, format_count
, *format
;
4339 dwarf_vma formati
, entryi
;
4341 load_debug_section_with_follow (line_str
, fileptr
);
4343 /* Skip directories format. */
4344 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4345 format_start
= data
;
4346 for (formati
= 0; formati
< format_count
; formati
++)
4348 SKIP_ULEB (data
, end
);
4349 SKIP_ULEB (data
, end
);
4352 READ_ULEB (n_directories
, data
, end
);
4355 warn (_("Corrupt directories list\n"));
4359 directory_table
= (unsigned char **)
4360 xmalloc (n_directories
* sizeof (unsigned char *));
4362 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4364 unsigned char **pathp
= &directory_table
[entryi
];
4366 format
= format_start
;
4367 for (formati
= 0; formati
< format_count
; formati
++)
4369 dwarf_vma content_type
, form
;
4372 READ_ULEB (content_type
, format
, end
);
4373 READ_ULEB (form
, format
, end
);
4376 warn (_("Corrupt directories list\n"));
4379 switch (content_type
)
4384 case DW_FORM_string
:
4387 case DW_FORM_line_strp
:
4388 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4390 /* Remove const by the cast. */
4391 *pathp
= (unsigned char *)
4392 fetch_indirect_line_string (uvalue
);
4397 data
= read_and_display_attr_value (0, form
, 0, start
,
4399 linfo
.li_offset_size
,
4406 warn (_("Corrupt directories list\n"));
4411 /* Skip files format. */
4412 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4413 format_start
= data
;
4414 for (formati
= 0; formati
< format_count
; formati
++)
4416 SKIP_ULEB (data
, end
);
4417 SKIP_ULEB (data
, end
);
4420 READ_ULEB (n_files
, data
, end
);
4423 warn (_("Corrupt file name list\n"));
4427 file_table
= (File_Entry
*) xcalloc (1, n_files
4428 * sizeof (File_Entry
));
4430 for (entryi
= 0; entryi
< n_files
; entryi
++)
4432 File_Entry
*file
= &file_table
[entryi
];
4434 format
= format_start
;
4435 for (formati
= 0; formati
< format_count
; formati
++)
4437 dwarf_vma content_type
, form
;
4441 READ_ULEB (content_type
, format
, end
);
4442 READ_ULEB (form
, format
, end
);
4445 warn (_("Corrupt file name list\n"));
4448 switch (content_type
)
4453 case DW_FORM_string
:
4456 case DW_FORM_line_strp
:
4457 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4459 /* Remove const by the cast. */
4460 file
->name
= (unsigned char *)
4461 fetch_indirect_line_string (uvalue
);
4465 case DW_LNCT_directory_index
:
4469 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4473 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4478 READ_ULEB (file
->directory_index
, tmp
, end
);
4483 data
= read_and_display_attr_value (0, form
, 0, start
,
4485 linfo
.li_offset_size
,
4492 warn (_("Corrupt file name list\n"));
4501 unsigned char *ptr_directory_table
= data
;
4503 while (data
< end
&& *data
!= 0)
4505 data
+= strnlen ((char *) data
, end
- data
) + 1;
4512 warn (_("directory table ends unexpectedly\n"));
4517 /* Go through the directory table again to save the directories. */
4518 directory_table
= (unsigned char **)
4519 xmalloc (n_directories
* sizeof (unsigned char *));
4522 while (*ptr_directory_table
!= 0)
4524 directory_table
[i
] = ptr_directory_table
;
4525 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4526 ptr_directory_table
- end
) + 1;
4530 /* Skip the NUL at the end of the table. */
4533 /* Traverse the File Name table just to count the entries. */
4534 if (data
< end
&& *data
!= 0)
4536 unsigned char *ptr_file_name_table
= data
;
4538 while (data
< end
&& *data
!= 0)
4540 /* Skip Name, directory index, last modification
4541 time and length of file. */
4542 data
+= strnlen ((char *) data
, end
- data
) + 1;
4543 SKIP_ULEB (data
, end
);
4544 SKIP_ULEB (data
, end
);
4545 SKIP_ULEB (data
, end
);
4551 warn (_("file table ends unexpectedly\n"));
4556 /* Go through the file table again to save the strings. */
4557 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4560 while (*ptr_file_name_table
!= 0)
4562 file_table
[i
].name
= ptr_file_name_table
;
4563 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4564 end
- ptr_file_name_table
) + 1;
4566 /* We are not interested in directory, time or size. */
4567 READ_ULEB (file_table
[i
].directory_index
,
4568 ptr_file_name_table
, end
);
4569 READ_ULEB (file_table
[i
].modification_date
,
4570 ptr_file_name_table
, end
);
4571 READ_ULEB (file_table
[i
].length
,
4572 ptr_file_name_table
, end
);
4578 /* Skip the NUL at the end of the table. */
4582 /* Print the Compilation Unit's name and a header. */
4583 if (file_table
== NULL
)
4585 else if (directory_table
== NULL
)
4586 printf (_("CU: %s:\n"), file_table
[0].name
);
4589 unsigned int ix
= file_table
[0].directory_index
;
4590 const char *directory
;
4595 else if (n_directories
== 0)
4596 directory
= _("<unknown>");
4597 else if (ix
> n_directories
)
4599 warn (_("directory index %u > number of directories %s\n"),
4600 ix
, dwarf_vmatoa ("u", n_directories
));
4601 directory
= _("<corrupt>");
4604 directory
= (char *) directory_table
[ix
- 1];
4606 if (do_wide
|| strlen (directory
) < 76)
4607 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4609 printf ("%s:\n", file_table
[0].name
);
4612 printf (_("File name Line number Starting address View Stmt\n"));
4613 saved_linfo
= linfo
;
4616 /* This loop iterates through the Dwarf Line Number Program. */
4617 while (data
< end_of_sequence
)
4619 unsigned char op_code
;
4622 unsigned long int uladv
;
4623 int is_special_opcode
= 0;
4628 if (op_code
>= linfo
.li_opcode_base
)
4630 op_code
-= linfo
.li_opcode_base
;
4631 uladv
= (op_code
/ linfo
.li_line_range
);
4632 if (linfo
.li_max_ops_per_insn
== 1)
4634 uladv
*= linfo
.li_min_insn_length
;
4635 state_machine_regs
.address
+= uladv
;
4637 state_machine_regs
.view
= 0;
4642 = ((state_machine_regs
.op_index
+ uladv
)
4643 / linfo
.li_max_ops_per_insn
)
4644 * linfo
.li_min_insn_length
;
4645 state_machine_regs
.address
4647 state_machine_regs
.op_index
4648 = (state_machine_regs
.op_index
+ uladv
)
4649 % linfo
.li_max_ops_per_insn
;
4651 state_machine_regs
.view
= 0;
4654 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4655 state_machine_regs
.line
+= adv
;
4656 is_special_opcode
= 1;
4657 /* Increment view after printing this row. */
4662 case DW_LNS_extended_op
:
4664 unsigned int ext_op_code_len
;
4665 unsigned char ext_op_code
;
4666 unsigned char *op_code_end
;
4667 unsigned char *op_code_data
= data
;
4669 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
4670 op_code_end
= op_code_data
+ ext_op_code_len
;
4671 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
4673 warn (_("Badly formed extended line op encountered!\n"));
4676 ext_op_code
= *op_code_data
++;
4680 switch (ext_op_code
)
4682 case DW_LNE_end_sequence
:
4683 /* Reset stuff after printing this row. */
4685 case DW_LNE_set_address
:
4686 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4688 op_code_end
- op_code_data
,
4690 state_machine_regs
.op_index
= 0;
4691 state_machine_regs
.view
= 0;
4693 case DW_LNE_define_file
:
4694 file_table
= (File_Entry
*) xrealloc
4695 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4697 ++state_machine_regs
.last_file_entry
;
4698 /* Source file name. */
4699 file_table
[n_files
].name
= op_code_data
;
4700 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4701 /* Directory index. */
4702 READ_ULEB (file_table
[n_files
].directory_index
,
4703 op_code_data
, op_code_end
);
4704 /* Last modification time. */
4705 READ_ULEB (file_table
[n_files
].modification_date
,
4706 op_code_data
, op_code_end
);
4708 READ_ULEB (file_table
[n_files
].length
,
4709 op_code_data
, op_code_end
);
4713 case DW_LNE_set_discriminator
:
4714 case DW_LNE_HP_set_sequence
:
4715 /* Simply ignored. */
4719 printf (_("UNKNOWN (%u): length %ld\n"),
4720 ext_op_code
, (long int) (op_code_data
- data
));
4727 /* Increment view after printing this row. */
4730 case DW_LNS_advance_pc
:
4731 READ_ULEB (uladv
, data
, end
);
4732 if (linfo
.li_max_ops_per_insn
== 1)
4734 uladv
*= linfo
.li_min_insn_length
;
4735 state_machine_regs
.address
+= uladv
;
4737 state_machine_regs
.view
= 0;
4742 = ((state_machine_regs
.op_index
+ uladv
)
4743 / linfo
.li_max_ops_per_insn
)
4744 * linfo
.li_min_insn_length
;
4745 state_machine_regs
.address
4747 state_machine_regs
.op_index
4748 = (state_machine_regs
.op_index
+ uladv
)
4749 % linfo
.li_max_ops_per_insn
;
4751 state_machine_regs
.view
= 0;
4755 case DW_LNS_advance_line
:
4756 READ_SLEB (adv
, data
, end
);
4757 state_machine_regs
.line
+= adv
;
4760 case DW_LNS_set_file
:
4761 READ_ULEB (uladv
, data
, end
);
4762 state_machine_regs
.file
= uladv
;
4765 unsigned file
= state_machine_regs
.file
- 1;
4768 if (file_table
== NULL
|| n_files
== 0)
4769 printf (_("\n [Use file table entry %d]\n"), file
);
4771 else if (file
>= n_files
)
4773 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4774 printf (_("\n <over large file table index %u>"), file
);
4776 else if ((dir
= file_table
[file
].directory_index
) == 0)
4777 /* If directory index is 0, that means current directory. */
4778 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4779 else if (directory_table
== NULL
|| n_directories
== 0)
4780 printf (_("\n [Use file %s in directory table entry %d]\n"),
4781 file_table
[file
].name
, dir
);
4783 else if (dir
> n_directories
)
4785 warn (_("directory index %u > number of directories %s\n"),
4786 dir
, dwarf_vmatoa ("u", n_directories
));
4787 printf (_("\n <over large directory table entry %u>\n"), dir
);
4790 printf ("\n%s/%s:\n",
4791 /* The directory index starts counting at 1. */
4792 directory_table
[dir
- 1], file_table
[file
].name
);
4796 case DW_LNS_set_column
:
4797 READ_ULEB (uladv
, data
, end
);
4798 state_machine_regs
.column
= uladv
;
4801 case DW_LNS_negate_stmt
:
4802 adv
= state_machine_regs
.is_stmt
;
4804 state_machine_regs
.is_stmt
= adv
;
4807 case DW_LNS_set_basic_block
:
4808 state_machine_regs
.basic_block
= 1;
4811 case DW_LNS_const_add_pc
:
4812 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4813 if (linfo
.li_max_ops_per_insn
== 1)
4815 uladv
*= linfo
.li_min_insn_length
;
4816 state_machine_regs
.address
+= uladv
;
4818 state_machine_regs
.view
= 0;
4823 = ((state_machine_regs
.op_index
+ uladv
)
4824 / linfo
.li_max_ops_per_insn
)
4825 * linfo
.li_min_insn_length
;
4826 state_machine_regs
.address
4828 state_machine_regs
.op_index
4829 = (state_machine_regs
.op_index
+ uladv
)
4830 % linfo
.li_max_ops_per_insn
;
4832 state_machine_regs
.view
= 0;
4836 case DW_LNS_fixed_advance_pc
:
4837 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4838 state_machine_regs
.address
+= uladv
;
4839 state_machine_regs
.op_index
= 0;
4840 /* Do NOT reset view. */
4843 case DW_LNS_set_prologue_end
:
4846 case DW_LNS_set_epilogue_begin
:
4849 case DW_LNS_set_isa
:
4850 READ_ULEB (uladv
, data
, end
);
4851 printf (_(" Set ISA to %lu\n"), uladv
);
4855 printf (_(" Unknown opcode %d with operands: "), op_code
);
4857 if (standard_opcodes
!= NULL
)
4858 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4862 READ_ULEB (val
, data
, end
);
4863 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
4864 i
== 1 ? "" : ", ");
4870 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4871 to the DWARF address/line matrix. */
4872 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4873 || (xop
== DW_LNS_copy
))
4875 const unsigned int MAX_FILENAME_LENGTH
= 35;
4877 char *newFileName
= NULL
;
4878 size_t fileNameLength
;
4882 unsigned indx
= state_machine_regs
.file
- 1;
4884 if (indx
>= n_files
)
4886 warn (_("corrupt file index %u encountered\n"), indx
);
4887 fileName
= _("<corrupt>");
4890 fileName
= (char *) file_table
[indx
].name
;
4893 fileName
= _("<unknown>");
4895 fileNameLength
= strlen (fileName
);
4897 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4899 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4900 /* Truncate file name */
4901 strncpy (newFileName
,
4902 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4903 MAX_FILENAME_LENGTH
+ 1);
4907 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4908 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4911 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4913 if (linfo
.li_max_ops_per_insn
== 1)
4914 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4915 newFileName
, state_machine_regs
.line
,
4916 state_machine_regs
.address
);
4918 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4919 newFileName
, state_machine_regs
.line
,
4920 state_machine_regs
.address
,
4921 state_machine_regs
.op_index
);
4925 if (linfo
.li_max_ops_per_insn
== 1)
4926 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
4927 newFileName
, state_machine_regs
.line
,
4928 state_machine_regs
.address
);
4930 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4931 newFileName
, state_machine_regs
.line
,
4932 state_machine_regs
.address
,
4933 state_machine_regs
.op_index
);
4936 if (state_machine_regs
.view
)
4937 printf (" %6u", state_machine_regs
.view
);
4941 if (state_machine_regs
.is_stmt
)
4945 state_machine_regs
.view
++;
4947 if (xop
== -DW_LNE_end_sequence
)
4949 reset_state_machine (linfo
.li_default_is_stmt
);
4964 if (directory_table
)
4966 free (directory_table
);
4967 directory_table
= NULL
;
4978 display_debug_lines (struct dwarf_section
*section
, void *file
)
4980 unsigned char *data
= section
->start
;
4981 unsigned char *end
= data
+ section
->size
;
4983 int retValDecoded
= 1;
4985 if (do_debug_lines
== 0)
4986 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
4988 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
4989 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
4991 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
4992 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
4994 if (!retValRaw
|| !retValDecoded
)
5001 find_debug_info_for_offset (unsigned long offset
)
5005 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5008 for (i
= 0; i
< num_debug_info_entries
; i
++)
5009 if (debug_information
[i
].cu_offset
== offset
)
5010 return debug_information
+ i
;
5016 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5018 /* See gdb/gdb-index.h. */
5019 static const char * const kinds
[] =
5031 return _ (kinds
[kind
]);
5035 display_debug_pubnames_worker (struct dwarf_section
*section
,
5036 void *file ATTRIBUTE_UNUSED
,
5039 DWARF2_Internal_PubNames names
;
5040 unsigned char *start
= section
->start
;
5041 unsigned char *end
= start
+ section
->size
;
5043 /* It does not matter if this load fails,
5044 we test for that later on. */
5045 load_debug_info (file
);
5047 introduce (section
, FALSE
);
5051 unsigned char *data
;
5052 unsigned long sec_off
;
5053 unsigned int offset_size
, initial_length_size
;
5055 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5056 if (names
.pn_length
== 0xffffffff)
5058 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5060 initial_length_size
= 12;
5065 initial_length_size
= 4;
5068 sec_off
= start
- section
->start
;
5069 if (sec_off
+ names
.pn_length
< sec_off
5070 || sec_off
+ names
.pn_length
> section
->size
)
5072 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5074 sec_off
- initial_length_size
,
5075 dwarf_vmatoa ("x", names
.pn_length
));
5080 start
+= names
.pn_length
;
5082 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5083 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5085 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5086 && num_debug_info_entries
> 0
5087 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5088 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5089 (unsigned long) names
.pn_offset
, section
->name
);
5091 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5093 printf (_(" Length: %ld\n"),
5094 (long) names
.pn_length
);
5095 printf (_(" Version: %d\n"),
5097 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5098 (unsigned long) names
.pn_offset
);
5099 printf (_(" Size of area in .debug_info section: %ld\n"),
5100 (long) names
.pn_size
);
5102 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5104 static int warned
= 0;
5108 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5116 printf (_("\n Offset Kind Name\n"));
5118 printf (_("\n Offset\tName\n"));
5122 bfd_size_type maxprint
;
5125 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5130 data
+= offset_size
;
5133 maxprint
= (end
- data
) - 1;
5137 unsigned int kind_data
;
5138 gdb_index_symbol_kind kind
;
5139 const char *kind_name
;
5142 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5145 /* GCC computes the kind as the upper byte in the CU index
5146 word, and then right shifts it by the CU index size.
5147 Left shift KIND to where the gdb-index.h accessor macros
5149 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5150 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5151 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5152 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5153 printf (" %-6lx %s,%-10s %.*s\n",
5154 (unsigned long) offset
, is_static
? _("s") : _("g"),
5155 kind_name
, (int) maxprint
, data
);
5158 printf (" %-6lx\t%.*s\n",
5159 (unsigned long) offset
, (int) maxprint
, data
);
5161 data
+= strnlen ((char *) data
, maxprint
) + 1;
5172 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5174 return display_debug_pubnames_worker (section
, file
, 0);
5178 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5180 return display_debug_pubnames_worker (section
, file
, 1);
5184 display_debug_macinfo (struct dwarf_section
*section
,
5185 void *file ATTRIBUTE_UNUSED
)
5187 unsigned char *start
= section
->start
;
5188 unsigned char *end
= start
+ section
->size
;
5189 unsigned char *curr
= start
;
5190 enum dwarf_macinfo_record_type op
;
5192 introduce (section
, FALSE
);
5196 unsigned int lineno
;
5197 const unsigned char *string
;
5199 op
= (enum dwarf_macinfo_record_type
) *curr
;
5204 case DW_MACINFO_start_file
:
5206 unsigned int filenum
;
5208 READ_ULEB (lineno
, curr
, end
);
5209 READ_ULEB (filenum
, curr
, end
);
5210 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5215 case DW_MACINFO_end_file
:
5216 printf (_(" DW_MACINFO_end_file\n"));
5219 case DW_MACINFO_define
:
5220 READ_ULEB (lineno
, curr
, end
);
5222 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5223 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5227 case DW_MACINFO_undef
:
5228 READ_ULEB (lineno
, curr
, end
);
5230 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5231 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5235 case DW_MACINFO_vendor_ext
:
5237 unsigned int constant
;
5239 READ_ULEB (constant
, curr
, end
);
5241 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5242 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5252 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5253 filename and dirname corresponding to file name table entry with index
5254 FILEIDX. Return NULL on failure. */
5256 static unsigned char *
5257 get_line_filename_and_dirname (dwarf_vma line_offset
,
5259 unsigned char **dir_name
)
5261 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5262 unsigned char *hdrptr
, *dirtable
, *file_name
;
5263 unsigned int offset_size
, initial_length_size
;
5264 unsigned int version
, opcode_base
;
5265 dwarf_vma length
, diridx
;
5266 const unsigned char * end
;
5269 if (section
->start
== NULL
5270 || line_offset
>= section
->size
5274 hdrptr
= section
->start
+ line_offset
;
5275 end
= section
->start
+ section
->size
;
5277 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5278 if (length
== 0xffffffff)
5280 /* This section is 64-bit DWARF 3. */
5281 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5283 initial_length_size
= 12;
5288 initial_length_size
= 4;
5290 if (length
+ initial_length_size
< length
5291 || length
+ initial_length_size
> section
->size
)
5294 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5295 if (version
!= 2 && version
!= 3 && version
!= 4)
5297 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5299 hdrptr
++; /* Skip max_ops_per_insn. */
5300 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5302 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5303 if (opcode_base
== 0)
5306 hdrptr
+= opcode_base
- 1;
5311 /* Skip over dirname table. */
5312 while (*hdrptr
!= '\0')
5314 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5318 hdrptr
++; /* Skip the NUL at the end of the table. */
5320 /* Now skip over preceding filename table entries. */
5321 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5323 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5324 SKIP_ULEB (hdrptr
, end
);
5325 SKIP_ULEB (hdrptr
, end
);
5326 SKIP_ULEB (hdrptr
, end
);
5328 if (hdrptr
>= end
|| *hdrptr
== '\0')
5332 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5335 READ_ULEB (diridx
, hdrptr
, end
);
5338 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5339 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5340 if (dirtable
>= end
|| *dirtable
== '\0')
5342 *dir_name
= dirtable
;
5347 display_debug_macro (struct dwarf_section
*section
,
5350 unsigned char *start
= section
->start
;
5351 unsigned char *end
= start
+ section
->size
;
5352 unsigned char *curr
= start
;
5353 unsigned char *extended_op_buf
[256];
5355 load_debug_section_with_follow (str
, file
);
5356 load_debug_section_with_follow (line
, file
);
5358 introduce (section
, FALSE
);
5362 unsigned int lineno
, version
, flags
;
5363 unsigned int offset_size
= 4;
5364 const unsigned char *string
;
5365 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5366 unsigned char **extended_ops
= NULL
;
5368 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5369 if (version
!= 4 && version
!= 5)
5371 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5376 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5379 printf (_(" Offset: 0x%lx\n"),
5380 (unsigned long) sec_offset
);
5381 printf (_(" Version: %d\n"), version
);
5382 printf (_(" Offset size: %d\n"), offset_size
);
5385 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5386 printf (_(" Offset into .debug_line: 0x%lx\n"),
5387 (unsigned long) line_offset
);
5391 unsigned int i
, count
, op
;
5394 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5396 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5397 extended_ops
= extended_op_buf
;
5400 printf (_(" Extension opcode arguments:\n"));
5401 for (i
= 0; i
< count
; i
++)
5403 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5404 extended_ops
[op
] = curr
;
5405 READ_ULEB (nargs
, curr
, end
);
5407 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5410 printf (_(" DW_MACRO_%02x arguments: "), op
);
5411 for (n
= 0; n
< nargs
; n
++)
5415 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5416 printf ("%s%s", get_FORM_name (form
),
5417 n
== nargs
- 1 ? "\n" : ", ");
5427 case DW_FORM_block1
:
5428 case DW_FORM_block2
:
5429 case DW_FORM_block4
:
5431 case DW_FORM_string
:
5433 case DW_FORM_sec_offset
:
5436 error (_("Invalid extension opcode form %s\n"),
5437 get_FORM_name (form
));
5453 error (_(".debug_macro section not zero terminated\n"));
5457 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5463 case DW_MACRO_start_file
:
5465 unsigned int filenum
;
5466 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5468 READ_ULEB (lineno
, curr
, end
);
5469 READ_ULEB (filenum
, curr
, end
);
5471 if ((flags
& 2) == 0)
5472 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5475 = get_line_filename_and_dirname (line_offset
, filenum
,
5477 if (file_name
== NULL
)
5478 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5481 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5483 dir_name
!= NULL
? (const char *) dir_name
: "",
5484 dir_name
!= NULL
? "/" : "", file_name
);
5488 case DW_MACRO_end_file
:
5489 printf (_(" DW_MACRO_end_file\n"));
5492 case DW_MACRO_define
:
5493 READ_ULEB (lineno
, curr
, end
);
5495 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5496 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5500 case DW_MACRO_undef
:
5501 READ_ULEB (lineno
, curr
, end
);
5503 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5504 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5508 case DW_MACRO_define_strp
:
5509 READ_ULEB (lineno
, curr
, end
);
5510 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5511 string
= fetch_indirect_string (offset
);
5512 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5516 case DW_MACRO_undef_strp
:
5517 READ_ULEB (lineno
, curr
, end
);
5518 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5519 string
= fetch_indirect_string (offset
);
5520 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5524 case DW_MACRO_import
:
5525 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5526 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5527 (unsigned long) offset
);
5530 case DW_MACRO_define_sup
:
5531 READ_ULEB (lineno
, curr
, end
);
5532 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5533 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5534 lineno
, (unsigned long) offset
);
5537 case DW_MACRO_undef_sup
:
5538 READ_ULEB (lineno
, curr
, end
);
5539 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5540 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5541 lineno
, (unsigned long) offset
);
5544 case DW_MACRO_import_sup
:
5545 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5546 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5547 (unsigned long) offset
);
5551 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5553 error (_(" Unknown macro opcode %02x seen\n"), op
);
5558 /* Skip over unhandled opcodes. */
5560 unsigned char *desc
= extended_ops
[op
];
5561 READ_ULEB (nargs
, desc
, end
);
5564 printf (_(" DW_MACRO_%02x\n"), op
);
5567 printf (_(" DW_MACRO_%02x -"), op
);
5568 for (n
= 0; n
< nargs
; n
++)
5572 /* DW_FORM_implicit_const is not expected here. */
5573 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5575 = read_and_display_attr_value (0, val
, 0,
5576 start
, curr
, end
, 0, 0, offset_size
,
5577 version
, NULL
, 0, NULL
,
5595 display_debug_abbrev (struct dwarf_section
*section
,
5596 void *file ATTRIBUTE_UNUSED
)
5598 abbrev_entry
*entry
;
5599 unsigned char *start
= section
->start
;
5600 unsigned char *end
= start
+ section
->size
;
5602 introduce (section
, FALSE
);
5606 unsigned char *last
;
5611 start
= process_abbrev_section (start
, end
);
5613 if (first_abbrev
== NULL
)
5616 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5618 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5622 printf (" %ld %s [%s]\n",
5624 get_TAG_name (entry
->tag
),
5625 entry
->children
? _("has children") : _("no children"));
5627 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5629 printf (" %-18s %s",
5630 get_AT_name (attr
->attribute
),
5631 get_FORM_name (attr
->form
));
5632 if (attr
->form
== DW_FORM_implicit_const
)
5633 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5645 /* Return true when ADDR is the maximum address, when addresses are
5646 POINTER_SIZE bytes long. */
5649 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5651 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5652 return ((addr
& mask
) == mask
);
5655 /* Display a view pair list starting at *VSTART_PTR and ending at
5656 VLISTEND within SECTION. */
5659 display_view_pair_list (struct dwarf_section
*section
,
5660 unsigned char **vstart_ptr
,
5661 unsigned int debug_info_entry
,
5662 unsigned char *vlistend
)
5664 unsigned char *vstart
= *vstart_ptr
;
5665 unsigned char *section_end
= section
->start
+ section
->size
;
5666 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5668 if (vlistend
< section_end
)
5669 section_end
= vlistend
;
5673 while (vstart
< section_end
)
5675 dwarf_vma off
= vstart
- section
->start
;
5676 dwarf_vma vbegin
, vend
;
5678 READ_ULEB (vbegin
, vstart
, section_end
);
5679 if (vstart
== section_end
)
5682 READ_ULEB (vend
, vstart
, section_end
);
5683 printf (" %8.8lx ", (unsigned long) off
);
5685 print_dwarf_view (vbegin
, pointer_size
, 1);
5686 print_dwarf_view (vend
, pointer_size
, 1);
5687 printf (_("location view pair\n"));
5691 *vstart_ptr
= vstart
;
5694 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5697 display_loc_list (struct dwarf_section
*section
,
5698 unsigned char **start_ptr
,
5699 unsigned int debug_info_entry
,
5701 dwarf_vma base_address
,
5702 unsigned char **vstart_ptr
,
5705 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5706 unsigned char *section_end
= section
->start
+ section
->size
;
5707 unsigned long cu_offset
;
5708 unsigned int pointer_size
;
5709 unsigned int offset_size
;
5714 unsigned short length
;
5715 int need_frame_base
;
5717 if (debug_info_entry
>= num_debug_info_entries
)
5719 warn (_("No debug information available for loc lists of entry: %u\n"),
5724 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5725 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5726 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5727 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5729 if (pointer_size
< 2 || pointer_size
> 8)
5731 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5732 pointer_size
, debug_info_entry
);
5738 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5739 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5741 if (start
+ 2 * pointer_size
> section_end
)
5743 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5744 (unsigned long) offset
);
5748 printf (" %8.8lx ", (unsigned long) off
);
5750 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5751 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5753 if (begin
== 0 && end
== 0)
5755 /* PR 18374: In a object file we can have a location list that
5756 starts with a begin and end of 0 because there are relocations
5757 that need to be applied to the addresses. Actually applying
5758 the relocations now does not help as they will probably resolve
5759 to 0, since the object file has not been fully linked. Real
5760 end of list markers will not have any relocations against them. */
5761 if (! reloc_at (section
, off
)
5762 && ! reloc_at (section
, off
+ pointer_size
))
5764 printf (_("<End of list>\n"));
5769 /* Check base address specifiers. */
5770 if (is_max_address (begin
, pointer_size
)
5771 && !is_max_address (end
, pointer_size
))
5774 print_dwarf_vma (begin
, pointer_size
);
5775 print_dwarf_vma (end
, pointer_size
);
5776 printf (_("(base address)\n"));
5782 off
= offset
+ (vstart
- *start_ptr
);
5784 READ_ULEB (vbegin
, vstart
, section_end
);
5785 print_dwarf_view (vbegin
, pointer_size
, 1);
5787 READ_ULEB (vend
, vstart
, section_end
);
5788 print_dwarf_view (vend
, pointer_size
, 1);
5790 printf (_("views at %8.8lx for:\n %*s "),
5791 (unsigned long) off
, 8, "");
5794 if (start
+ 2 > section_end
)
5796 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5797 (unsigned long) offset
);
5801 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5803 if (start
+ length
> section_end
)
5805 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5806 (unsigned long) offset
);
5810 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5811 print_dwarf_vma (end
+ base_address
, pointer_size
);
5814 need_frame_base
= decode_location_expression (start
,
5819 cu_offset
, section
);
5822 if (need_frame_base
&& !has_frame_base
)
5823 printf (_(" [without DW_AT_frame_base]"));
5825 if (begin
== end
&& vbegin
== vend
)
5826 fputs (_(" (start == end)"), stdout
);
5827 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5828 fputs (_(" (start > end)"), stdout
);
5836 *vstart_ptr
= vstart
;
5839 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5842 display_loclists_list (struct dwarf_section
*section
,
5843 unsigned char **start_ptr
,
5844 unsigned int debug_info_entry
,
5846 dwarf_vma base_address
,
5847 unsigned char **vstart_ptr
,
5850 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5851 unsigned char *section_end
= section
->start
+ section
->size
;
5852 unsigned long cu_offset
;
5853 unsigned int pointer_size
;
5854 unsigned int offset_size
;
5857 /* Initialize it due to a false compiler warning. */
5858 dwarf_vma begin
= -1, vbegin
= -1;
5859 dwarf_vma end
= -1, vend
= -1;
5861 int need_frame_base
;
5863 if (debug_info_entry
>= num_debug_info_entries
)
5865 warn (_("No debug information available for "
5866 "loclists lists of entry: %u\n"),
5871 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5872 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5873 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5874 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5876 if (pointer_size
< 2 || pointer_size
> 8)
5878 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5879 pointer_size
, debug_info_entry
);
5885 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5886 enum dwarf_location_list_entry_type llet
;
5888 if (start
+ 1 > section_end
)
5890 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5891 (unsigned long) offset
);
5895 printf (" %8.8lx ", (unsigned long) off
);
5897 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5899 if (vstart
&& llet
== DW_LLE_offset_pair
)
5901 off
= offset
+ (vstart
- *start_ptr
);
5903 READ_ULEB (vbegin
, vstart
, section_end
);
5904 print_dwarf_view (vbegin
, pointer_size
, 1);
5906 READ_ULEB (vend
, vstart
, section_end
);
5907 print_dwarf_view (vend
, pointer_size
, 1);
5909 printf (_("views at %8.8lx for:\n %*s "),
5910 (unsigned long) off
, 8, "");
5915 case DW_LLE_end_of_list
:
5916 printf (_("<End of list>\n"));
5918 case DW_LLE_offset_pair
:
5919 READ_ULEB (begin
, start
, section_end
);
5920 READ_ULEB (end
, start
, section_end
);
5922 case DW_LLE_base_address
:
5923 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
5925 print_dwarf_vma (base_address
, pointer_size
);
5926 printf (_("(base address)\n"));
5928 #ifdef DW_LLE_view_pair
5929 case DW_LLE_view_pair
:
5931 printf (_("View pair entry in loclist with locviews attribute\n"));
5932 READ_ULEB (vbegin
, start
, section_end
);
5933 print_dwarf_view (vbegin
, pointer_size
, 1);
5935 READ_ULEB (vend
, start
, section_end
);
5936 print_dwarf_view (vend
, pointer_size
, 1);
5938 printf (_("views for:\n"));
5942 error (_("Invalid location list entry type %d\n"), llet
);
5945 if (llet
== DW_LLE_end_of_list
)
5947 if (llet
!= DW_LLE_offset_pair
)
5950 if (start
+ 2 > section_end
)
5952 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5953 (unsigned long) offset
);
5957 READ_ULEB (length
, start
, section_end
);
5959 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5960 print_dwarf_vma (end
+ base_address
, pointer_size
);
5963 need_frame_base
= decode_location_expression (start
,
5968 cu_offset
, section
);
5971 if (need_frame_base
&& !has_frame_base
)
5972 printf (_(" [without DW_AT_frame_base]"));
5974 if (begin
== end
&& vbegin
== vend
)
5975 fputs (_(" (start == end)"), stdout
);
5976 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5977 fputs (_(" (start > end)"), stdout
);
5985 if (vbegin
!= vm1
|| vend
!= vm1
)
5986 printf (_("Trailing view pair not used in a range"));
5989 *vstart_ptr
= vstart
;
5992 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
5993 right-adjusted in a field of length LEN, and followed by a space. */
5996 print_addr_index (unsigned int idx
, unsigned int len
)
5998 static char buf
[15];
5999 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6000 printf ("%*s ", len
, buf
);
6003 /* Display a location list from a .dwo section. It uses address indexes rather
6004 than embedded addresses. This code closely follows display_loc_list, but the
6005 two are sufficiently different that combining things is very ugly. */
6008 display_loc_list_dwo (struct dwarf_section
*section
,
6009 unsigned char **start_ptr
,
6010 unsigned int debug_info_entry
,
6012 unsigned char **vstart_ptr
,
6015 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6016 unsigned char *section_end
= section
->start
+ section
->size
;
6017 unsigned long cu_offset
;
6018 unsigned int pointer_size
;
6019 unsigned int offset_size
;
6022 unsigned short length
;
6023 int need_frame_base
;
6026 if (debug_info_entry
>= num_debug_info_entries
)
6028 warn (_("No debug information for loc lists of entry: %u\n"),
6033 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6034 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6035 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6036 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6038 if (pointer_size
< 2 || pointer_size
> 8)
6040 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6041 pointer_size
, debug_info_entry
);
6047 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6049 if (start
>= section_end
)
6051 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6052 (unsigned long) offset
);
6056 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6069 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6071 READ_ULEB (view
, vstart
, section_end
);
6072 print_dwarf_view (view
, 8, 1);
6074 READ_ULEB (view
, vstart
, section_end
);
6075 print_dwarf_view (view
, 8, 1);
6077 printf (_("views at %8.8lx for:\n %*s "),
6078 (unsigned long) off
, 8, "");
6086 case 0: /* A terminating entry. */
6088 *vstart_ptr
= vstart
;
6089 printf (_("<End of list>\n"));
6091 case 1: /* A base-address entry. */
6092 READ_ULEB (idx
, start
, section_end
);
6093 print_addr_index (idx
, 8);
6094 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6095 printf (_("(base address selection entry)\n"));
6097 case 2: /* A start/end entry. */
6098 READ_ULEB (idx
, start
, section_end
);
6099 print_addr_index (idx
, 8);
6100 READ_ULEB (idx
, start
, section_end
);
6101 print_addr_index (idx
, 8);
6103 case 3: /* A start/length entry. */
6104 READ_ULEB (idx
, start
, section_end
);
6105 print_addr_index (idx
, 8);
6106 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6107 printf ("%08x ", idx
);
6109 case 4: /* An offset pair entry. */
6110 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6111 printf ("%08x ", idx
);
6112 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6113 printf ("%08x ", idx
);
6116 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6118 *vstart_ptr
= vstart
;
6122 if (start
+ 2 > section_end
)
6124 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6125 (unsigned long) offset
);
6129 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6130 if (start
+ length
> section_end
)
6132 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6133 (unsigned long) offset
);
6138 need_frame_base
= decode_location_expression (start
,
6143 cu_offset
, section
);
6146 if (need_frame_base
&& !has_frame_base
)
6147 printf (_(" [without DW_AT_frame_base]"));
6155 *vstart_ptr
= vstart
;
6158 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6161 static dwarf_vma
*loc_offsets
, *loc_views
;
6164 loc_offsets_compar (const void *ap
, const void *bp
)
6166 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6167 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6169 int ret
= (a
> b
) - (b
> a
);
6173 a
= loc_views
[*(const unsigned int *) ap
];
6174 b
= loc_views
[*(const unsigned int *) bp
];
6176 ret
= (a
> b
) - (b
> a
);
6182 display_debug_loc (struct dwarf_section
*section
, void *file
)
6184 unsigned char *start
= section
->start
, *vstart
= NULL
;
6185 unsigned long bytes
;
6186 unsigned char *section_begin
= start
;
6187 unsigned int num_loc_list
= 0;
6188 unsigned long last_offset
= 0;
6189 unsigned long last_view
= 0;
6190 unsigned int first
= 0;
6193 int seen_first_offset
= 0;
6194 int locs_sorted
= 1;
6195 unsigned char *next
= start
, *vnext
= vstart
;
6196 unsigned int *array
= NULL
;
6197 const char *suffix
= strrchr (section
->name
, '.');
6198 bfd_boolean is_dwo
= FALSE
;
6199 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6200 dwarf_vma expected_start
= 0;
6202 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6205 bytes
= section
->size
;
6209 printf (_("\nThe %s section is empty.\n"), section
->name
);
6215 unsigned char *hdrptr
= section_begin
;
6216 dwarf_vma ll_length
;
6217 unsigned short ll_version
;
6218 unsigned char *end
= section_begin
+ section
->size
;
6219 unsigned char address_size
, segment_selector_size
;
6220 uint32_t offset_entry_count
;
6222 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6223 if (ll_length
== 0xffffffff)
6224 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6226 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6227 if (ll_version
!= 5)
6229 warn (_("The %s section contains corrupt or "
6230 "unsupported version number: %d.\n"),
6231 section
->name
, ll_version
);
6235 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6237 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6238 if (segment_selector_size
!= 0)
6240 warn (_("The %s section contains "
6241 "unsupported segment selector size: %d.\n"),
6242 section
->name
, segment_selector_size
);
6246 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6247 if (offset_entry_count
!= 0)
6249 warn (_("The %s section contains "
6250 "unsupported offset entry count: %d.\n"),
6251 section
->name
, offset_entry_count
);
6255 expected_start
= hdrptr
- section_begin
;
6258 if (load_debug_info (file
) == 0)
6260 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6265 /* Check the order of location list in .debug_info section. If
6266 offsets of location lists are in the ascending order, we can
6267 use `debug_information' directly. */
6268 for (i
= 0; i
< num_debug_info_entries
; i
++)
6272 num
= debug_information
[i
].num_loc_offsets
;
6273 if (num
> num_loc_list
)
6276 /* Check if we can use `debug_information' directly. */
6277 if (locs_sorted
&& num
!= 0)
6279 if (!seen_first_offset
)
6281 /* This is the first location list. */
6282 last_offset
= debug_information
[i
].loc_offsets
[0];
6283 last_view
= debug_information
[i
].loc_views
[0];
6285 seen_first_offset
= 1;
6291 for (; j
< num
; j
++)
6294 debug_information
[i
].loc_offsets
[j
]
6295 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6296 && last_view
> debug_information
[i
].loc_views
[j
]))
6301 last_offset
= debug_information
[i
].loc_offsets
[j
];
6302 last_view
= debug_information
[i
].loc_views
[j
];
6307 if (!seen_first_offset
)
6308 error (_("No location lists in .debug_info section!\n"));
6310 if (debug_information
[first
].num_loc_offsets
> 0
6311 && debug_information
[first
].loc_offsets
[0] != expected_start
6312 && debug_information
[first
].loc_views
[0] != expected_start
)
6313 warn (_("Location lists in %s section start at 0x%s\n"),
6315 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6318 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6320 introduce (section
, FALSE
);
6322 if (reloc_at (section
, 0))
6323 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6325 printf (_(" Offset Begin End Expression\n"));
6327 seen_first_offset
= 0;
6328 for (i
= first
; i
< num_debug_info_entries
; i
++)
6330 dwarf_vma offset
, voffset
;
6331 dwarf_vma base_address
;
6337 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6339 loc_offsets
= debug_information
[i
].loc_offsets
;
6340 loc_views
= debug_information
[i
].loc_views
;
6341 qsort (array
, debug_information
[i
].num_loc_offsets
,
6342 sizeof (*array
), loc_offsets_compar
);
6345 int adjacent_view_loclists
= 1;
6346 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6348 j
= locs_sorted
? k
: array
[k
];
6350 && (debug_information
[i
].loc_offsets
[locs_sorted
6351 ? k
- 1 : array
[k
- 1]]
6352 == debug_information
[i
].loc_offsets
[j
])
6353 && (debug_information
[i
].loc_views
[locs_sorted
6354 ? k
- 1 : array
[k
- 1]]
6355 == debug_information
[i
].loc_views
[j
]))
6357 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6358 offset
= debug_information
[i
].loc_offsets
[j
];
6359 next
= section_begin
+ offset
;
6360 voffset
= debug_information
[i
].loc_views
[j
];
6362 vnext
= section_begin
+ voffset
;
6365 base_address
= debug_information
[i
].base_address
;
6367 if (vnext
&& vnext
< next
)
6370 display_view_pair_list (section
, &vstart
, i
, next
);
6375 if (!seen_first_offset
|| !adjacent_view_loclists
)
6376 seen_first_offset
= 1;
6380 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6381 (unsigned long) (start
- section_begin
),
6382 (unsigned long) offset
);
6383 else if (start
> next
)
6384 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6385 (unsigned long) (start
- section_begin
),
6386 (unsigned long) offset
);
6391 if (offset
>= bytes
)
6393 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6394 (unsigned long) offset
);
6398 if (vnext
&& voffset
>= bytes
)
6400 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6401 (unsigned long) voffset
);
6408 display_loc_list_dwo (section
, &start
, i
, offset
,
6409 &vstart
, has_frame_base
);
6411 display_loc_list (section
, &start
, i
, offset
, base_address
,
6412 &vstart
, has_frame_base
);
6417 warn (_("DWO is not yet supported.\n"));
6419 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6420 &vstart
, has_frame_base
);
6423 /* FIXME: this arrangement is quite simplistic. Nothing
6424 requires locview lists to be adjacent to corresponding
6425 loclists, and a single loclist could be augmented by
6426 different locview lists, and vice-versa, unlikely as it
6427 is that it would make sense to do so. Hopefully we'll
6428 have view pair support built into loclists before we ever
6429 need to address all these possibilities. */
6430 if (adjacent_view_loclists
&& vnext
6431 && vnext
!= start
&& vstart
!= next
)
6433 adjacent_view_loclists
= 0;
6434 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6437 if (vnext
&& vnext
== start
)
6438 display_view_pair_list (section
, &start
, i
, vstart
);
6442 if (start
< section
->start
+ section
->size
)
6443 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6444 "There are %ld unused bytes at the end of section %s\n",
6445 (long) (section
->start
+ section
->size
- start
)),
6446 (long) (section
->start
+ section
->size
- start
), section
->name
);
6453 display_debug_str (struct dwarf_section
*section
,
6454 void *file ATTRIBUTE_UNUSED
)
6456 unsigned char *start
= section
->start
;
6457 unsigned long bytes
= section
->size
;
6458 dwarf_vma addr
= section
->address
;
6462 printf (_("\nThe %s section is empty.\n"), section
->name
);
6466 introduce (section
, FALSE
);
6474 lbytes
= (bytes
> 16 ? 16 : bytes
);
6476 printf (" 0x%8.8lx ", (unsigned long) addr
);
6478 for (j
= 0; j
< 16; j
++)
6481 printf ("%2.2x", start
[j
]);
6489 for (j
= 0; j
< lbytes
; j
++)
6492 if (k
>= ' ' && k
< 0x80)
6511 display_debug_info (struct dwarf_section
*section
, void *file
)
6513 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6517 display_debug_types (struct dwarf_section
*section
, void *file
)
6519 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6523 display_trace_info (struct dwarf_section
*section
, void *file
)
6525 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6529 display_debug_aranges (struct dwarf_section
*section
,
6530 void *file ATTRIBUTE_UNUSED
)
6532 unsigned char *start
= section
->start
;
6533 unsigned char *end
= start
+ section
->size
;
6535 introduce (section
, FALSE
);
6537 /* It does not matter if this load fails,
6538 we test for that later on. */
6539 load_debug_info (file
);
6543 unsigned char *hdrptr
;
6544 DWARF2_Internal_ARange arange
;
6545 unsigned char *addr_ranges
;
6548 unsigned long sec_off
;
6549 unsigned char address_size
;
6551 unsigned int offset_size
;
6552 unsigned int initial_length_size
;
6556 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6557 if (arange
.ar_length
== 0xffffffff)
6559 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6561 initial_length_size
= 12;
6566 initial_length_size
= 4;
6569 sec_off
= hdrptr
- section
->start
;
6570 if (sec_off
+ arange
.ar_length
< sec_off
6571 || sec_off
+ arange
.ar_length
> section
->size
)
6573 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6575 sec_off
- initial_length_size
,
6576 dwarf_vmatoa ("x", arange
.ar_length
));
6580 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6581 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6583 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6584 && num_debug_info_entries
> 0
6585 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6586 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6587 (unsigned long) arange
.ar_info_offset
, section
->name
);
6589 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6590 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6592 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6594 /* PR 19872: A version number of 0 probably means that there is
6595 padding at the end of the .debug_aranges section. Gold puts
6596 it there when performing an incremental link, for example.
6597 So do not generate a warning in this case. */
6598 if (arange
.ar_version
)
6599 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6603 printf (_(" Length: %ld\n"),
6604 (long) arange
.ar_length
);
6605 printf (_(" Version: %d\n"), arange
.ar_version
);
6606 printf (_(" Offset into .debug_info: 0x%lx\n"),
6607 (unsigned long) arange
.ar_info_offset
);
6608 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6609 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6611 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6613 /* PR 17512: file: 001-108546-0.001:0.1. */
6614 if (address_size
== 0 || address_size
> 8)
6616 error (_("Invalid address size in %s section!\n"),
6621 /* The DWARF spec does not require that the address size be a power
6622 of two, but we do. This will have to change if we ever encounter
6623 an uneven architecture. */
6624 if ((address_size
& (address_size
- 1)) != 0)
6626 warn (_("Pointer size + Segment size is not a power of two.\n"));
6630 if (address_size
> 4)
6631 printf (_("\n Address Length\n"));
6633 printf (_("\n Address Length\n"));
6635 addr_ranges
= hdrptr
;
6637 /* Must pad to an alignment boundary that is twice the address size. */
6638 excess
= (hdrptr
- start
) % (2 * address_size
);
6640 addr_ranges
+= (2 * address_size
) - excess
;
6642 start
+= arange
.ar_length
+ initial_length_size
;
6644 while (addr_ranges
+ 2 * address_size
<= start
)
6646 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6647 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6650 print_dwarf_vma (address
, address_size
);
6651 print_dwarf_vma (length
, address_size
);
6661 /* Comparison function for qsort. */
6663 comp_addr_base (const void * v0
, const void * v1
)
6665 debug_info
*info0
= *(debug_info
**) v0
;
6666 debug_info
*info1
= *(debug_info
**) v1
;
6667 return info0
->addr_base
- info1
->addr_base
;
6670 /* Display the debug_addr section. */
6672 display_debug_addr (struct dwarf_section
*section
,
6675 debug_info
**debug_addr_info
;
6676 unsigned char *entry
;
6681 if (section
->size
== 0)
6683 printf (_("\nThe %s section is empty.\n"), section
->name
);
6687 if (load_debug_info (file
) == 0)
6689 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6694 introduce (section
, FALSE
);
6696 /* PR 17531: file: cf38d01b.
6697 We use xcalloc because a corrupt file may not have initialised all of the
6698 fields in the debug_info structure, which means that the sort below might
6699 try to move uninitialised data. */
6700 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6701 sizeof (debug_info
*));
6704 for (i
= 0; i
< num_debug_info_entries
; i
++)
6705 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6707 /* PR 17531: file: cf38d01b. */
6708 if (debug_information
[i
].addr_base
>= section
->size
)
6709 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6710 (unsigned long) debug_information
[i
].addr_base
, i
);
6712 debug_addr_info
[count
++] = debug_information
+ i
;
6715 /* Add a sentinel to make iteration convenient. */
6716 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6717 debug_addr_info
[count
]->addr_base
= section
->size
;
6718 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6720 for (i
= 0; i
< count
; i
++)
6723 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6725 printf (_(" For compilation unit at offset 0x%s:\n"),
6726 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6728 printf (_("\tIndex\tAddress\n"));
6729 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6730 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6734 dwarf_vma base
= byte_get (entry
, address_size
);
6735 printf (_("\t%d:\t"), idx
);
6736 print_dwarf_vma (base
, address_size
);
6738 entry
+= address_size
;
6744 free (debug_addr_info
);
6748 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6751 display_debug_str_offsets (struct dwarf_section
*section
,
6752 void *file ATTRIBUTE_UNUSED
)
6754 if (section
->size
== 0)
6756 printf (_("\nThe %s section is empty.\n"), section
->name
);
6759 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6760 what the offset size is for this section. */
6764 /* Each debug_information[x].range_lists[y] gets this representation for
6765 sorting purposes. */
6769 /* The debug_information[x].range_lists[y] value. */
6770 dwarf_vma ranges_offset
;
6772 /* Original debug_information to find parameters of the data. */
6773 debug_info
*debug_info_p
;
6776 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6779 range_entry_compar (const void *ap
, const void *bp
)
6781 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6782 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6783 const dwarf_vma a
= a_re
->ranges_offset
;
6784 const dwarf_vma b
= b_re
->ranges_offset
;
6786 return (a
> b
) - (b
> a
);
6790 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6791 unsigned int pointer_size
, unsigned long offset
,
6792 unsigned long base_address
)
6794 while (start
< finish
)
6799 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6800 if (start
>= finish
)
6802 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6805 printf (" %8.8lx ", offset
);
6807 if (begin
== 0 && end
== 0)
6809 printf (_("<End of list>\n"));
6813 /* Check base address specifiers. */
6814 if (is_max_address (begin
, pointer_size
)
6815 && !is_max_address (end
, pointer_size
))
6818 print_dwarf_vma (begin
, pointer_size
);
6819 print_dwarf_vma (end
, pointer_size
);
6820 printf ("(base address)\n");
6824 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6825 print_dwarf_vma (end
+ base_address
, pointer_size
);
6828 fputs (_("(start == end)"), stdout
);
6829 else if (begin
> end
)
6830 fputs (_("(start > end)"), stdout
);
6837 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
6838 unsigned int pointer_size
, unsigned long offset
,
6839 unsigned long base_address
)
6841 unsigned char *next
= start
;
6845 unsigned long off
= offset
+ (start
- next
);
6846 enum dwarf_range_list_entry rlet
;
6847 /* Initialize it due to a false compiler warning. */
6848 dwarf_vma begin
= -1, length
, end
= -1;
6850 if (start
+ 1 > finish
)
6852 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6857 printf (" %8.8lx ", off
);
6859 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
6863 case DW_RLE_end_of_list
:
6864 printf (_("<End of list>\n"));
6866 case DW_RLE_base_address
:
6867 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
6868 print_dwarf_vma (base_address
, pointer_size
);
6869 printf (_("(base address)\n"));
6871 case DW_RLE_start_length
:
6872 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6873 READ_ULEB (length
, start
, finish
);
6874 end
= begin
+ length
;
6876 case DW_RLE_offset_pair
:
6877 READ_ULEB (begin
, start
, finish
);
6878 READ_ULEB (end
, start
, finish
);
6880 case DW_RLE_start_end
:
6881 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6882 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6885 error (_("Invalid range list entry type %d\n"), rlet
);
6886 rlet
= DW_RLE_end_of_list
;
6889 if (rlet
== DW_RLE_end_of_list
)
6891 if (rlet
== DW_RLE_base_address
)
6894 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6895 print_dwarf_vma (end
+ base_address
, pointer_size
);
6898 fputs (_("(start == end)"), stdout
);
6899 else if (begin
> end
)
6900 fputs (_("(start > end)"), stdout
);
6907 display_debug_ranges (struct dwarf_section
*section
,
6908 void *file ATTRIBUTE_UNUSED
)
6910 unsigned char *start
= section
->start
;
6911 unsigned char *last_start
= start
;
6912 unsigned long bytes
= section
->size
;
6913 unsigned char *section_begin
= start
;
6914 unsigned char *finish
= start
+ bytes
;
6915 unsigned int num_range_list
, i
;
6916 struct range_entry
*range_entries
, *range_entry_fill
;
6917 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
6918 /* Initialize it due to a false compiler warning. */
6919 unsigned char address_size
= 0;
6923 printf (_("\nThe %s section is empty.\n"), section
->name
);
6929 dwarf_vma initial_length
;
6930 unsigned int initial_length_size
;
6931 unsigned char segment_selector_size
;
6932 unsigned int offset_size
, offset_entry_count
;
6933 unsigned short version
;
6935 /* Get and check the length of the block. */
6936 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
6938 if (initial_length
== 0xffffffff)
6940 /* This section is 64-bit DWARF 3. */
6941 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
6943 initial_length_size
= 12;
6948 initial_length_size
= 4;
6951 if (initial_length
+ initial_length_size
> section
->size
)
6953 /* If the length field has a relocation against it, then we should
6954 not complain if it is inaccurate (and probably negative).
6955 It is copied from .debug_line handling code. */
6956 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
6958 initial_length
= (finish
- start
) - initial_length_size
;
6962 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6963 (long) initial_length
);
6968 /* Get and check the version number. */
6969 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
6973 warn (_("Only DWARF version 5 debug_rnglists info "
6974 "is currently supported.\n"));
6978 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
6980 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
6981 if (segment_selector_size
!= 0)
6983 warn (_("The %s section contains "
6984 "unsupported segment selector size: %d.\n"),
6985 section
->name
, segment_selector_size
);
6989 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
6990 if (offset_entry_count
!= 0)
6992 warn (_("The %s section contains "
6993 "unsupported offset entry count: %u.\n"),
6994 section
->name
, offset_entry_count
);
6999 if (load_debug_info (file
) == 0)
7001 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7007 for (i
= 0; i
< num_debug_info_entries
; i
++)
7008 num_range_list
+= debug_information
[i
].num_range_lists
;
7010 if (num_range_list
== 0)
7012 /* This can happen when the file was compiled with -gsplit-debug
7013 which removes references to range lists from the primary .o file. */
7014 printf (_("No range lists in .debug_info section.\n"));
7018 range_entries
= (struct range_entry
*)
7019 xmalloc (sizeof (*range_entries
) * num_range_list
);
7020 range_entry_fill
= range_entries
;
7022 for (i
= 0; i
< num_debug_info_entries
; i
++)
7024 debug_info
*debug_info_p
= &debug_information
[i
];
7027 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7029 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7030 range_entry_fill
->debug_info_p
= debug_info_p
;
7035 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7036 range_entry_compar
);
7038 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7039 warn (_("Range lists in %s section start at 0x%lx\n"),
7040 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7042 introduce (section
, FALSE
);
7044 printf (_(" Offset Begin End\n"));
7046 for (i
= 0; i
< num_range_list
; i
++)
7048 struct range_entry
*range_entry
= &range_entries
[i
];
7049 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7050 unsigned int pointer_size
;
7052 unsigned char *next
;
7053 dwarf_vma base_address
;
7055 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7056 offset
= range_entry
->ranges_offset
;
7057 next
= section_begin
+ offset
;
7058 base_address
= debug_info_p
->base_address
;
7060 /* PR 17512: file: 001-101485-0.001:0.1. */
7061 if (pointer_size
< 2 || pointer_size
> 8)
7063 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7064 pointer_size
, (unsigned long) offset
);
7068 if (next
< section_begin
|| next
>= finish
)
7070 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7071 (unsigned long) offset
, i
);
7075 if (dwarf_check
!= 0 && i
> 0)
7078 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7079 (unsigned long) (start
- section_begin
),
7080 (unsigned long) (next
- section_begin
), section
->name
);
7081 else if (start
> next
)
7083 if (next
== last_start
)
7085 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7086 (unsigned long) (start
- section_begin
),
7087 (unsigned long) (next
- section_begin
), section
->name
);
7094 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7095 (start
, finish
, pointer_size
, offset
, base_address
);
7099 free (range_entries
);
7104 typedef struct Frame_Chunk
7106 struct Frame_Chunk
*next
;
7107 unsigned char *chunk_start
;
7109 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7110 short int *col_type
;
7113 unsigned int code_factor
;
7117 unsigned int cfa_reg
;
7118 dwarf_vma cfa_offset
;
7120 unsigned char fde_encoding
;
7121 unsigned char cfa_exp
;
7122 unsigned char ptr_size
;
7123 unsigned char segment_size
;
7127 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7128 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7129 static const char *const *dwarf_regnames
;
7130 static unsigned int dwarf_regnames_count
;
7133 /* A marker for a col_type that means this column was never referenced
7134 in the frame info. */
7135 #define DW_CFA_unreferenced (-1)
7137 /* Return 0 if no more space is needed, 1 if more space is needed,
7138 -1 for invalid reg. */
7141 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7143 unsigned int prev
= fc
->ncols
;
7145 if (reg
< (unsigned int) fc
->ncols
)
7148 if (dwarf_regnames_count
> 0
7149 && reg
> dwarf_regnames_count
)
7152 fc
->ncols
= reg
+ 1;
7153 /* PR 17512: file: 10450-2643-0.004.
7154 If reg == -1 then this can happen... */
7158 /* PR 17512: file: 2844a11d. */
7159 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7161 error (_("Unfeasibly large register number: %u\n"), reg
);
7163 /* FIXME: 1024 is an arbitrary limit. Increase it if
7164 we ever encounter a valid binary that exceeds it. */
7168 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7169 sizeof (short int));
7170 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7171 /* PR 17512: file:002-10025-0.005. */
7172 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7174 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7180 while (prev
< fc
->ncols
)
7182 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7183 fc
->col_offset
[prev
] = 0;
7189 static const char *const dwarf_regnames_i386
[] =
7191 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7192 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7193 "eip", "eflags", NULL
, /* 8 - 10 */
7194 "st0", "st1", "st2", "st3", /* 11 - 14 */
7195 "st4", "st5", "st6", "st7", /* 15 - 18 */
7196 NULL
, NULL
, /* 19 - 20 */
7197 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7198 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7199 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7200 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7201 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7202 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7203 "tr", "ldtr", /* 48 - 49 */
7204 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7205 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7206 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7207 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7208 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7209 NULL
, NULL
, NULL
, /* 90 - 92 */
7210 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7213 static const char *const dwarf_regnames_iamcu
[] =
7215 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7216 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7217 "eip", "eflags", NULL
, /* 8 - 10 */
7218 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7219 NULL
, NULL
, /* 19 - 20 */
7220 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7221 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7222 NULL
, NULL
, NULL
, /* 37 - 39 */
7223 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7224 "tr", "ldtr", /* 48 - 49 */
7225 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7226 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7227 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7228 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7229 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7230 NULL
, NULL
, NULL
, /* 90 - 92 */
7231 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7235 init_dwarf_regnames_i386 (void)
7237 dwarf_regnames
= dwarf_regnames_i386
;
7238 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7239 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7243 init_dwarf_regnames_iamcu (void)
7245 dwarf_regnames
= dwarf_regnames_iamcu
;
7246 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7247 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7250 static const char *const dwarf_regnames_x86_64
[] =
7252 "rax", "rdx", "rcx", "rbx",
7253 "rsi", "rdi", "rbp", "rsp",
7254 "r8", "r9", "r10", "r11",
7255 "r12", "r13", "r14", "r15",
7257 "xmm0", "xmm1", "xmm2", "xmm3",
7258 "xmm4", "xmm5", "xmm6", "xmm7",
7259 "xmm8", "xmm9", "xmm10", "xmm11",
7260 "xmm12", "xmm13", "xmm14", "xmm15",
7261 "st0", "st1", "st2", "st3",
7262 "st4", "st5", "st6", "st7",
7263 "mm0", "mm1", "mm2", "mm3",
7264 "mm4", "mm5", "mm6", "mm7",
7266 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7267 "fs.base", "gs.base", NULL
, NULL
,
7269 "mxcsr", "fcw", "fsw",
7270 "xmm16", "xmm17", "xmm18", "xmm19",
7271 "xmm20", "xmm21", "xmm22", "xmm23",
7272 "xmm24", "xmm25", "xmm26", "xmm27",
7273 "xmm28", "xmm29", "xmm30", "xmm31",
7274 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7275 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7276 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7277 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7278 NULL
, NULL
, NULL
, /* 115 - 117 */
7279 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7283 init_dwarf_regnames_x86_64 (void)
7285 dwarf_regnames
= dwarf_regnames_x86_64
;
7286 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7287 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7290 static const char *const dwarf_regnames_aarch64
[] =
7292 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7293 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7294 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7295 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7296 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7297 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7298 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7299 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7300 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7301 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7302 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7303 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7304 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7305 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7306 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7307 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7311 init_dwarf_regnames_aarch64 (void)
7313 dwarf_regnames
= dwarf_regnames_aarch64
;
7314 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7315 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7318 static const char *const dwarf_regnames_s390
[] =
7320 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7321 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7322 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7323 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7324 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7325 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7326 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7327 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7328 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7331 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7332 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7336 init_dwarf_regnames_s390 (void)
7338 dwarf_regnames
= dwarf_regnames_s390
;
7339 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7340 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7343 static const char *const dwarf_regnames_riscv
[] =
7345 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7346 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7347 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7348 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7349 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7350 "fs0", "fs1", /* 40 - 41 */
7351 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7352 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7353 "fs10", "fs11", /* 58 - 59 */
7354 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7357 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
7358 the large number of CSRs. */
7361 regname_internal_riscv (unsigned int regno
)
7363 const char *name
= NULL
;
7365 /* Lookup in the table first, this covers GPR and FPR. */
7366 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
7367 name
= dwarf_regnames_riscv
[regno
];
7368 else if (regno
>= 4096 && regno
<= 8191)
7370 /* This might be a CSR, these live in a sparse number space from 4096
7371 to 8191 These numbers are defined in the RISC-V ELF ABI
7375 #define DECLARE_CSR(NAME,VALUE) case VALUE + 4096: name = #NAME; break;
7376 #include "opcode/riscv-opc.h"
7381 static char csr_name
[10];
7382 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7393 init_dwarf_regnames_riscv (void)
7395 dwarf_regnames
= NULL
;
7396 dwarf_regnames_count
= 8192;
7397 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7401 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7403 dwarf_regnames_lookup_func
= NULL
;
7408 init_dwarf_regnames_i386 ();
7412 init_dwarf_regnames_iamcu ();
7418 init_dwarf_regnames_x86_64 ();
7422 init_dwarf_regnames_aarch64 ();
7426 init_dwarf_regnames_s390 ();
7430 init_dwarf_regnames_riscv ();
7438 /* Initialize the DWARF register name lookup state based on the
7439 architecture and specific machine type of a BFD. */
7442 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7445 dwarf_regnames_lookup_func
= NULL
;
7452 case bfd_mach_x86_64
:
7453 case bfd_mach_x86_64_intel_syntax
:
7454 case bfd_mach_x86_64_nacl
:
7455 case bfd_mach_x64_32
:
7456 case bfd_mach_x64_32_intel_syntax
:
7457 case bfd_mach_x64_32_nacl
:
7458 init_dwarf_regnames_x86_64 ();
7462 init_dwarf_regnames_i386 ();
7467 case bfd_arch_iamcu
:
7468 init_dwarf_regnames_iamcu ();
7471 case bfd_arch_aarch64
:
7472 init_dwarf_regnames_aarch64();
7476 init_dwarf_regnames_s390 ();
7479 case bfd_arch_riscv
:
7480 init_dwarf_regnames_riscv ();
7489 regname_internal_by_table_only (unsigned int regno
)
7491 if (dwarf_regnames
!= NULL
7492 && regno
< dwarf_regnames_count
7493 && dwarf_regnames
[regno
] != NULL
)
7494 return dwarf_regnames
[regno
];
7500 regname (unsigned int regno
, int name_only_p
)
7502 static char reg
[64];
7504 const char *name
= NULL
;
7506 if (dwarf_regnames_lookup_func
!= NULL
)
7507 name
= dwarf_regnames_lookup_func (regno
);
7513 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7516 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7521 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7526 if (*max_regs
!= fc
->ncols
)
7527 *max_regs
= fc
->ncols
;
7529 if (*need_col_headers
)
7531 static const char *sloc
= " LOC";
7533 *need_col_headers
= 0;
7535 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7537 for (r
= 0; r
< *max_regs
; r
++)
7538 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7543 printf ("%-5s ", regname (r
, 1));
7549 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7551 strcpy (tmp
, "exp");
7553 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7554 printf ("%-8s ", tmp
);
7556 for (r
= 0; r
< fc
->ncols
; r
++)
7558 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7560 switch (fc
->col_type
[r
])
7562 case DW_CFA_undefined
:
7565 case DW_CFA_same_value
:
7569 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7571 case DW_CFA_val_offset
:
7572 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7574 case DW_CFA_register
:
7575 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7577 case DW_CFA_expression
:
7578 strcpy (tmp
, "exp");
7580 case DW_CFA_val_expression
:
7581 strcpy (tmp
, "vexp");
7584 strcpy (tmp
, "n/a");
7587 printf ("%-5s ", tmp
);
7593 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7595 static unsigned char *
7596 read_cie (unsigned char *start
, unsigned char *end
,
7597 Frame_Chunk
**p_cie
, int *p_version
,
7598 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7602 unsigned char *augmentation_data
= NULL
;
7603 bfd_size_type augmentation_data_len
= 0;
7606 /* PR 17512: file: 001-228113-0.004. */
7610 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7611 memset (fc
, 0, sizeof (Frame_Chunk
));
7613 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7614 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7618 fc
->augmentation
= (char *) start
;
7619 /* PR 17512: file: 001-228113-0.004.
7620 Skip past augmentation name, but avoid running off the end of the data. */
7622 if (* start
++ == '\0')
7626 warn (_("No terminator for augmentation name\n"));
7630 if (strcmp (fc
->augmentation
, "eh") == 0)
7631 start
+= eh_addr_size
;
7635 GET (fc
->ptr_size
, 1);
7636 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7638 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7642 GET (fc
->segment_size
, 1);
7643 /* PR 17512: file: e99d2804. */
7644 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7646 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7650 eh_addr_size
= fc
->ptr_size
;
7654 fc
->ptr_size
= eh_addr_size
;
7655 fc
->segment_size
= 0;
7658 READ_ULEB (fc
->code_factor
, start
, end
);
7659 READ_SLEB (fc
->data_factor
, start
, end
);
7667 READ_ULEB (fc
->ra
, start
, end
);
7670 if (fc
->augmentation
[0] == 'z')
7672 READ_ULEB (augmentation_data_len
, start
, end
);
7673 augmentation_data
= start
;
7674 /* PR 17512: file: 11042-2589-0.004. */
7675 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7677 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7678 dwarf_vmatoa ("x", augmentation_data_len
),
7679 (unsigned long) (end
- start
));
7682 start
+= augmentation_data_len
;
7685 if (augmentation_data_len
)
7689 unsigned char *qend
;
7691 p
= (unsigned char *) fc
->augmentation
+ 1;
7692 q
= augmentation_data
;
7693 qend
= q
+ augmentation_data_len
;
7695 while (p
< end
&& q
< qend
)
7700 q
+= 1 + size_of_encoded_value (*q
);
7702 fc
->fde_encoding
= *q
++;
7711 /* Note - it is OK if this loop terminates with q < qend.
7712 Padding may have been inserted to align the end of the CIE. */
7717 *p_version
= version
;
7720 *p_aug_len
= augmentation_data_len
;
7721 *p_aug
= augmentation_data
;
7726 free (fc
->col_offset
);
7727 free (fc
->col_type
);
7732 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7733 If do_wide is not enabled, then formats the output to fit into 80 columns.
7734 PRINTED contains the number of characters already written to the current
7738 display_data (bfd_size_type printed
,
7739 const unsigned char * data
,
7740 const bfd_size_type len
)
7742 if (do_wide
|| len
< ((80 - printed
) / 3))
7743 for (printed
= 0; printed
< len
; ++printed
)
7744 printf (" %02x", data
[printed
]);
7747 for (printed
= 0; printed
< len
; ++printed
)
7749 if (printed
% (80 / 3) == 0)
7751 printf (" %02x", data
[printed
]);
7756 /* Prints out the contents on the augmentation data array.
7757 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7760 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7764 i
= printf (_(" Augmentation data: "));
7765 display_data (i
, data
, len
);
7769 display_debug_frames (struct dwarf_section
*section
,
7770 void *file ATTRIBUTE_UNUSED
)
7772 unsigned char *start
= section
->start
;
7773 unsigned char *end
= start
+ section
->size
;
7774 unsigned char *section_start
= start
;
7775 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7776 Frame_Chunk
*remembered_state
= NULL
;
7778 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7779 unsigned int max_regs
= 0;
7780 const char *bad_reg
= _("bad register: ");
7781 unsigned int saved_eh_addr_size
= eh_addr_size
;
7783 introduce (section
, FALSE
);
7787 unsigned char *saved_start
;
7788 unsigned char *block_end
;
7793 int need_col_headers
= 1;
7794 unsigned char *augmentation_data
= NULL
;
7795 bfd_size_type augmentation_data_len
= 0;
7796 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7797 unsigned int offset_size
;
7798 unsigned int initial_length_size
;
7799 bfd_boolean all_nops
;
7801 saved_start
= start
;
7803 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7807 printf ("\n%08lx ZERO terminator\n\n",
7808 (unsigned long)(saved_start
- section_start
));
7809 /* Skip any zero terminators that directly follow.
7810 A corrupt section size could have loaded a whole
7811 slew of zero filled memory bytes. eg
7812 PR 17512: file: 070-19381-0.004. */
7813 while (start
< end
&& * start
== 0)
7818 if (length
== 0xffffffff)
7820 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7822 initial_length_size
= 12;
7827 initial_length_size
= 4;
7830 block_end
= saved_start
+ length
+ initial_length_size
;
7831 if (block_end
> end
|| block_end
< start
)
7833 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7834 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7835 (unsigned long) (saved_start
- section_start
));
7839 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7841 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7842 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7847 start
= read_cie (start
, end
, &cie
, &version
,
7848 &augmentation_data_len
, &augmentation_data
);
7849 /* PR 17512: file: 027-135133-0.005. */
7856 fc
->chunk_start
= saved_start
;
7857 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7860 if (frame_need_space (fc
, mreg
) < 0)
7862 if (fc
->fde_encoding
)
7863 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7865 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7866 print_dwarf_vma (length
, fc
->ptr_size
);
7867 print_dwarf_vma (cie_id
, offset_size
);
7869 if (do_debug_frames_interp
)
7871 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7872 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7877 printf (" Version: %d\n", version
);
7878 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7881 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7882 printf (" Segment Size: %u\n", fc
->segment_size
);
7884 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7885 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7886 printf (" Return address column: %d\n", fc
->ra
);
7888 if (augmentation_data_len
)
7889 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7896 unsigned char *look_for
;
7897 static Frame_Chunk fde_fc
;
7898 unsigned long segment_selector
;
7902 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7903 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7906 look_for
= section_start
+ cie_id
;
7908 if (look_for
<= saved_start
)
7910 for (cie
= chunks
; cie
; cie
= cie
->next
)
7911 if (cie
->chunk_start
== look_for
)
7916 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7917 if (cie
->chunk_start
== look_for
)
7921 unsigned int off_size
;
7922 unsigned char *cie_scan
;
7924 cie_scan
= look_for
;
7926 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7927 if (length
== 0xffffffff)
7929 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7936 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7939 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7940 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7945 read_cie (cie_scan
, end
, &cie
, &version
,
7946 &augmentation_data_len
, &augmentation_data
);
7947 /* PR 17512: file: 3450-2098-0.004. */
7950 warn (_("Failed to read CIE information\n"));
7953 cie
->next
= forward_refs
;
7955 cie
->chunk_start
= look_for
;
7956 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7959 if (frame_need_space (cie
, mreg
) < 0)
7961 warn (_("Invalid max register\n"));
7964 if (cie
->fde_encoding
)
7966 = size_of_encoded_value (cie
->fde_encoding
);
7973 memset (fc
, 0, sizeof (Frame_Chunk
));
7977 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7978 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7979 (unsigned long) (saved_start
- section_start
));
7981 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7982 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7983 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
7985 warn (_("Invalid max register\n"));
7989 fc
->augmentation
= "";
7990 fc
->fde_encoding
= 0;
7991 fc
->ptr_size
= eh_addr_size
;
7992 fc
->segment_size
= 0;
7996 fc
->ncols
= cie
->ncols
;
7997 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
7998 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
7999 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8000 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8001 fc
->augmentation
= cie
->augmentation
;
8002 fc
->ptr_size
= cie
->ptr_size
;
8003 eh_addr_size
= cie
->ptr_size
;
8004 fc
->segment_size
= cie
->segment_size
;
8005 fc
->code_factor
= cie
->code_factor
;
8006 fc
->data_factor
= cie
->data_factor
;
8007 fc
->cfa_reg
= cie
->cfa_reg
;
8008 fc
->cfa_offset
= cie
->cfa_offset
;
8010 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8012 warn (_("Invalid max register\n"));
8015 fc
->fde_encoding
= cie
->fde_encoding
;
8018 if (fc
->fde_encoding
)
8019 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8021 segment_selector
= 0;
8022 if (fc
->segment_size
)
8024 if (fc
->segment_size
> sizeof (segment_selector
))
8026 /* PR 17512: file: 9e196b3e. */
8027 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8028 fc
->segment_size
= 4;
8030 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8033 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8035 /* FIXME: It appears that sometimes the final pc_range value is
8036 encoded in less than encoded_ptr_size bytes. See the x86_64
8037 run of the "objcopy on compressed debug sections" test for an
8039 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8041 if (cie
->augmentation
[0] == 'z')
8043 READ_ULEB (augmentation_data_len
, start
, end
);
8044 augmentation_data
= start
;
8045 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8046 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8048 warn (_("Augmentation data too long: 0x%s, "
8049 "expected at most %#lx\n"),
8050 dwarf_vmatoa ("x", augmentation_data_len
),
8051 (unsigned long) (end
- start
));
8053 augmentation_data
= NULL
;
8054 augmentation_data_len
= 0;
8056 start
+= augmentation_data_len
;
8059 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8060 (unsigned long)(saved_start
- section_start
),
8061 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8062 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8063 (unsigned long)(cie
->chunk_start
- section_start
));
8065 if (fc
->segment_size
)
8066 printf ("%04lx:", segment_selector
);
8069 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8070 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8072 if (! do_debug_frames_interp
&& augmentation_data_len
)
8074 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8079 /* At this point, fc is the current chunk, cie (if any) is set, and
8080 we're about to interpret instructions for the chunk. */
8081 /* ??? At present we need to do this always, since this sizes the
8082 fc->col_type and fc->col_offset arrays, which we write into always.
8083 We should probably split the interpreted and non-interpreted bits
8084 into two different routines, since there's so much that doesn't
8085 really overlap between them. */
8086 if (1 || do_debug_frames_interp
)
8088 /* Start by making a pass over the chunk, allocating storage
8089 and taking note of what registers are used. */
8090 unsigned char *tmp
= start
;
8092 while (start
< block_end
)
8094 unsigned int reg
, op
, opa
;
8096 unsigned char * new_start
;
8103 /* Warning: if you add any more cases to this switch, be
8104 sure to add them to the corresponding switch below. */
8107 case DW_CFA_advance_loc
:
8110 SKIP_ULEB (start
, end
);
8111 if (frame_need_space (fc
, opa
) >= 0)
8112 fc
->col_type
[opa
] = DW_CFA_undefined
;
8114 case DW_CFA_restore
:
8115 if (frame_need_space (fc
, opa
) >= 0)
8116 fc
->col_type
[opa
] = DW_CFA_undefined
;
8118 case DW_CFA_set_loc
:
8119 start
+= encoded_ptr_size
;
8121 case DW_CFA_advance_loc1
:
8124 case DW_CFA_advance_loc2
:
8127 case DW_CFA_advance_loc4
:
8130 case DW_CFA_offset_extended
:
8131 case DW_CFA_val_offset
:
8132 READ_ULEB (reg
, start
, end
);
8133 SKIP_ULEB (start
, end
);
8134 if (frame_need_space (fc
, reg
) >= 0)
8135 fc
->col_type
[reg
] = DW_CFA_undefined
;
8137 case DW_CFA_restore_extended
:
8138 READ_ULEB (reg
, start
, end
);
8139 if (frame_need_space (fc
, reg
) >= 0)
8140 fc
->col_type
[reg
] = DW_CFA_undefined
;
8142 case DW_CFA_undefined
:
8143 READ_ULEB (reg
, start
, end
);
8144 if (frame_need_space (fc
, reg
) >= 0)
8145 fc
->col_type
[reg
] = DW_CFA_undefined
;
8147 case DW_CFA_same_value
:
8148 READ_ULEB (reg
, start
, end
);
8149 if (frame_need_space (fc
, reg
) >= 0)
8150 fc
->col_type
[reg
] = DW_CFA_undefined
;
8152 case DW_CFA_register
:
8153 READ_ULEB (reg
, start
, end
);
8154 SKIP_ULEB (start
, end
);
8155 if (frame_need_space (fc
, reg
) >= 0)
8156 fc
->col_type
[reg
] = DW_CFA_undefined
;
8158 case DW_CFA_def_cfa
:
8159 SKIP_ULEB (start
, end
);
8160 SKIP_ULEB (start
, end
);
8162 case DW_CFA_def_cfa_register
:
8163 SKIP_ULEB (start
, end
);
8165 case DW_CFA_def_cfa_offset
:
8166 SKIP_ULEB (start
, end
);
8168 case DW_CFA_def_cfa_expression
:
8169 READ_ULEB (temp
, start
, end
);
8170 new_start
= start
+ temp
;
8171 if (new_start
< start
)
8173 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8179 case DW_CFA_expression
:
8180 case DW_CFA_val_expression
:
8181 READ_ULEB (reg
, start
, end
);
8182 READ_ULEB (temp
, start
, end
);
8183 new_start
= start
+ temp
;
8184 if (new_start
< start
)
8186 /* PR 17512: file:306-192417-0.005. */
8187 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8192 if (frame_need_space (fc
, reg
) >= 0)
8193 fc
->col_type
[reg
] = DW_CFA_undefined
;
8195 case DW_CFA_offset_extended_sf
:
8196 case DW_CFA_val_offset_sf
:
8197 READ_ULEB (reg
, start
, end
);
8198 SKIP_SLEB (start
, end
);
8199 if (frame_need_space (fc
, reg
) >= 0)
8200 fc
->col_type
[reg
] = DW_CFA_undefined
;
8202 case DW_CFA_def_cfa_sf
:
8203 SKIP_ULEB (start
, end
);
8204 SKIP_SLEB (start
, end
);
8206 case DW_CFA_def_cfa_offset_sf
:
8207 SKIP_SLEB (start
, end
);
8209 case DW_CFA_MIPS_advance_loc8
:
8212 case DW_CFA_GNU_args_size
:
8213 SKIP_ULEB (start
, end
);
8215 case DW_CFA_GNU_negative_offset_extended
:
8216 READ_ULEB (reg
, start
, end
);
8217 SKIP_ULEB (start
, end
);
8218 if (frame_need_space (fc
, reg
) >= 0)
8219 fc
->col_type
[reg
] = DW_CFA_undefined
;
8230 /* Now we know what registers are used, make a second pass over
8231 the chunk, this time actually printing out the info. */
8233 while (start
< block_end
)
8235 unsigned char * tmp
;
8237 unsigned long ul
, roffs
;
8238 /* Note: It is tempting to use an unsigned long for 'reg' but there
8239 are various functions, notably frame_space_needed() that assume that
8240 reg is an unsigned int. */
8245 const char *reg_prefix
= "";
8252 /* Make a note if something other than DW_CFA_nop happens. */
8253 if (op
!= DW_CFA_nop
)
8256 /* Warning: if you add any more cases to this switch, be
8257 sure to add them to the corresponding switch above. */
8260 case DW_CFA_advance_loc
:
8261 if (do_debug_frames_interp
)
8262 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8264 printf (" DW_CFA_advance_loc: %d to %s\n",
8265 opa
* fc
->code_factor
,
8266 dwarf_vmatoa_1 (NULL
,
8267 fc
->pc_begin
+ opa
* fc
->code_factor
,
8269 fc
->pc_begin
+= opa
* fc
->code_factor
;
8273 READ_ULEB (roffs
, start
, end
);
8274 if (opa
>= (unsigned int) fc
->ncols
)
8275 reg_prefix
= bad_reg
;
8276 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8277 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8278 reg_prefix
, regname (opa
, 0),
8279 roffs
* fc
->data_factor
);
8280 if (*reg_prefix
== '\0')
8282 fc
->col_type
[opa
] = DW_CFA_offset
;
8283 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8287 case DW_CFA_restore
:
8288 if (opa
>= (unsigned int) fc
->ncols
)
8289 reg_prefix
= bad_reg
;
8290 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8291 printf (" DW_CFA_restore: %s%s\n",
8292 reg_prefix
, regname (opa
, 0));
8293 if (*reg_prefix
!= '\0')
8296 if (opa
>= (unsigned int) cie
->ncols
8297 || (do_debug_frames_interp
8298 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8300 fc
->col_type
[opa
] = DW_CFA_undefined
;
8301 fc
->col_offset
[opa
] = 0;
8305 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8306 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8310 case DW_CFA_set_loc
:
8311 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8312 if (do_debug_frames_interp
)
8313 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8315 printf (" DW_CFA_set_loc: %s\n",
8316 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8320 case DW_CFA_advance_loc1
:
8321 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8322 if (do_debug_frames_interp
)
8323 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8325 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8326 (unsigned long) (ofs
* fc
->code_factor
),
8327 dwarf_vmatoa_1 (NULL
,
8328 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8330 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8333 case DW_CFA_advance_loc2
:
8334 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8335 if (do_debug_frames_interp
)
8336 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8338 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8339 (unsigned long) (ofs
* fc
->code_factor
),
8340 dwarf_vmatoa_1 (NULL
,
8341 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8343 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8346 case DW_CFA_advance_loc4
:
8347 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8348 if (do_debug_frames_interp
)
8349 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8351 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8352 (unsigned long) (ofs
* fc
->code_factor
),
8353 dwarf_vmatoa_1 (NULL
,
8354 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8356 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8359 case DW_CFA_offset_extended
:
8360 READ_ULEB (reg
, start
, end
);
8361 READ_ULEB (roffs
, start
, end
);
8362 if (reg
>= (unsigned int) fc
->ncols
)
8363 reg_prefix
= bad_reg
;
8364 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8365 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8366 reg_prefix
, regname (reg
, 0),
8367 roffs
* fc
->data_factor
);
8368 if (*reg_prefix
== '\0')
8370 fc
->col_type
[reg
] = DW_CFA_offset
;
8371 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8375 case DW_CFA_val_offset
:
8376 READ_ULEB (reg
, start
, end
);
8377 READ_ULEB (roffs
, start
, end
);
8378 if (reg
>= (unsigned int) fc
->ncols
)
8379 reg_prefix
= bad_reg
;
8380 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8381 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8382 reg_prefix
, regname (reg
, 0),
8383 roffs
* fc
->data_factor
);
8384 if (*reg_prefix
== '\0')
8386 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8387 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8391 case DW_CFA_restore_extended
:
8392 READ_ULEB (reg
, start
, end
);
8393 if (reg
>= (unsigned int) fc
->ncols
)
8394 reg_prefix
= bad_reg
;
8395 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8396 printf (" DW_CFA_restore_extended: %s%s\n",
8397 reg_prefix
, regname (reg
, 0));
8398 if (*reg_prefix
!= '\0')
8401 if (reg
>= (unsigned int) cie
->ncols
)
8403 fc
->col_type
[reg
] = DW_CFA_undefined
;
8404 fc
->col_offset
[reg
] = 0;
8408 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8409 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8413 case DW_CFA_undefined
:
8414 READ_ULEB (reg
, 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_undefined: %s%s\n",
8419 reg_prefix
, regname (reg
, 0));
8420 if (*reg_prefix
== '\0')
8422 fc
->col_type
[reg
] = DW_CFA_undefined
;
8423 fc
->col_offset
[reg
] = 0;
8427 case DW_CFA_same_value
:
8428 READ_ULEB (reg
, start
, end
);
8429 if (reg
>= (unsigned int) fc
->ncols
)
8430 reg_prefix
= bad_reg
;
8431 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8432 printf (" DW_CFA_same_value: %s%s\n",
8433 reg_prefix
, regname (reg
, 0));
8434 if (*reg_prefix
== '\0')
8436 fc
->col_type
[reg
] = DW_CFA_same_value
;
8437 fc
->col_offset
[reg
] = 0;
8441 case DW_CFA_register
:
8442 READ_ULEB (reg
, start
, end
);
8443 READ_ULEB (roffs
, start
, end
);
8444 if (reg
>= (unsigned int) fc
->ncols
)
8445 reg_prefix
= bad_reg
;
8446 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8448 printf (" DW_CFA_register: %s%s in ",
8449 reg_prefix
, regname (reg
, 0));
8450 puts (regname (roffs
, 0));
8452 if (*reg_prefix
== '\0')
8454 fc
->col_type
[reg
] = DW_CFA_register
;
8455 fc
->col_offset
[reg
] = roffs
;
8459 case DW_CFA_remember_state
:
8460 if (! do_debug_frames_interp
)
8461 printf (" DW_CFA_remember_state\n");
8462 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8463 rs
->cfa_offset
= fc
->cfa_offset
;
8464 rs
->cfa_reg
= fc
->cfa_reg
;
8466 rs
->cfa_exp
= fc
->cfa_exp
;
8467 rs
->ncols
= fc
->ncols
;
8468 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8469 sizeof (* rs
->col_type
));
8470 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8471 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8472 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8473 rs
->next
= remembered_state
;
8474 remembered_state
= rs
;
8477 case DW_CFA_restore_state
:
8478 if (! do_debug_frames_interp
)
8479 printf (" DW_CFA_restore_state\n");
8480 rs
= remembered_state
;
8483 remembered_state
= rs
->next
;
8484 fc
->cfa_offset
= rs
->cfa_offset
;
8485 fc
->cfa_reg
= rs
->cfa_reg
;
8487 fc
->cfa_exp
= rs
->cfa_exp
;
8488 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8490 warn (_("Invalid column number in saved frame state\n"));
8494 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8495 memcpy (fc
->col_offset
, rs
->col_offset
,
8496 rs
->ncols
* sizeof (* rs
->col_offset
));
8497 free (rs
->col_type
);
8498 free (rs
->col_offset
);
8501 else if (do_debug_frames_interp
)
8502 printf ("Mismatched DW_CFA_restore_state\n");
8505 case DW_CFA_def_cfa
:
8506 READ_ULEB (fc
->cfa_reg
, start
, end
);
8507 READ_ULEB (fc
->cfa_offset
, start
, end
);
8509 if (! do_debug_frames_interp
)
8510 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8511 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8514 case DW_CFA_def_cfa_register
:
8515 READ_ULEB (fc
->cfa_reg
, start
, end
);
8517 if (! do_debug_frames_interp
)
8518 printf (" DW_CFA_def_cfa_register: %s\n",
8519 regname (fc
->cfa_reg
, 0));
8522 case DW_CFA_def_cfa_offset
:
8523 READ_ULEB (fc
->cfa_offset
, start
, end
);
8524 if (! do_debug_frames_interp
)
8525 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8529 if (! do_debug_frames_interp
)
8530 printf (" DW_CFA_nop\n");
8533 case DW_CFA_def_cfa_expression
:
8534 READ_ULEB (ul
, start
, end
);
8535 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8537 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8540 if (! do_debug_frames_interp
)
8542 printf (" DW_CFA_def_cfa_expression (");
8543 decode_location_expression (start
, eh_addr_size
, 0, -1,
8551 case DW_CFA_expression
:
8552 READ_ULEB (reg
, start
, end
);
8553 READ_ULEB (ul
, start
, end
);
8554 if (reg
>= (unsigned int) fc
->ncols
)
8555 reg_prefix
= bad_reg
;
8556 /* PR 17512: file: 069-133014-0.006. */
8557 /* PR 17512: file: 98c02eb4. */
8559 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8561 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8564 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8566 printf (" DW_CFA_expression: %s%s (",
8567 reg_prefix
, regname (reg
, 0));
8568 decode_location_expression (start
, eh_addr_size
, 0, -1,
8572 if (*reg_prefix
== '\0')
8573 fc
->col_type
[reg
] = DW_CFA_expression
;
8577 case DW_CFA_val_expression
:
8578 READ_ULEB (reg
, start
, end
);
8579 READ_ULEB (ul
, start
, end
);
8580 if (reg
>= (unsigned int) fc
->ncols
)
8581 reg_prefix
= bad_reg
;
8583 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8585 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8588 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8590 printf (" DW_CFA_val_expression: %s%s (",
8591 reg_prefix
, regname (reg
, 0));
8592 decode_location_expression (start
, eh_addr_size
, 0, -1,
8596 if (*reg_prefix
== '\0')
8597 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8601 case DW_CFA_offset_extended_sf
:
8602 READ_ULEB (reg
, start
, end
);
8603 READ_SLEB (l
, start
, end
);
8604 if (frame_need_space (fc
, reg
) < 0)
8605 reg_prefix
= bad_reg
;
8606 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8607 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8608 reg_prefix
, regname (reg
, 0),
8609 (long)(l
* fc
->data_factor
));
8610 if (*reg_prefix
== '\0')
8612 fc
->col_type
[reg
] = DW_CFA_offset
;
8613 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8617 case DW_CFA_val_offset_sf
:
8618 READ_ULEB (reg
, start
, end
);
8619 READ_SLEB (l
, start
, end
);
8620 if (frame_need_space (fc
, reg
) < 0)
8621 reg_prefix
= bad_reg
;
8622 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8623 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8624 reg_prefix
, regname (reg
, 0),
8625 (long)(l
* fc
->data_factor
));
8626 if (*reg_prefix
== '\0')
8628 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8629 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8633 case DW_CFA_def_cfa_sf
:
8634 READ_ULEB (fc
->cfa_reg
, start
, end
);
8635 READ_ULEB (fc
->cfa_offset
, start
, end
);
8636 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8638 if (! do_debug_frames_interp
)
8639 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8640 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8643 case DW_CFA_def_cfa_offset_sf
:
8644 READ_ULEB (fc
->cfa_offset
, start
, end
);
8645 fc
->cfa_offset
*= fc
->data_factor
;
8646 if (! do_debug_frames_interp
)
8647 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8650 case DW_CFA_MIPS_advance_loc8
:
8651 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8652 if (do_debug_frames_interp
)
8653 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8655 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8656 (unsigned long) (ofs
* fc
->code_factor
),
8657 dwarf_vmatoa_1 (NULL
,
8658 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8660 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8663 case DW_CFA_GNU_window_save
:
8664 if (! do_debug_frames_interp
)
8665 printf (" DW_CFA_GNU_window_save\n");
8668 case DW_CFA_GNU_args_size
:
8669 READ_ULEB (ul
, start
, end
);
8670 if (! do_debug_frames_interp
)
8671 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8674 case DW_CFA_GNU_negative_offset_extended
:
8675 READ_ULEB (reg
, start
, end
);
8676 READ_SLEB (l
, start
, end
);
8678 if (frame_need_space (fc
, reg
) < 0)
8679 reg_prefix
= bad_reg
;
8680 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8681 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8682 reg_prefix
, regname (reg
, 0),
8683 (long)(l
* fc
->data_factor
));
8684 if (*reg_prefix
== '\0')
8686 fc
->col_type
[reg
] = DW_CFA_offset
;
8687 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8692 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8693 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8695 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8700 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8701 if (do_debug_frames_interp
&& ! all_nops
)
8702 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8705 eh_addr_size
= saved_eh_addr_size
;
8710 while (remembered_state
!= NULL
)
8712 rs
= remembered_state
;
8713 remembered_state
= rs
->next
;
8714 free (rs
->col_type
);
8715 free (rs
->col_offset
);
8716 rs
->next
= NULL
; /* Paranoia. */
8720 while (chunks
!= NULL
)
8724 free (rs
->col_type
);
8725 free (rs
->col_offset
);
8726 rs
->next
= NULL
; /* Paranoia. */
8730 while (forward_refs
!= NULL
)
8733 forward_refs
= rs
->next
;
8734 free (rs
->col_type
);
8735 free (rs
->col_offset
);
8736 rs
->next
= NULL
; /* Paranoia. */
8746 display_debug_names (struct dwarf_section
*section
, void *file
)
8748 unsigned char *hdrptr
= section
->start
;
8749 dwarf_vma unit_length
;
8750 unsigned char *unit_start
;
8751 const unsigned char *const section_end
= section
->start
+ section
->size
;
8752 unsigned char *unit_end
;
8754 introduce (section
, FALSE
);
8756 load_debug_section_with_follow (str
, file
);
8758 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8760 unsigned int offset_size
;
8761 uint16_t dwarf_version
, padding
;
8762 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8763 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8764 uint32_t augmentation_string_size
;
8766 unsigned long sec_off
;
8767 bfd_boolean augmentation_printable
;
8768 const char *augmentation_string
;
8770 unit_start
= hdrptr
;
8772 /* Get and check the length of the block. */
8773 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8775 if (unit_length
== 0xffffffff)
8777 /* This section is 64-bit DWARF. */
8778 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8783 unit_end
= hdrptr
+ unit_length
;
8785 sec_off
= hdrptr
- section
->start
;
8786 if (sec_off
+ unit_length
< sec_off
8787 || sec_off
+ unit_length
> section
->size
)
8789 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8791 (unsigned long) (unit_start
- section
->start
),
8792 dwarf_vmatoa ("x", unit_length
));
8796 /* Get and check the version number. */
8797 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8798 printf (_("Version %ld\n"), (long) dwarf_version
);
8800 /* Prior versions did not exist, and future versions may not be
8801 backwards compatible. */
8802 if (dwarf_version
!= 5)
8804 warn (_("Only DWARF version 5 .debug_names "
8805 "is currently supported.\n"));
8809 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8811 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8814 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8815 if (comp_unit_count
== 0)
8816 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8818 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8819 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8820 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8821 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8822 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8824 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8825 if (augmentation_string_size
% 4 != 0)
8827 warn (_("Augmentation string length %u must be rounded up "
8828 "to a multiple of 4 in .debug_names.\n"),
8829 augmentation_string_size
);
8830 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8833 printf (_("Augmentation string:"));
8835 augmentation_printable
= TRUE
;
8836 augmentation_string
= (const char *) hdrptr
;
8838 for (i
= 0; i
< augmentation_string_size
; i
++)
8842 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8843 printf (" %02x", uc
);
8845 if (uc
!= 0 && !ISPRINT (uc
))
8846 augmentation_printable
= FALSE
;
8849 if (augmentation_printable
)
8853 i
< augmentation_string_size
&& augmentation_string
[i
];
8855 putchar (augmentation_string
[i
]);
8860 printf (_("CU table:\n"));
8861 for (i
= 0; i
< comp_unit_count
; i
++)
8865 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8866 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8870 printf (_("TU table:\n"));
8871 for (i
= 0; i
< local_type_unit_count
; i
++)
8875 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8876 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8880 printf (_("Foreign TU table:\n"));
8881 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8885 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8886 printf (_("[%3u] "), i
);
8887 print_dwarf_vma (signature
, 8);
8892 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8893 hdrptr
+= bucket_count
* sizeof (uint32_t);
8894 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8895 hdrptr
+= name_count
* sizeof (uint32_t);
8896 unsigned char *const name_table_string_offsets
= hdrptr
;
8897 hdrptr
+= name_count
* offset_size
;
8898 unsigned char *const name_table_entry_offsets
= hdrptr
;
8899 hdrptr
+= name_count
* offset_size
;
8900 unsigned char *const abbrev_table
= hdrptr
;
8901 hdrptr
+= abbrev_table_size
;
8902 const unsigned char *const abbrev_table_end
= hdrptr
;
8903 unsigned char *const entry_pool
= hdrptr
;
8904 if (hdrptr
> unit_end
)
8906 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8907 "for unit 0x%lx in the debug_names\n"),
8908 (long) (hdrptr
- section
->start
),
8909 (long) (unit_end
- section
->start
),
8910 (long) (unit_start
- section
->start
));
8914 size_t buckets_filled
= 0;
8916 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8918 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8923 printf (ngettext ("Used %zu of %lu bucket.\n",
8924 "Used %zu of %lu buckets.\n",
8926 buckets_filled
, (unsigned long) bucket_count
);
8928 uint32_t hash_prev
= 0;
8929 size_t hash_clash_count
= 0;
8930 size_t longest_clash
= 0;
8931 size_t this_length
= 0;
8933 for (hashi
= 0; hashi
< name_count
; hashi
++)
8935 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8939 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8943 longest_clash
= MAX (longest_clash
, this_length
);
8948 hash_prev
= hash_this
;
8950 printf (_("Out of %lu items there are %zu bucket clashes"
8951 " (longest of %zu entries).\n"),
8952 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
8953 assert (name_count
== buckets_filled
+ hash_clash_count
);
8955 struct abbrev_lookup_entry
8957 dwarf_vma abbrev_tag
;
8958 unsigned char *abbrev_lookup_ptr
;
8960 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
8961 size_t abbrev_lookup_used
= 0;
8962 size_t abbrev_lookup_allocated
= 0;
8964 unsigned char *abbrevptr
= abbrev_table
;
8967 dwarf_vma abbrev_tag
;
8969 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
8970 if (abbrev_tag
== 0)
8972 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
8974 abbrev_lookup_allocated
= MAX (0x100,
8975 abbrev_lookup_allocated
* 2);
8976 abbrev_lookup
= xrealloc (abbrev_lookup
,
8977 (abbrev_lookup_allocated
8978 * sizeof (*abbrev_lookup
)));
8980 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
8981 struct abbrev_lookup_entry
*entry
;
8982 for (entry
= abbrev_lookup
;
8983 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8985 if (entry
->abbrev_tag
== abbrev_tag
)
8987 warn (_("Duplicate abbreviation tag %lu "
8988 "in unit 0x%lx in the debug_names\n"),
8989 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
8992 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
8993 entry
->abbrev_tag
= abbrev_tag
;
8994 entry
->abbrev_lookup_ptr
= abbrevptr
;
8996 /* Skip DWARF tag. */
8997 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9000 dwarf_vma xindex
, form
;
9002 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9003 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9004 if (xindex
== 0 && form
== 0)
9009 printf (_("\nSymbol table:\n"));
9011 for (namei
= 0; namei
< name_count
; ++namei
)
9013 uint64_t string_offset
, entry_offset
;
9015 SAFE_BYTE_GET (string_offset
,
9016 name_table_string_offsets
+ namei
* offset_size
,
9017 offset_size
, unit_end
);
9018 SAFE_BYTE_GET (entry_offset
,
9019 name_table_entry_offsets
+ namei
* offset_size
,
9020 offset_size
, unit_end
);
9022 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9023 fetch_indirect_string (string_offset
));
9025 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9027 // We need to scan first whether there is a single or multiple
9028 // entries. TAGNO is -2 for the first entry, it is -1 for the
9029 // initial tag read of the second entry, then it becomes 0 for the
9030 // first entry for real printing etc.
9032 /* Initialize it due to a false compiler warning. */
9033 dwarf_vma second_abbrev_tag
= -1;
9036 dwarf_vma abbrev_tag
;
9037 dwarf_vma dwarf_tag
;
9038 const struct abbrev_lookup_entry
*entry
;
9040 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9043 second_abbrev_tag
= abbrev_tag
;
9045 entryptr
= entry_pool
+ entry_offset
;
9048 if (abbrev_tag
== 0)
9052 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9053 (unsigned long) abbrev_tag
);
9055 for (entry
= abbrev_lookup
;
9056 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9058 if (entry
->abbrev_tag
== abbrev_tag
)
9060 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9062 warn (_("Undefined abbreviation tag %lu "
9063 "in unit 0x%lx in the debug_names\n"),
9065 (long) (unit_start
- section
->start
));
9068 abbrevptr
= entry
->abbrev_lookup_ptr
;
9069 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9071 printf (" %s", get_TAG_name (dwarf_tag
));
9074 dwarf_vma xindex
, form
;
9076 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9077 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9078 if (xindex
== 0 && form
== 0)
9082 printf (" %s", get_IDX_name (xindex
));
9083 entryptr
= read_and_display_attr_value (0, form
, 0,
9084 unit_start
, entryptr
, unit_end
,
9086 dwarf_version
, NULL
,
9093 printf (_(" <no entries>"));
9097 free (abbrev_lookup
);
9104 display_debug_links (struct dwarf_section
* section
,
9105 void * file ATTRIBUTE_UNUSED
)
9107 const unsigned char * filename
;
9108 unsigned int filelen
;
9110 introduce (section
, FALSE
);
9112 /* The .gnu_debuglink section is formatted as:
9113 (c-string) Filename.
9114 (padding) If needed to reach a 4 byte boundary.
9115 (uint32_t) CRC32 value.
9117 The .gun_debugaltlink section is formatted as:
9118 (c-string) Filename.
9119 (binary) Build-ID. */
9121 filename
= section
->start
;
9122 filelen
= strnlen ((const char *) filename
, section
->size
);
9123 if (filelen
== section
->size
)
9125 warn (_("The debuglink filename is corrupt/missing\n"));
9129 printf (_(" Separate debug info file: %s\n"), filename
);
9131 if (const_strneq (section
->name
, ".gnu_debuglink"))
9134 unsigned int crc_offset
;
9136 crc_offset
= filelen
+ 1;
9137 crc_offset
= (crc_offset
+ 3) & ~3;
9138 if (crc_offset
+ 4 > section
->size
)
9140 warn (_("CRC offset missing/truncated\n"));
9144 crc32
= byte_get (filename
+ crc_offset
, 4);
9146 printf (_(" CRC value: %#x\n"), crc32
);
9148 if (crc_offset
+ 4 < section
->size
)
9150 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9151 (long)(section
->size
- (crc_offset
+ 4)));
9155 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9157 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9158 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9159 bfd_size_type printed
;
9161 /* FIXME: Should we support smaller build-id notes ? */
9162 if (build_id_len
< 0x14)
9164 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9168 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9169 display_data (printed
, build_id
, build_id_len
);
9178 display_gdb_index (struct dwarf_section
*section
,
9179 void *file ATTRIBUTE_UNUSED
)
9181 unsigned char *start
= section
->start
;
9183 uint32_t cu_list_offset
, tu_list_offset
;
9184 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9185 unsigned int cu_list_elements
, tu_list_elements
;
9186 unsigned int address_table_size
, symbol_table_slots
;
9187 unsigned char *cu_list
, *tu_list
;
9188 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9191 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9193 introduce (section
, FALSE
);
9195 if (section
->size
< 6 * sizeof (uint32_t))
9197 warn (_("Truncated header in the %s section.\n"), section
->name
);
9201 version
= byte_get_little_endian (start
, 4);
9202 printf (_("Version %ld\n"), (long) version
);
9204 /* Prior versions are obsolete, and future versions may not be
9205 backwards compatible. */
9206 if (version
< 3 || version
> 8)
9208 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9212 warn (_("The address table data in version 3 may be wrong.\n"));
9214 warn (_("Version 4 does not support case insensitive lookups.\n"));
9216 warn (_("Version 5 does not include inlined functions.\n"));
9218 warn (_("Version 6 does not include symbol attributes.\n"));
9219 /* Version 7 indices generated by Gold have bad type unit references,
9220 PR binutils/15021. But we don't know if the index was generated by
9221 Gold or not, so to avoid worrying users with gdb-generated indices
9222 we say nothing for version 7 here. */
9224 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9225 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9226 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9227 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9228 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9230 if (cu_list_offset
> section
->size
9231 || tu_list_offset
> section
->size
9232 || address_table_offset
> section
->size
9233 || symbol_table_offset
> section
->size
9234 || constant_pool_offset
> section
->size
)
9236 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9240 /* PR 17531: file: 418d0a8a. */
9241 if (tu_list_offset
< cu_list_offset
)
9243 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9244 tu_list_offset
, cu_list_offset
);
9248 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9250 if (address_table_offset
< tu_list_offset
)
9252 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9253 address_table_offset
, tu_list_offset
);
9257 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9259 /* PR 17531: file: 18a47d3d. */
9260 if (symbol_table_offset
< address_table_offset
)
9262 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9263 symbol_table_offset
, address_table_offset
);
9267 address_table_size
= symbol_table_offset
- address_table_offset
;
9269 if (constant_pool_offset
< symbol_table_offset
)
9271 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9272 constant_pool_offset
, symbol_table_offset
);
9276 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9278 cu_list
= start
+ cu_list_offset
;
9279 tu_list
= start
+ tu_list_offset
;
9280 address_table
= start
+ address_table_offset
;
9281 symbol_table
= start
+ symbol_table_offset
;
9282 constant_pool
= start
+ constant_pool_offset
;
9284 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9286 warn (_("Address table extends beyond end of section.\n"));
9290 printf (_("\nCU table:\n"));
9291 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9293 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9294 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9296 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9297 (unsigned long) cu_offset
,
9298 (unsigned long) (cu_offset
+ cu_length
- 1));
9301 printf (_("\nTU table:\n"));
9302 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9304 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9305 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9306 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9308 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9309 (unsigned long) tu_offset
,
9310 (unsigned long) type_offset
);
9311 print_dwarf_vma (signature
, 8);
9315 printf (_("\nAddress table:\n"));
9316 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9319 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9320 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9321 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9323 print_dwarf_vma (low
, 8);
9324 print_dwarf_vma (high
, 8);
9325 printf (_("%lu\n"), (unsigned long) cu_index
);
9328 printf (_("\nSymbol table:\n"));
9329 for (i
= 0; i
< symbol_table_slots
; ++i
)
9331 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9332 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9333 uint32_t num_cus
, cu
;
9335 if (name_offset
!= 0
9336 || cu_vector_offset
!= 0)
9339 unsigned char * adr
;
9341 adr
= constant_pool
+ name_offset
;
9342 /* PR 17531: file: 5b7b07ad. */
9343 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9345 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9346 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9350 printf ("[%3u] %.*s:", i
,
9351 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9352 constant_pool
+ name_offset
);
9354 adr
= constant_pool
+ cu_vector_offset
;
9355 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9357 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9358 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9359 cu_vector_offset
, i
);
9363 num_cus
= byte_get_little_endian (adr
, 4);
9365 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9366 if (num_cus
* 4 < num_cus
9367 || adr
>= section
->start
+ section
->size
9368 || adr
< constant_pool
)
9370 printf ("<invalid number of CUs: %d>\n", num_cus
);
9371 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9379 for (j
= 0; j
< num_cus
; ++j
)
9382 gdb_index_symbol_kind kind
;
9384 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9385 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9386 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9387 cu
= GDB_INDEX_CU_VALUE (cu
);
9388 /* Convert to TU number if it's for a type unit. */
9389 if (cu
>= cu_list_elements
/ 2)
9390 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9391 (unsigned long) (cu
- cu_list_elements
/ 2));
9393 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9395 printf (" [%s, %s]",
9396 is_static
? _("static") : _("global"),
9397 get_gdb_index_symbol_kind_name (kind
));
9409 /* Pre-allocate enough space for the CU/TU sets needed. */
9412 prealloc_cu_tu_list (unsigned int nshndx
)
9414 if (shndx_pool
== NULL
)
9416 shndx_pool_size
= nshndx
;
9417 shndx_pool_used
= 0;
9418 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9419 sizeof (unsigned int));
9423 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9424 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9425 sizeof (unsigned int));
9430 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9432 if (shndx_pool_used
>= shndx_pool_size
)
9434 error (_("Internal error: out of space in the shndx pool.\n"));
9437 shndx_pool
[shndx_pool_used
++] = shndx
;
9441 end_cu_tu_entry (void)
9443 if (shndx_pool_used
>= shndx_pool_size
)
9445 error (_("Internal error: out of space in the shndx pool.\n"));
9448 shndx_pool
[shndx_pool_used
++] = 0;
9451 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9454 get_DW_SECT_short_name (unsigned int dw_sect
)
9456 static char buf
[16];
9464 case DW_SECT_ABBREV
:
9470 case DW_SECT_STR_OFFSETS
:
9472 case DW_SECT_MACINFO
:
9480 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9484 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9485 These sections are extensions for Fission.
9486 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9489 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9491 unsigned char *phdr
= section
->start
;
9492 unsigned char *limit
= phdr
+ section
->size
;
9493 unsigned char *phash
;
9494 unsigned char *pindex
;
9495 unsigned char *ppool
;
9496 unsigned int version
;
9497 unsigned int ncols
= 0;
9499 unsigned int nslots
;
9502 dwarf_vma signature_high
;
9503 dwarf_vma signature_low
;
9506 /* PR 17512: file: 002-168123-0.004. */
9509 warn (_("Section %s is empty\n"), section
->name
);
9512 /* PR 17512: file: 002-376-0.004. */
9513 if (section
->size
< 24)
9515 warn (_("Section %s is too small to contain a CU/TU header\n"),
9520 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9522 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9523 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9524 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9527 pindex
= phash
+ (size_t) nslots
* 8;
9528 ppool
= pindex
+ (size_t) nslots
* 4;
9532 introduce (section
, FALSE
);
9534 printf (_(" Version: %u\n"), version
);
9536 printf (_(" Number of columns: %u\n"), ncols
);
9537 printf (_(" Number of used entries: %u\n"), nused
);
9538 printf (_(" Number of slots: %u\n\n"), nslots
);
9541 /* PR 17531: file: 45d69832. */
9542 if ((size_t) nslots
* 8 / 8 != nslots
9543 || phash
< phdr
|| phash
> limit
9544 || pindex
< phash
|| pindex
> limit
9545 || ppool
< pindex
|| ppool
> limit
)
9547 warn (ngettext ("Section %s is too small for %u slot\n",
9548 "Section %s is too small for %u slots\n",
9550 section
->name
, nslots
);
9557 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9558 for (i
= 0; i
< nslots
; i
++)
9560 unsigned char *shndx_list
;
9563 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9564 if (signature_high
!= 0 || signature_low
!= 0)
9566 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9567 shndx_list
= ppool
+ j
* 4;
9568 /* PR 17531: file: 705e010d. */
9569 if (shndx_list
< ppool
)
9571 warn (_("Section index pool located before start of section\n"));
9576 printf (_(" [%3d] Signature: 0x%s Sections: "),
9577 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9578 buf
, sizeof (buf
)));
9581 if (shndx_list
>= limit
)
9583 warn (_("Section %s too small for shndx pool\n"),
9587 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9591 printf (" %d", shndx
);
9593 add_shndx_to_cu_tu_entry (shndx
);
9605 else if (version
== 2)
9608 unsigned int dw_sect
;
9609 unsigned char *ph
= phash
;
9610 unsigned char *pi
= pindex
;
9611 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9612 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9613 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9614 bfd_boolean is_tu_index
;
9615 struct cu_tu_set
*this_set
= NULL
;
9617 unsigned char *prow
;
9619 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9621 /* PR 17531: file: 0dd159bf.
9622 Check for integer overflow (can occur when size_t is 32-bit)
9623 with overlarge ncols or nused values. */
9625 && ((size_t) ncols
* 4 / 4 != ncols
9626 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9627 || poffsets
< ppool
|| poffsets
> limit
9628 || psizes
< poffsets
|| psizes
> limit
9629 || pend
< psizes
|| pend
> limit
))
9631 warn (_("Section %s too small for offset and size tables\n"),
9638 printf (_(" Offset table\n"));
9639 printf (" slot %-16s ",
9640 is_tu_index
? _("signature") : _("dwo_id"));
9647 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9653 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9660 for (j
= 0; j
< ncols
; j
++)
9662 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9663 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9668 for (i
= 0; i
< nslots
; i
++)
9670 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9672 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9675 /* PR 17531: file: a05f6ab3. */
9678 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9685 size_t num_copy
= sizeof (uint64_t);
9687 /* PR 23064: Beware of buffer overflow. */
9688 if (ph
+ num_copy
< limit
)
9689 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9692 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9697 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9698 /* PR 17531: file: b8ce60a8. */
9699 if (prow
< poffsets
|| prow
> limit
)
9701 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9707 printf (_(" [%3d] 0x%s"),
9708 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9709 buf
, sizeof (buf
)));
9710 for (j
= 0; j
< ncols
; j
++)
9712 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9714 printf (" %8d", val
);
9717 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9719 /* PR 17531: file: 10796eb3. */
9720 if (dw_sect
>= DW_SECT_MAX
)
9721 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9723 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9739 printf (_(" Size table\n"));
9740 printf (" slot %-16s ",
9741 is_tu_index
? _("signature") : _("dwo_id"));
9744 for (j
= 0; j
< ncols
; j
++)
9746 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9748 printf (" %8s", get_DW_SECT_short_name (val
));
9754 for (i
= 0; i
< nslots
; i
++)
9756 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9758 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9761 prow
= psizes
+ (row
- 1) * ncols
* 4;
9764 printf (_(" [%3d] 0x%s"),
9765 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9766 buf
, sizeof (buf
)));
9768 for (j
= 0; j
< ncols
; j
++)
9770 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9772 printf (" %8d", val
);
9775 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9776 if (dw_sect
>= DW_SECT_MAX
)
9777 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9779 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9791 else if (do_display
)
9792 printf (_(" Unsupported version (%d)\n"), version
);
9800 /* Load the CU and TU indexes if present. This will build a list of
9801 section sets that we can use to associate a .debug_info.dwo section
9802 with its associated .debug_abbrev.dwo section in a .dwp file. */
9805 load_cu_tu_indexes (void *file
)
9807 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
9809 /* If we have already loaded (or tried to load) the CU and TU indexes
9810 then do not bother to repeat the task. */
9811 if (cu_tu_indexes_read
== -1)
9813 cu_tu_indexes_read
= TRUE
;
9815 if (load_debug_section_with_follow (dwp_cu_index
, file
))
9816 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
9817 cu_tu_indexes_read
= FALSE
;
9819 if (load_debug_section_with_follow (dwp_tu_index
, file
))
9820 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
9821 cu_tu_indexes_read
= FALSE
;
9824 return (bfd_boolean
) cu_tu_indexes_read
;
9827 /* Find the set of sections that includes section SHNDX. */
9830 find_cu_tu_set (void *file
, unsigned int shndx
)
9834 if (! load_cu_tu_indexes (file
))
9837 /* Find SHNDX in the shndx pool. */
9838 for (i
= 0; i
< shndx_pool_used
; i
++)
9839 if (shndx_pool
[i
] == shndx
)
9842 if (i
>= shndx_pool_used
)
9845 /* Now backup to find the first entry in the set. */
9846 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9849 return shndx_pool
+ i
;
9852 /* Display a .debug_cu_index or .debug_tu_index section. */
9855 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9857 return process_cu_tu_index (section
, 1);
9861 display_debug_not_supported (struct dwarf_section
*section
,
9862 void *file ATTRIBUTE_UNUSED
)
9864 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9870 /* Like malloc, but takes two parameters like calloc.
9871 Verifies that the first parameter is not too large.
9872 Note: does *not* initialise the allocated memory to zero. */
9875 cmalloc (size_t nmemb
, size_t size
)
9877 /* Check for overflow. */
9878 if (nmemb
>= ~(size_t) 0 / size
)
9881 return xmalloc (nmemb
* size
);
9884 /* Like xmalloc, but takes two parameters like calloc.
9885 Verifies that the first parameter is not too large.
9886 Note: does *not* initialise the allocated memory to zero. */
9889 xcmalloc (size_t nmemb
, size_t size
)
9891 /* Check for overflow. */
9892 if (nmemb
>= ~(size_t) 0 / size
)
9895 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9900 return xmalloc (nmemb
* size
);
9903 /* Like xrealloc, but takes three parameters.
9904 Verifies that the second parameter is not too large.
9905 Note: does *not* initialise any new memory to zero. */
9908 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9910 /* Check for overflow. */
9911 if (nmemb
>= ~(size_t) 0 / size
)
9913 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9918 return xrealloc (ptr
, nmemb
* size
);
9921 /* Like xcalloc, but verifies that the first parameter is not too large. */
9924 xcalloc2 (size_t nmemb
, size_t size
)
9926 /* Check for overflow. */
9927 if (nmemb
>= ~(size_t) 0 / size
)
9929 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9934 return xcalloc (nmemb
, size
);
9937 static unsigned long
9938 calc_gnu_debuglink_crc32 (unsigned long crc
,
9939 const unsigned char * buf
,
9942 static const unsigned long crc32_table
[256] =
9944 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
9945 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
9946 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
9947 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
9948 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
9949 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
9950 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
9951 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
9952 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
9953 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
9954 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
9955 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
9956 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
9957 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
9958 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
9959 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
9960 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
9961 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
9962 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
9963 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
9964 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
9965 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
9966 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
9967 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
9968 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
9969 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
9970 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
9971 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
9972 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
9973 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
9974 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
9975 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
9976 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
9977 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
9978 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
9979 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
9980 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
9981 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
9982 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
9983 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
9984 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
9985 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
9986 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
9987 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
9988 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
9989 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
9990 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
9991 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
9992 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
9993 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
9994 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
9997 const unsigned char *end
;
9999 crc
= ~crc
& 0xffffffff;
10000 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10001 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10002 return ~crc
& 0xffffffff;
10005 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10006 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10009 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10011 static unsigned char buffer
[8 * 1024];
10013 bfd_size_type count
;
10014 unsigned long crc
= 0;
10017 sep_data
= open_debug_file (pathname
);
10018 if (sep_data
== NULL
)
10021 /* Yes - we are opening the file twice... */
10022 f
= fopen (pathname
, "rb");
10025 /* Paranoia: This should never happen. */
10026 close_debug_file (sep_data
);
10027 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10031 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10032 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10036 if (crc
!= * (unsigned long *) crc_pointer
)
10038 close_debug_file (sep_data
);
10039 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10047 static const char *
10048 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10051 unsigned int crc_offset
;
10052 unsigned long * crc32
= (unsigned long *) data
;
10054 /* The name is first.
10055 The CRC value is stored after the filename, aligned up to 4 bytes. */
10056 name
= (const char *) section
->start
;
10059 crc_offset
= strnlen (name
, section
->size
) + 1;
10060 crc_offset
= (crc_offset
+ 3) & ~3;
10061 if (crc_offset
+ 4 > section
->size
)
10064 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10069 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10071 void * sep_data
= open_debug_file (filename
);
10073 if (sep_data
== NULL
)
10076 /* FIXME: We should now extract the build-id in the separate file
10082 typedef struct build_id_data
10085 const unsigned char * data
;
10088 static const char *
10089 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10092 bfd_size_type namelen
;
10093 bfd_size_type id_len
;
10094 Build_id_data
* build_id_data
;
10096 /* The name is first.
10097 The build-id follows immediately, with no padding, up to the section's end. */
10099 name
= (const char *) section
->start
;
10100 namelen
= strnlen (name
, section
->size
) + 1;
10101 if (namelen
>= section
->size
)
10104 id_len
= section
->size
- namelen
;
10108 build_id_data
= calloc (1, sizeof * build_id_data
);
10109 if (build_id_data
== NULL
)
10112 build_id_data
->len
= id_len
;
10113 build_id_data
->data
= section
->start
+ namelen
;
10115 * (Build_id_data
**) data
= build_id_data
;
10121 add_separate_debug_file (const char * filename
, void * handle
)
10123 separate_info
* i
= xmalloc (sizeof * i
);
10125 i
->filename
= filename
;
10126 i
->handle
= handle
;
10127 i
->next
= first_separate_info
;
10128 first_separate_info
= i
;
10132 load_separate_debug_info (const char * main_filename
,
10133 struct dwarf_section
* xlink
,
10134 parse_func_type parse_func
,
10135 check_func_type check_func
,
10138 const char * separate_filename
;
10139 char * debug_filename
;
10141 size_t canon_dirlen
;
10144 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10146 warn (_("Corrupt debuglink section: %s\n"),
10147 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10151 /* Attempt to locate the separate file.
10152 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10154 canon_dir
= lrealpath (main_filename
);
10156 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10157 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10159 canon_dir
[canon_dirlen
] = '\0';
10162 #define DEBUGDIR "/lib/debug"
10164 #ifndef EXTRA_DEBUG_ROOT1
10165 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10167 #ifndef EXTRA_DEBUG_ROOT2
10168 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10171 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10173 + strlen (".debug/")
10174 #ifdef EXTRA_DEBUG_ROOT1
10175 + strlen (EXTRA_DEBUG_ROOT1
)
10177 #ifdef EXTRA_DEBUG_ROOT2
10178 + strlen (EXTRA_DEBUG_ROOT2
)
10180 + strlen (separate_filename
)
10182 if (debug_filename
== NULL
)
10184 warn (_("Out of memory"));
10189 /* First try in the current directory. */
10190 sprintf (debug_filename
, "%s", separate_filename
);
10191 if (check_func (debug_filename
, func_data
))
10194 /* Then try in a subdirectory called .debug. */
10195 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10196 if (check_func (debug_filename
, func_data
))
10199 /* Then try in the same directory as the original file. */
10200 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10201 if (check_func (debug_filename
, func_data
))
10204 /* And the .debug subdirectory of that directory. */
10205 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10206 if (check_func (debug_filename
, func_data
))
10209 #ifdef EXTRA_DEBUG_ROOT1
10210 /* Try the first extra debug file root. */
10211 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10212 if (check_func (debug_filename
, func_data
))
10215 /* Try the first extra debug file root. */
10216 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10217 if (check_func (debug_filename
, func_data
))
10221 #ifdef EXTRA_DEBUG_ROOT2
10222 /* Try the second extra debug file root. */
10223 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10224 if (check_func (debug_filename
, func_data
))
10228 /* Then try in the global debug_filename directory. */
10229 strcpy (debug_filename
, DEBUGDIR
);
10230 dirlen
= strlen (DEBUGDIR
) - 1;
10231 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10232 strcat (debug_filename
, "/");
10233 strcat (debug_filename
, (const char *) separate_filename
);
10235 if (check_func (debug_filename
, func_data
))
10238 /* Failed to find the file. */
10239 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10240 warn (_("tried: %s\n"), debug_filename
);
10242 #ifdef EXTRA_DEBUG_ROOT2
10243 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10244 warn (_("tried: %s\n"), debug_filename
);
10247 #ifdef EXTRA_DEBUG_ROOT1
10248 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10249 warn (_("tried: %s\n"), debug_filename
);
10251 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10252 warn (_("tried: %s\n"), debug_filename
);
10255 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10256 warn (_("tried: %s\n"), debug_filename
);
10258 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10259 warn (_("tried: %s\n"), debug_filename
);
10261 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10262 warn (_("tried: %s\n"), debug_filename
);
10264 sprintf (debug_filename
, "%s", separate_filename
);
10265 warn (_("tried: %s\n"), debug_filename
);
10268 free (debug_filename
);
10274 void * debug_handle
;
10276 /* Now open the file.... */
10277 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10279 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10280 free (debug_filename
);
10284 /* FIXME: We do not check to see if there are any other separate debug info
10285 files that would also match. */
10287 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10288 add_separate_debug_file (debug_filename
, debug_handle
);
10290 /* Do not free debug_filename - it might be referenced inside
10291 the structure returned by open_debug_file(). */
10292 return debug_handle
;
10295 /* Attempt to load a separate dwarf object file. */
10298 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10300 char * separate_filename
;
10301 void * separate_handle
;
10303 /* FIXME: Skip adding / if dwo_dir ends in /. */
10304 separate_filename
= concat (dir
, "/", name
, NULL
);
10305 if (separate_filename
== NULL
)
10307 warn (_("Out of memory allocating dwo filename\n"));
10311 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10313 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10314 free (separate_filename
);
10318 /* FIXME: We should check the dwo_id. */
10320 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10321 add_separate_debug_file (separate_filename
, separate_handle
);
10322 /* Note - separate_filename will be freed in free_debug_memory(). */
10323 return separate_handle
;
10326 /* Load the separate debug info file(s) attached to FILE, if any exist.
10327 Returns TRUE if any were found, FALSE otherwise.
10328 If TRUE is returned then the linked list starting at first_separate_info
10329 will be populated with open file handles. */
10332 load_separate_debug_files (void * file
, const char * filename
)
10334 /* Skip this operation if we are not interested in debug links. */
10335 if (! do_follow_links
&& ! do_debug_links
)
10338 /* See if there are any dwo links. */
10339 if (load_debug_section (str
, file
)
10340 && load_debug_section (abbrev
, file
)
10341 && load_debug_section (info
, file
))
10345 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10347 bfd_boolean introduced
= FALSE
;
10349 const char * dir
= NULL
;
10350 const char * id
= NULL
;
10352 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10354 switch (dwinfo
->type
)
10357 if (do_debug_links
)
10361 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10362 debug_displays
[info
].section
.uncompressed_name
);
10366 printf (_(" Name: %s\n"), dwinfo
->value
);
10367 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10369 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10371 printf (_(" ID: <unknown>\n"));
10375 if (do_follow_links
)
10376 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10380 dir
= dwinfo
->value
;
10384 id
= dwinfo
->value
;
10388 error (_("Unexpected DWO INFO type"));
10395 if (! do_follow_links
)
10396 /* The other debug links will be displayed by display_debug_links()
10397 so we do not need to do any further processing here. */
10400 /* FIXME: We do not check for the presence of both link sections in the same file. */
10401 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10402 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10403 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10405 if (load_debug_section (gnu_debugaltlink
, file
))
10407 Build_id_data
* build_id_data
;
10409 load_separate_debug_info (filename
,
10410 & debug_displays
[gnu_debugaltlink
].section
,
10411 parse_gnu_debugaltlink
,
10412 check_gnu_debugaltlink
,
10416 if (load_debug_section (gnu_debuglink
, file
))
10418 unsigned long crc32
;
10420 load_separate_debug_info (filename
,
10421 & debug_displays
[gnu_debuglink
].section
,
10422 parse_gnu_debuglink
,
10423 check_gnu_debuglink
,
10427 if (first_separate_info
!= NULL
)
10430 do_follow_links
= 0;
10435 free_debug_memory (void)
10441 for (i
= 0; i
< max
; i
++)
10442 free_debug_section ((enum dwarf_section_display_enum
) i
);
10444 if (debug_information
!= NULL
)
10446 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10448 for (i
= 0; i
< num_debug_info_entries
; i
++)
10450 if (!debug_information
[i
].max_loc_offsets
)
10452 free (debug_information
[i
].loc_offsets
);
10453 free (debug_information
[i
].have_frame_base
);
10455 if (!debug_information
[i
].max_range_lists
)
10456 free (debug_information
[i
].range_lists
);
10459 free (debug_information
);
10460 debug_information
= NULL
;
10461 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10465 separate_info
* next
;
10467 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10469 close_debug_file (d
->handle
);
10470 free ((void *) d
->filename
);
10474 first_separate_info
= NULL
;
10480 dwarf_select_sections_by_names (const char *names
)
10484 const char * option
;
10488 debug_dump_long_opts
;
10490 static const debug_dump_long_opts opts_table
[] =
10492 /* Please keep this table alpha- sorted. */
10493 { "Ranges", & do_debug_ranges
, 1 },
10494 { "abbrev", & do_debug_abbrevs
, 1 },
10495 { "addr", & do_debug_addr
, 1 },
10496 { "aranges", & do_debug_aranges
, 1 },
10497 { "cu_index", & do_debug_cu_index
, 1 },
10498 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10499 { "follow-links", & do_follow_links
, 1 },
10500 { "frames", & do_debug_frames
, 1 },
10501 { "frames-interp", & do_debug_frames_interp
, 1 },
10502 /* The special .gdb_index section. */
10503 { "gdb_index", & do_gdb_index
, 1 },
10504 { "info", & do_debug_info
, 1 },
10505 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10506 { "links", & do_debug_links
, 1 },
10507 { "loc", & do_debug_loc
, 1 },
10508 { "macro", & do_debug_macinfo
, 1 },
10509 { "pubnames", & do_debug_pubnames
, 1 },
10510 { "pubtypes", & do_debug_pubtypes
, 1 },
10511 /* This entry is for compatibility
10512 with earlier versions of readelf. */
10513 { "ranges", & do_debug_aranges
, 1 },
10514 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10515 { "str", & do_debug_str
, 1 },
10516 /* These trace_* sections are used by Itanium VMS. */
10517 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10518 { "trace_aranges", & do_trace_aranges
, 1 },
10519 { "trace_info", & do_trace_info
, 1 },
10528 const debug_dump_long_opts
* entry
;
10530 for (entry
= opts_table
; entry
->option
; entry
++)
10532 size_t len
= strlen (entry
->option
);
10534 if (strncmp (p
, entry
->option
, len
) == 0
10535 && (p
[len
] == ',' || p
[len
] == '\0'))
10537 * entry
->variable
|= entry
->val
;
10539 /* The --debug-dump=frames-interp option also
10540 enables the --debug-dump=frames option. */
10541 if (do_debug_frames_interp
)
10542 do_debug_frames
= 1;
10549 if (entry
->option
== NULL
)
10551 warn (_("Unrecognized debug option '%s'\n"), p
);
10552 p
= strchr (p
, ',');
10563 dwarf_select_sections_by_letters (const char *letters
)
10565 unsigned int lindex
= 0;
10567 while (letters
[lindex
])
10568 switch (letters
[lindex
++])
10570 case 'A': do_debug_addr
= 1; break;
10571 case 'a': do_debug_abbrevs
= 1; break;
10572 case 'c': do_debug_cu_index
= 1; break;
10573 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10574 case 'f': do_debug_frames
= 1; break;
10575 case 'g': do_gdb_index
= 1; break;
10576 case 'i': do_debug_info
= 1; break;
10577 case 'K': do_follow_links
= 1; break;
10578 case 'k': do_debug_links
= 1; break;
10579 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10580 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10581 case 'm': do_debug_macinfo
= 1; break;
10582 case 'o': do_debug_loc
= 1; break;
10583 case 'p': do_debug_pubnames
= 1; break;
10584 case 'R': do_debug_ranges
= 1; break;
10585 case 'r': do_debug_aranges
= 1; break;
10586 case 's': do_debug_str
= 1; break;
10587 case 'T': do_trace_aranges
= 1; break;
10588 case 't': do_debug_pubtypes
= 1; break;
10589 case 'U': do_trace_info
= 1; break;
10590 case 'u': do_trace_abbrevs
= 1; break;
10593 warn (_("Unrecognized debug option '%s'\n"), letters
);
10599 dwarf_select_sections_all (void)
10602 do_debug_abbrevs
= 1;
10603 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10604 do_debug_pubnames
= 1;
10605 do_debug_pubtypes
= 1;
10606 do_debug_aranges
= 1;
10607 do_debug_ranges
= 1;
10608 do_debug_frames
= 1;
10609 do_debug_macinfo
= 1;
10614 do_trace_abbrevs
= 1;
10615 do_trace_aranges
= 1;
10617 do_debug_cu_index
= 1;
10618 do_follow_links
= 1;
10619 do_debug_links
= 1;
10622 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10623 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10625 /* N.B. The order here must match the order in section_display_enum. */
10627 struct dwarf_section_display debug_displays
[] =
10629 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10630 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10631 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10632 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10633 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10634 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10635 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10636 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10637 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10638 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10639 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10640 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10641 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10642 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10643 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10644 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10645 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10646 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10647 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10648 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10649 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10650 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10651 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10652 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10653 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10654 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10655 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10656 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10657 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10658 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10659 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10660 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10661 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10662 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10663 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10664 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10665 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10666 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10667 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10668 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10669 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10670 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10671 /* Separate debug info files can containt their own .debug_str section,
10672 and this might be in *addition* to a .debug_str section already present
10673 in the main file. Hence we need to have two entries for .debug_str. */
10674 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10677 /* A static assertion. */
10678 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];