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 No bytes will be read at address END or beyond. */
325 read_leb128 (unsigned char *data
,
326 unsigned int *length_return
,
328 const unsigned char * const end
)
330 dwarf_vma result
= 0;
331 unsigned int num_read
= 0;
332 unsigned int shift
= 0;
333 unsigned char byte
= 0;
340 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
343 if ((byte
& 0x80) == 0)
346 /* PR 17512: file: 0ca183b8.
347 FIXME: Should we signal this error somehow ? */
348 if (shift
>= sizeof (result
) * 8)
352 if (length_return
!= NULL
)
353 *length_return
= num_read
;
355 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
356 result
|= -((dwarf_vma
) 1 << shift
);
361 /* Create a signed version to avoid painful typecasts. */
362 static inline dwarf_signed_vma
363 read_sleb128 (unsigned char * data
,
364 unsigned int * length_return
,
365 const unsigned char * const end
)
367 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
370 static inline dwarf_vma
371 read_uleb128 (unsigned char * data
,
372 unsigned int * length_return
,
373 const unsigned char * const end
)
375 return read_leb128 (data
, length_return
, FALSE
, end
);
378 #define SKIP_ULEB() read_uleb128 (start, & length_return, end); start += length_return
379 #define SKIP_SLEB() read_sleb128 (start, & length_return, end); start += length_return
381 #define READ_ULEB(var) \
386 (var) = _val = read_uleb128 (start, &length_return, end); \
388 error (_("Internal error: %s:%d: LEB value (%s) " \
389 "too large for containing variable\n"), \
390 __FILE__, __LINE__, dwarf_vmatoa ("u", _val)); \
391 start += length_return; \
395 #define READ_SLEB(var) \
398 dwarf_signed_vma _val; \
400 (var) = _val = read_sleb128 (start, &length_return, end); \
402 error (_("Internal error: %s:%d: LEB value (%s) " \
403 "too large for containing variable\n"), \
404 __FILE__, __LINE__, dwarf_vmatoa ("d", _val)); \
405 start += length_return; \
409 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
410 Checks to make sure that the read will not reach or pass END
411 and that VAL is big enough to hold AMOUNT bytes. */
412 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
415 unsigned int amount = (AMOUNT); \
416 if (sizeof (VAL) < amount) \
418 error (ngettext ("internal error: attempt to read %d byte " \
419 "of data in to %d sized variable", \
420 "internal error: attempt to read %d bytes " \
421 "of data in to %d sized variable", \
423 amount, (int) sizeof (VAL)); \
424 amount = sizeof (VAL); \
426 if (((PTR) + amount) >= (END)) \
429 amount = (END) - (PTR); \
433 if (amount == 0 || amount > 8) \
436 VAL = byte_get ((PTR), amount); \
440 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */
441 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
444 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
449 /* Like SAFE_BYTE_GET, but reads a signed value. */
450 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
453 unsigned int amount = (AMOUNT); \
454 if (((PTR) + amount) >= (END)) \
457 amount = (END) - (PTR); \
462 VAL = byte_get_signed ((PTR), amount); \
468 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */
469 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
472 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
477 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
480 if (((PTR) + 8) <= (END)) \
482 byte_get_64 ((PTR), (HIGH), (LOW)); \
486 * (LOW) = * (HIGH) = 0; \
491 typedef struct State_Machine_Registers
500 unsigned char op_index
;
501 unsigned char end_sequence
;
502 /* This variable hold the number of the last entry seen
503 in the File Table. */
504 unsigned int last_file_entry
;
507 static SMR state_machine_regs
;
510 reset_state_machine (int is_stmt
)
512 state_machine_regs
.address
= 0;
513 state_machine_regs
.view
= 0;
514 state_machine_regs
.op_index
= 0;
515 state_machine_regs
.file
= 1;
516 state_machine_regs
.line
= 1;
517 state_machine_regs
.column
= 0;
518 state_machine_regs
.is_stmt
= is_stmt
;
519 state_machine_regs
.basic_block
= 0;
520 state_machine_regs
.end_sequence
= 0;
521 state_machine_regs
.last_file_entry
= 0;
524 /* Handled an extend line op.
525 Returns the number of bytes read. */
528 process_extended_line_op (unsigned char * data
,
532 unsigned char op_code
;
533 unsigned int bytes_read
;
536 unsigned char *orig_data
= data
;
539 len
= read_uleb128 (data
, & bytes_read
, end
);
542 if (len
== 0 || data
== end
|| len
> (uintptr_t) (end
- data
))
544 warn (_("Badly formed extended line op encountered!\n"));
551 printf (_(" Extended opcode %d: "), op_code
);
555 case DW_LNE_end_sequence
:
556 printf (_("End of Sequence\n\n"));
557 reset_state_machine (is_stmt
);
560 case DW_LNE_set_address
:
561 /* PR 17512: file: 002-100480-0.004. */
562 if (len
- bytes_read
- 1 > 8)
564 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
565 len
- bytes_read
- 1);
569 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
570 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
571 state_machine_regs
.address
= adr
;
572 state_machine_regs
.view
= 0;
573 state_machine_regs
.op_index
= 0;
576 case DW_LNE_define_file
:
577 printf (_("define new File Table entry\n"));
578 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
579 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
585 l
= strnlen ((char *) data
, end
- data
);
587 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
589 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
591 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
593 printf ("%.*s\n\n", (int) l
, name
);
596 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
597 warn (_("DW_LNE_define_file: Bad opcode length\n"));
600 case DW_LNE_set_discriminator
:
601 printf (_("set Discriminator to %s\n"),
602 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
606 case DW_LNE_HP_negate_is_UV_update
:
607 printf ("DW_LNE_HP_negate_is_UV_update\n");
609 case DW_LNE_HP_push_context
:
610 printf ("DW_LNE_HP_push_context\n");
612 case DW_LNE_HP_pop_context
:
613 printf ("DW_LNE_HP_pop_context\n");
615 case DW_LNE_HP_set_file_line_column
:
616 printf ("DW_LNE_HP_set_file_line_column\n");
618 case DW_LNE_HP_set_routine_name
:
619 printf ("DW_LNE_HP_set_routine_name\n");
621 case DW_LNE_HP_set_sequence
:
622 printf ("DW_LNE_HP_set_sequence\n");
624 case DW_LNE_HP_negate_post_semantics
:
625 printf ("DW_LNE_HP_negate_post_semantics\n");
627 case DW_LNE_HP_negate_function_exit
:
628 printf ("DW_LNE_HP_negate_function_exit\n");
630 case DW_LNE_HP_negate_front_end_logical
:
631 printf ("DW_LNE_HP_negate_front_end_logical\n");
633 case DW_LNE_HP_define_proc
:
634 printf ("DW_LNE_HP_define_proc\n");
636 case DW_LNE_HP_source_file_correlation
:
638 unsigned char *edata
= data
+ len
- bytes_read
- 1;
640 printf ("DW_LNE_HP_source_file_correlation\n");
646 opc
= read_uleb128 (data
, & bytes_read
, edata
);
651 case DW_LNE_HP_SFC_formfeed
:
652 printf (" DW_LNE_HP_SFC_formfeed\n");
654 case DW_LNE_HP_SFC_set_listing_line
:
655 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
657 read_uleb128 (data
, & bytes_read
, edata
)));
660 case DW_LNE_HP_SFC_associate
:
661 printf (" DW_LNE_HP_SFC_associate ");
664 read_uleb128 (data
, & bytes_read
, edata
)));
668 read_uleb128 (data
, & bytes_read
, edata
)));
672 read_uleb128 (data
, & bytes_read
, edata
)));
676 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
686 unsigned int rlen
= len
- bytes_read
- 1;
688 if (op_code
>= DW_LNE_lo_user
689 /* The test against DW_LNW_hi_user is redundant due to
690 the limited range of the unsigned char data type used
692 /*&& op_code <= DW_LNE_hi_user*/)
693 printf (_("user defined: "));
695 printf (_("UNKNOWN: "));
696 printf (_("length %d ["), rlen
);
698 printf (" %02x", *data
++);
707 static const unsigned char *
708 fetch_indirect_string (dwarf_vma offset
)
710 struct dwarf_section
*section
= &debug_displays
[str
].section
;
711 const unsigned char * ret
;
713 if (section
->start
== NULL
)
714 return (const unsigned char *) _("<no .debug_str section>");
716 if (offset
>= section
->size
)
718 warn (_("DW_FORM_strp offset too big: %s\n"),
719 dwarf_vmatoa ("x", offset
));
720 return (const unsigned char *) _("<offset is too big>");
723 ret
= section
->start
+ offset
;
724 /* Unfortunately we cannot rely upon the .debug_str section ending with a
725 NUL byte. Since our caller is expecting to receive a well formed C
726 string we test for the lack of a terminating byte here. */
727 if (strnlen ((const char *) ret
, section
->size
- offset
)
728 == section
->size
- offset
)
729 ret
= (const unsigned char *)
730 _("<no NUL byte at end of .debug_str section>");
735 static const unsigned char *
736 fetch_indirect_line_string (dwarf_vma offset
)
738 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
739 const unsigned char * ret
;
741 if (section
->start
== NULL
)
742 return (const unsigned char *) _("<no .debug_line_str section>");
744 if (offset
>= section
->size
)
746 warn (_("DW_FORM_line_strp offset too big: %s\n"),
747 dwarf_vmatoa ("x", offset
));
748 return (const unsigned char *) _("<offset is too big>");
751 ret
= section
->start
+ offset
;
752 /* Unfortunately we cannot rely upon the .debug_line_str section ending
753 with a NUL byte. Since our caller is expecting to receive a well formed
754 C string we test for the lack of a terminating byte here. */
755 if (strnlen ((const char *) ret
, section
->size
- offset
)
756 == section
->size
- offset
)
757 ret
= (const unsigned char *)
758 _("<no NUL byte at end of .debug_line_str section>");
764 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
765 dwarf_vma offset_size
, bfd_boolean dwo
)
767 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
768 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
769 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
770 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
771 dwarf_vma index_offset
= idx
* offset_size
;
772 dwarf_vma str_offset
;
775 if (index_section
->start
== NULL
)
776 return (dwo
? _("<no .debug_str_offsets.dwo section>")
777 : _("<no .debug_str_offsets section>"));
779 if (this_set
!= NULL
)
780 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
781 if (index_offset
>= index_section
->size
)
783 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
784 dwarf_vmatoa ("x", index_offset
));
785 return _("<index offset is too big>");
788 if (str_section
->start
== NULL
)
789 return (dwo
? _("<no .debug_str.dwo section>")
790 : _("<no .debug_str section>"));
792 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
793 str_offset
-= str_section
->address
;
794 if (str_offset
>= str_section
->size
)
796 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
797 dwarf_vmatoa ("x", str_offset
));
798 return _("<indirect index offset is too big>");
801 ret
= (const char *) str_section
->start
+ str_offset
;
802 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
803 Since our caller is expecting to receive a well formed C string we test
804 for the lack of a terminating byte here. */
805 if (strnlen (ret
, str_section
->size
- str_offset
)
806 == str_section
->size
- str_offset
)
807 ret
= (const char *) _("<no NUL byte at end of section>");
813 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
815 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
817 if (section
->start
== NULL
)
818 return (_("<no .debug_addr section>"));
820 if (offset
+ bytes
> section
->size
)
822 warn (_("Offset into section %s too big: %s\n"),
823 section
->name
, dwarf_vmatoa ("x", offset
));
824 return "<offset too big>";
827 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
831 /* FIXME: There are better and more efficient ways to handle
832 these structures. For now though, I just want something that
833 is simple to implement. */
834 typedef struct abbrev_attr
836 unsigned long attribute
;
838 bfd_signed_vma implicit_const
;
839 struct abbrev_attr
*next
;
843 typedef struct abbrev_entry
848 struct abbrev_attr
*first_attr
;
849 struct abbrev_attr
*last_attr
;
850 struct abbrev_entry
*next
;
854 static abbrev_entry
*first_abbrev
= NULL
;
855 static abbrev_entry
*last_abbrev
= NULL
;
862 for (abbrv
= first_abbrev
; abbrv
;)
864 abbrev_entry
*next_abbrev
= abbrv
->next
;
867 for (attr
= abbrv
->first_attr
; attr
;)
869 abbrev_attr
*next_attr
= attr
->next
;
879 last_abbrev
= first_abbrev
= NULL
;
883 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
887 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
892 entry
->entry
= number
;
894 entry
->children
= children
;
895 entry
->first_attr
= NULL
;
896 entry
->last_attr
= NULL
;
899 if (first_abbrev
== NULL
)
900 first_abbrev
= entry
;
902 last_abbrev
->next
= entry
;
908 add_abbrev_attr (unsigned long attribute
, unsigned long form
,
909 bfd_signed_vma implicit_const
)
913 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
918 attr
->attribute
= attribute
;
920 attr
->implicit_const
= implicit_const
;
923 if (last_abbrev
->first_attr
== NULL
)
924 last_abbrev
->first_attr
= attr
;
926 last_abbrev
->last_attr
->next
= attr
;
928 last_abbrev
->last_attr
= attr
;
931 /* Processes the (partial) contents of a .debug_abbrev section.
932 Returns NULL if the end of the section was encountered.
933 Returns the address after the last byte read if the end of
934 an abbreviation set was found. */
936 static unsigned char *
937 process_abbrev_section (unsigned char *start
, unsigned char *end
)
939 if (first_abbrev
!= NULL
)
944 unsigned int bytes_read
;
947 unsigned long attribute
;
950 entry
= read_uleb128 (start
, & bytes_read
, end
);
953 /* A single zero is supposed to end the section according
954 to the standard. If there's more, then signal that to
961 tag
= read_uleb128 (start
, & bytes_read
, end
);
968 add_abbrev (entry
, tag
, children
);
973 /* Initialize it due to a false compiler warning. */
974 bfd_signed_vma implicit_const
= -1;
976 attribute
= read_uleb128 (start
, & bytes_read
, end
);
981 form
= read_uleb128 (start
, & bytes_read
, end
);
986 if (form
== DW_FORM_implicit_const
)
988 implicit_const
= read_sleb128 (start
, & bytes_read
, end
);
994 add_abbrev_attr (attribute
, form
, implicit_const
);
996 while (attribute
!= 0);
999 /* Report the missing single zero which ends the section. */
1000 error (_(".debug_abbrev section not zero terminated\n"));
1006 get_TAG_name (unsigned long tag
)
1008 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
1012 static char buffer
[100];
1014 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
1015 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
1017 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
1025 get_FORM_name (unsigned long form
)
1030 return "DW_FORM value: 0";
1032 name
= get_DW_FORM_name (form
);
1035 static char buffer
[100];
1037 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1045 get_IDX_name (unsigned long idx
)
1047 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1051 static char buffer
[100];
1053 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1060 static unsigned char *
1061 display_block (unsigned char *data
,
1063 const unsigned char * const end
, char delimiter
)
1067 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1069 return (unsigned char *) end
;
1071 maxlen
= (dwarf_vma
) (end
- data
);
1072 length
= length
> maxlen
? maxlen
: length
;
1075 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1081 decode_location_expression (unsigned char * data
,
1082 unsigned int pointer_size
,
1083 unsigned int offset_size
,
1086 dwarf_vma cu_offset
,
1087 struct dwarf_section
* section
)
1090 unsigned int bytes_read
;
1092 dwarf_signed_vma svalue
;
1093 unsigned char *end
= data
+ length
;
1094 int need_frame_base
= 0;
1103 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1104 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1107 printf ("DW_OP_deref");
1110 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1111 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1114 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1115 printf ("DW_OP_const1s: %ld", (long) svalue
);
1118 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1119 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1122 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1123 printf ("DW_OP_const2s: %ld", (long) svalue
);
1126 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1127 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1130 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1131 printf ("DW_OP_const4s: %ld", (long) svalue
);
1134 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1135 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1136 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1137 printf ("%lu", (unsigned long) uvalue
);
1140 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1141 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1142 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1143 printf ("%ld", (long) svalue
);
1146 printf ("DW_OP_constu: %s",
1147 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1151 printf ("DW_OP_consts: %s",
1152 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1156 printf ("DW_OP_dup");
1159 printf ("DW_OP_drop");
1162 printf ("DW_OP_over");
1165 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1166 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1169 printf ("DW_OP_swap");
1172 printf ("DW_OP_rot");
1175 printf ("DW_OP_xderef");
1178 printf ("DW_OP_abs");
1181 printf ("DW_OP_and");
1184 printf ("DW_OP_div");
1187 printf ("DW_OP_minus");
1190 printf ("DW_OP_mod");
1193 printf ("DW_OP_mul");
1196 printf ("DW_OP_neg");
1199 printf ("DW_OP_not");
1202 printf ("DW_OP_or");
1205 printf ("DW_OP_plus");
1207 case DW_OP_plus_uconst
:
1208 printf ("DW_OP_plus_uconst: %s",
1209 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1213 printf ("DW_OP_shl");
1216 printf ("DW_OP_shr");
1219 printf ("DW_OP_shra");
1222 printf ("DW_OP_xor");
1225 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1226 printf ("DW_OP_bra: %ld", (long) svalue
);
1229 printf ("DW_OP_eq");
1232 printf ("DW_OP_ge");
1235 printf ("DW_OP_gt");
1238 printf ("DW_OP_le");
1241 printf ("DW_OP_lt");
1244 printf ("DW_OP_ne");
1247 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1248 printf ("DW_OP_skip: %ld", (long) svalue
);
1283 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1318 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1319 regname (op
- DW_OP_reg0
, 1));
1354 printf ("DW_OP_breg%d (%s): %s",
1356 regname (op
- DW_OP_breg0
, 1),
1357 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1362 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1364 printf ("DW_OP_regx: %s (%s)",
1365 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1368 need_frame_base
= 1;
1369 printf ("DW_OP_fbreg: %s",
1370 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1374 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1376 printf ("DW_OP_bregx: %s (%s) %s",
1377 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1378 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1382 printf ("DW_OP_piece: %s",
1383 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1386 case DW_OP_deref_size
:
1387 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1388 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1390 case DW_OP_xderef_size
:
1391 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1392 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1395 printf ("DW_OP_nop");
1398 /* DWARF 3 extensions. */
1399 case DW_OP_push_object_address
:
1400 printf ("DW_OP_push_object_address");
1403 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1404 this ought to be an 8-byte wide computation. */
1405 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1406 printf ("DW_OP_call2: <0x%s>",
1407 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1410 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1411 this ought to be an 8-byte wide computation. */
1412 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1413 printf ("DW_OP_call4: <0x%s>",
1414 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1416 case DW_OP_call_ref
:
1417 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1418 this ought to be an 8-byte wide computation. */
1419 if (dwarf_version
== -1)
1421 printf (_("(DW_OP_call_ref in frame info)"));
1422 /* No way to tell where the next op is, so just bail. */
1423 return need_frame_base
;
1425 if (dwarf_version
== 2)
1427 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1431 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1433 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1435 case DW_OP_form_tls_address
:
1436 printf ("DW_OP_form_tls_address");
1438 case DW_OP_call_frame_cfa
:
1439 printf ("DW_OP_call_frame_cfa");
1441 case DW_OP_bit_piece
:
1442 printf ("DW_OP_bit_piece: ");
1443 printf (_("size: %s "),
1444 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1446 printf (_("offset: %s "),
1447 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1451 /* DWARF 4 extensions. */
1452 case DW_OP_stack_value
:
1453 printf ("DW_OP_stack_value");
1456 case DW_OP_implicit_value
:
1457 printf ("DW_OP_implicit_value");
1458 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1460 data
= display_block (data
, uvalue
, end
, ' ');
1463 /* GNU extensions. */
1464 case DW_OP_GNU_push_tls_address
:
1465 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1467 case DW_OP_GNU_uninit
:
1468 printf ("DW_OP_GNU_uninit");
1469 /* FIXME: Is there data associated with this OP ? */
1471 case DW_OP_GNU_encoded_addr
:
1478 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1480 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1481 print_dwarf_vma (addr
, pointer_size
);
1484 case DW_OP_implicit_pointer
:
1485 case DW_OP_GNU_implicit_pointer
:
1486 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1487 this ought to be an 8-byte wide computation. */
1488 if (dwarf_version
== -1)
1490 printf (_("(%s in frame info)"),
1491 (op
== DW_OP_implicit_pointer
1492 ? "DW_OP_implicit_pointer"
1493 : "DW_OP_GNU_implicit_pointer"));
1494 /* No way to tell where the next op is, so just bail. */
1495 return need_frame_base
;
1497 if (dwarf_version
== 2)
1499 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1503 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1505 printf ("%s: <0x%s> %s",
1506 (op
== DW_OP_implicit_pointer
1507 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1508 dwarf_vmatoa ("x", uvalue
),
1509 dwarf_vmatoa ("d", read_sleb128 (data
,
1510 &bytes_read
, end
)));
1513 case DW_OP_entry_value
:
1514 case DW_OP_GNU_entry_value
:
1515 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1517 /* PR 17531: file: 0cc9cd00. */
1518 if (uvalue
> (dwarf_vma
) (end
- data
))
1519 uvalue
= end
- data
;
1520 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1521 : "DW_OP_GNU_entry_value"));
1522 if (decode_location_expression (data
, pointer_size
, offset_size
,
1523 dwarf_version
, uvalue
,
1524 cu_offset
, section
))
1525 need_frame_base
= 1;
1531 case DW_OP_const_type
:
1532 case DW_OP_GNU_const_type
:
1533 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1535 printf ("%s: <0x%s> ",
1536 (op
== DW_OP_const_type
? "DW_OP_const_type"
1537 : "DW_OP_GNU_const_type"),
1538 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1539 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1540 data
= display_block (data
, uvalue
, end
, ' ');
1542 case DW_OP_regval_type
:
1543 case DW_OP_GNU_regval_type
:
1544 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1546 printf ("%s: %s (%s)",
1547 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1548 : "DW_OP_GNU_regval_type"),
1549 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1550 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1552 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1554 case DW_OP_deref_type
:
1555 case DW_OP_GNU_deref_type
:
1556 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1558 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1559 : "DW_OP_GNU_deref_type"),
1561 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1563 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1566 case DW_OP_GNU_convert
:
1567 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1569 printf ("%s <0x%s>",
1570 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1571 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1573 case DW_OP_reinterpret
:
1574 case DW_OP_GNU_reinterpret
:
1575 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1577 printf ("%s <0x%s>",
1578 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1579 : "DW_OP_GNU_reinterpret"),
1580 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1582 case DW_OP_GNU_parameter_ref
:
1583 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1584 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1585 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1587 case DW_OP_GNU_addr_index
:
1588 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1590 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1592 case DW_OP_GNU_const_index
:
1593 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1595 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1597 case DW_OP_GNU_variable_value
:
1598 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1599 this ought to be an 8-byte wide computation. */
1600 if (dwarf_version
== -1)
1602 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1603 /* No way to tell where the next op is, so just bail. */
1604 return need_frame_base
;
1606 if (dwarf_version
== 2)
1608 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1612 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1614 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1617 /* HP extensions. */
1618 case DW_OP_HP_is_value
:
1619 printf ("DW_OP_HP_is_value");
1620 /* FIXME: Is there data associated with this OP ? */
1622 case DW_OP_HP_fltconst4
:
1623 printf ("DW_OP_HP_fltconst4");
1624 /* FIXME: Is there data associated with this OP ? */
1626 case DW_OP_HP_fltconst8
:
1627 printf ("DW_OP_HP_fltconst8");
1628 /* FIXME: Is there data associated with this OP ? */
1630 case DW_OP_HP_mod_range
:
1631 printf ("DW_OP_HP_mod_range");
1632 /* FIXME: Is there data associated with this OP ? */
1634 case DW_OP_HP_unmod_range
:
1635 printf ("DW_OP_HP_unmod_range");
1636 /* FIXME: Is there data associated with this OP ? */
1639 printf ("DW_OP_HP_tls");
1640 /* FIXME: Is there data associated with this OP ? */
1643 /* PGI (STMicroelectronics) extensions. */
1644 case DW_OP_PGI_omp_thread_num
:
1645 /* Pushes the thread number for the current thread as it would be
1646 returned by the standard OpenMP library function:
1647 omp_get_thread_num(). The "current thread" is the thread for
1648 which the expression is being evaluated. */
1649 printf ("DW_OP_PGI_omp_thread_num");
1653 if (op
>= DW_OP_lo_user
1654 && op
<= DW_OP_hi_user
)
1655 printf (_("(User defined location op 0x%x)"), op
);
1657 printf (_("(Unknown location op 0x%x)"), op
);
1658 /* No way to tell where the next op is, so just bail. */
1659 return need_frame_base
;
1662 /* Separate the ops. */
1667 return need_frame_base
;
1670 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1671 This is used for DWARF package files. */
1673 static struct cu_tu_set
*
1674 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1676 struct cu_tu_set
*p
;
1678 unsigned int dw_sect
;
1684 dw_sect
= DW_SECT_TYPES
;
1690 dw_sect
= DW_SECT_INFO
;
1694 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1702 /* Add INC to HIGH_BITS:LOW_BITS. */
1704 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1706 dwarf_vma tmp
= * low_bits
;
1710 /* FIXME: There is probably a better way of handling this:
1712 We need to cope with dwarf_vma being a 32-bit or 64-bit
1713 type. Plus regardless of its size LOW_BITS is meant to
1714 only hold 32-bits, so if there is overflow or wrap around
1715 we must propagate into HIGH_BITS. */
1716 if (tmp
< * low_bits
)
1720 else if (sizeof (tmp
) > 8
1731 fetch_alt_indirect_string (dwarf_vma offset
)
1735 if (! do_follow_links
)
1738 if (first_separate_info
== NULL
)
1739 return _("<no links available>");
1741 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1743 struct dwarf_section
* section
;
1746 if (! load_debug_section (separate_debug_str
, i
->handle
))
1749 section
= &debug_displays
[separate_debug_str
].section
;
1751 if (section
->start
== NULL
)
1754 if (offset
>= section
->size
)
1757 ret
= (const char *) (section
->start
+ offset
);
1758 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1759 NUL byte. Since our caller is expecting to receive a well formed C
1760 string we test for the lack of a terminating byte here. */
1761 if (strnlen ((const char *) ret
, section
->size
- offset
)
1762 == section
->size
- offset
)
1763 return _("<no NUL byte at end of alt .debug_str section>");
1768 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1769 dwarf_vmatoa ("x", offset
));
1770 return _("<offset is too big>");
1774 get_AT_name (unsigned long attribute
)
1779 return "DW_AT value: 0";
1781 /* One value is shared by the MIPS and HP extensions: */
1782 if (attribute
== DW_AT_MIPS_fde
)
1783 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1785 name
= get_DW_AT_name (attribute
);
1789 static char buffer
[100];
1791 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1800 add_dwo_info (const char * field
, dwo_type type
)
1802 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1804 dwinfo
->type
= type
;
1805 dwinfo
->value
= field
;
1806 dwinfo
->next
= first_dwo_info
;
1807 first_dwo_info
= dwinfo
;
1811 add_dwo_name (const char * name
)
1813 add_dwo_info (name
, DWO_NAME
);
1817 add_dwo_dir (const char * dir
)
1819 add_dwo_info (dir
, DWO_DIR
);
1823 add_dwo_id (const char * id
)
1825 add_dwo_info (id
, DWO_ID
);
1829 free_dwo_info (void)
1834 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1836 next
= dwinfo
->next
;
1839 first_dwo_info
= NULL
;
1842 /* Ensure that START + UVALUE is less than END.
1843 Return an adjusted UVALUE if necessary to ensure this relationship. */
1845 static inline dwarf_vma
1846 check_uvalue (const unsigned char * start
,
1848 const unsigned char * end
)
1850 dwarf_vma max_uvalue
= end
- start
;
1852 /* See PR 17512: file: 008-103549-0.001:0.1.
1853 and PR 24829 for examples of where these tests are triggered. */
1854 if (uvalue
> max_uvalue
)
1856 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1857 uvalue
= max_uvalue
;
1863 static unsigned char *
1864 skip_attr_bytes (unsigned long form
,
1865 unsigned char * data
,
1866 unsigned const char * end
,
1867 dwarf_vma pointer_size
,
1868 dwarf_vma offset_size
,
1870 dwarf_vma
* value_return
)
1872 unsigned int bytes_read
;
1873 dwarf_vma uvalue
= 0;
1879 case DW_FORM_ref_addr
:
1880 if (dwarf_version
== 2)
1881 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1882 else if (dwarf_version
== 3 || dwarf_version
== 4)
1883 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1889 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1893 case DW_FORM_line_strp
:
1894 case DW_FORM_sec_offset
:
1895 case DW_FORM_GNU_ref_alt
:
1896 case DW_FORM_GNU_strp_alt
:
1897 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1900 case DW_FORM_flag_present
:
1907 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1912 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1917 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1921 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1925 case DW_FORM_ref_udata
:
1927 case DW_FORM_GNU_str_index
:
1928 case DW_FORM_GNU_addr_index
:
1929 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1938 case DW_FORM_data16
:
1942 case DW_FORM_string
:
1943 data
+= strnlen ((char *) data
, end
- data
) + 1;
1947 case DW_FORM_exprloc
:
1948 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1949 data
+= bytes_read
+ uvalue
;
1952 case DW_FORM_block1
:
1953 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1957 case DW_FORM_block2
:
1958 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1962 case DW_FORM_block4
:
1963 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1967 case DW_FORM_ref_sig8
:
1971 case DW_FORM_indirect
:
1972 /* FIXME: Handle this form. */
1977 * value_return
= uvalue
;
1979 data
= (unsigned char *) end
;
1983 /* Return IS_SIGNED set to TRUE if the type at
1984 DATA can be determined to be a signed type. */
1987 get_type_signedness (unsigned char * start
,
1988 unsigned char * data
,
1989 unsigned const char * end
,
1990 dwarf_vma pointer_size
,
1991 dwarf_vma offset_size
,
1993 bfd_boolean
* is_signed
,
1994 bfd_boolean is_nested
)
1996 unsigned long abbrev_number
;
1997 unsigned int bytes_read
;
1998 abbrev_entry
* entry
;
2001 * is_signed
= FALSE
;
2003 abbrev_number
= read_uleb128 (data
, & bytes_read
, end
);
2006 for (entry
= first_abbrev
;
2007 entry
!= NULL
&& entry
->entry
!= abbrev_number
;
2008 entry
= entry
->next
)
2012 /* FIXME: Issue a warning ? */
2015 for (attr
= entry
->first_attr
;
2016 attr
!= NULL
&& attr
->attribute
;
2019 dwarf_vma uvalue
= 0;
2021 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
2022 offset_size
, dwarf_version
, & uvalue
);
2026 switch (attr
->attribute
)
2028 #if 0 /* FIXME: It would be nice to print the name of the type,
2029 but this would mean updating a lot of binutils tests. */
2031 if (attr
->form
== DW_FORM_strp
)
2032 printf ("%s", fetch_indirect_string (uvalue
));
2039 /* FIXME: Warn - or is this expected ?
2040 NB/ We need to avoid infinite recursion. */
2043 if (uvalue
>= (size_t) (end
- start
))
2045 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
2046 offset_size
, dwarf_version
, is_signed
, TRUE
);
2049 case DW_AT_encoding
:
2050 /* Determine signness. */
2053 case DW_ATE_address
:
2054 /* FIXME - some architectures have signed addresses. */
2055 case DW_ATE_boolean
:
2056 case DW_ATE_unsigned
:
2057 case DW_ATE_unsigned_char
:
2058 case DW_ATE_unsigned_fixed
:
2059 * is_signed
= FALSE
;
2063 case DW_ATE_complex_float
:
2066 case DW_ATE_signed_char
:
2067 case DW_ATE_imaginary_float
:
2068 case DW_ATE_decimal_float
:
2069 case DW_ATE_signed_fixed
:
2079 read_and_print_leb128 (unsigned char * data
,
2080 unsigned int * bytes_read
,
2081 unsigned const char * end
,
2082 bfd_boolean is_signed
)
2086 dwarf_signed_vma sval
= read_sleb128 (data
, bytes_read
, end
);
2087 printf ("%ld", (long) sval
);
2091 dwarf_vma uval
= read_uleb128 (data
, bytes_read
, end
);
2092 printf ("%lu", (unsigned long) uval
);
2097 display_discr_list (unsigned long form
,
2099 unsigned char * data
,
2100 unsigned const char * end
,
2105 printf ("[default]");
2112 case DW_FORM_block1
:
2113 case DW_FORM_block2
:
2114 case DW_FORM_block4
:
2115 /* Move data pointer back to the start of the byte array. */
2119 printf ("<corrupt>\n");
2120 warn (_("corrupt discr_list - not using a block form\n"));
2126 printf ("<corrupt>\n");
2127 warn (_("corrupt discr_list - block not long enough\n"));
2131 bfd_boolean is_signed
=
2132 (level
> 0 && level
<= MAX_CU_NESTING
)
2133 ? level_type_signed
[level
- 1] : FALSE
;
2138 unsigned char discriminant
;
2139 unsigned int bytes_read
;
2141 SAFE_BYTE_GET (discriminant
, data
, 1, end
);
2145 assert (uvalue
> 0);
2146 switch (discriminant
)
2150 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2151 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2152 uvalue
-= bytes_read
;
2158 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2159 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2160 uvalue
-= bytes_read
;
2164 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2165 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2166 uvalue
-= bytes_read
;
2171 printf ("<corrupt>\n");
2172 warn (_("corrupt discr_list - unrecognised discriminant byte %#x\n"),
2182 printf (")(signed)");
2184 printf (")(unsigned)");
2187 static unsigned char *
2188 read_and_display_attr_value (unsigned long attribute
,
2190 dwarf_signed_vma implicit_const
,
2191 unsigned char * start
,
2192 unsigned char * data
,
2193 unsigned char * end
,
2194 dwarf_vma cu_offset
,
2195 dwarf_vma pointer_size
,
2196 dwarf_vma offset_size
,
2198 debug_info
* debug_info_p
,
2200 struct dwarf_section
* section
,
2201 struct cu_tu_set
* this_set
,
2205 dwarf_vma uvalue
= 0;
2206 unsigned char * block_start
= NULL
;
2207 unsigned char * orig_data
= data
;
2208 unsigned int bytes_read
;
2210 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2212 warn (_("Corrupt attribute\n"));
2221 case DW_FORM_ref_addr
:
2222 if (dwarf_version
== 2)
2223 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2224 else if (dwarf_version
== 3 || dwarf_version
== 4)
2225 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2227 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
2232 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2236 case DW_FORM_line_strp
:
2237 case DW_FORM_sec_offset
:
2238 case DW_FORM_GNU_ref_alt
:
2239 case DW_FORM_GNU_strp_alt
:
2240 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2243 case DW_FORM_flag_present
:
2250 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2255 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2260 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2264 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
2268 case DW_FORM_GNU_str_index
:
2269 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
2273 case DW_FORM_ref_udata
:
2275 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
2279 case DW_FORM_indirect
:
2280 form
= read_uleb128 (data
, & bytes_read
, end
);
2283 printf ("%c%s", delimiter
, get_FORM_name (form
));
2284 if (form
== DW_FORM_implicit_const
)
2286 implicit_const
= read_sleb128 (data
, & bytes_read
, end
);
2289 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2291 cu_offset
, pointer_size
,
2292 offset_size
, dwarf_version
,
2293 debug_info_p
, do_loc
,
2294 section
, this_set
, delimiter
, level
);
2295 case DW_FORM_GNU_addr_index
:
2296 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
2303 case DW_FORM_ref_addr
:
2305 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2308 case DW_FORM_GNU_ref_alt
:
2310 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2311 /* FIXME: Follow the reference... */
2317 case DW_FORM_ref_udata
:
2319 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2324 case DW_FORM_sec_offset
:
2326 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2329 case DW_FORM_flag_present
:
2336 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2339 case DW_FORM_implicit_const
:
2341 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2348 dwarf_vma high_bits
;
2352 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2354 if (form
== DW_FORM_ref8
)
2355 add64 (& high_bits
, & utmp
, cu_offset
);
2356 printf ("%c0x%s", delimiter
,
2357 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
2360 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2361 && num_debug_info_entries
== 0)
2363 if (sizeof (uvalue
) == 8)
2364 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
2366 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
2372 case DW_FORM_data16
:
2375 dwarf_vma left_high_bits
, left_low_bits
;
2376 dwarf_vma right_high_bits
, right_low_bits
;
2378 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
2379 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
2380 if (byte_get
== byte_get_little_endian
)
2383 left_high_bits
^= right_high_bits
;
2384 right_high_bits
^= left_high_bits
;
2385 left_high_bits
^= right_high_bits
;
2386 left_low_bits
^= right_low_bits
;
2387 right_low_bits
^= left_low_bits
;
2388 left_low_bits
^= right_low_bits
;
2390 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
2391 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
2392 left_high_bits
, left_low_bits
, right_high_bits
,
2398 case DW_FORM_string
:
2400 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2401 data
+= strnlen ((char *) data
, end
- data
) + 1;
2405 case DW_FORM_exprloc
:
2406 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
2407 block_start
= data
+ bytes_read
;
2408 if (block_start
>= end
)
2410 warn (_("Block ends prematurely\n"));
2415 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2418 data
= block_start
+ uvalue
;
2420 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2423 case DW_FORM_block1
:
2424 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
2425 block_start
= data
+ 1;
2426 if (block_start
>= end
)
2428 warn (_("Block ends prematurely\n"));
2433 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2436 data
= block_start
+ uvalue
;
2438 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2441 case DW_FORM_block2
:
2442 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
2443 block_start
= data
+ 2;
2444 if (block_start
>= end
)
2446 warn (_("Block ends prematurely\n"));
2451 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2454 data
= block_start
+ uvalue
;
2456 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2459 case DW_FORM_block4
:
2460 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
2461 block_start
= data
+ 4;
2462 /* PR 17512: file: 3371-3907-0.004. */
2463 if (block_start
>= end
)
2465 warn (_("Block ends prematurely\n"));
2470 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2473 data
= block_start
+ uvalue
;
2475 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2480 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2481 dwarf_vmatoa ("x", uvalue
),
2482 fetch_indirect_string (uvalue
));
2485 case DW_FORM_line_strp
:
2487 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2488 dwarf_vmatoa ("x", uvalue
),
2489 fetch_indirect_line_string (uvalue
));
2492 case DW_FORM_GNU_str_index
:
2495 const char * suffix
= strrchr (section
->name
, '.');
2496 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
2498 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2499 dwarf_vmatoa ("x", uvalue
),
2500 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2504 case DW_FORM_GNU_strp_alt
:
2507 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2508 dwarf_vmatoa ("x", uvalue
),
2509 fetch_alt_indirect_string (uvalue
));
2513 case DW_FORM_indirect
:
2514 /* Handled above. */
2517 case DW_FORM_ref_sig8
:
2520 dwarf_vma high_bits
;
2523 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2524 printf ("%csignature: 0x%s", delimiter
,
2525 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2530 case DW_FORM_GNU_addr_index
:
2532 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2533 dwarf_vmatoa ("x", uvalue
),
2534 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2538 warn (_("Unrecognized form: %lu\n"), form
);
2542 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2543 && num_debug_info_entries
== 0
2544 && debug_info_p
!= NULL
)
2548 case DW_AT_frame_base
:
2549 have_frame_base
= 1;
2551 case DW_AT_location
:
2552 case DW_AT_GNU_locviews
:
2553 case DW_AT_string_length
:
2554 case DW_AT_return_addr
:
2555 case DW_AT_data_member_location
:
2556 case DW_AT_vtable_elem_location
:
2558 case DW_AT_static_link
:
2559 case DW_AT_use_location
:
2560 case DW_AT_call_value
:
2561 case DW_AT_GNU_call_site_value
:
2562 case DW_AT_call_data_value
:
2563 case DW_AT_GNU_call_site_data_value
:
2564 case DW_AT_call_target
:
2565 case DW_AT_GNU_call_site_target
:
2566 case DW_AT_call_target_clobbered
:
2567 case DW_AT_GNU_call_site_target_clobbered
:
2568 if ((dwarf_version
< 4
2569 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2570 || form
== DW_FORM_sec_offset
)
2572 /* Process location list. */
2573 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2574 unsigned int num
= debug_info_p
->num_loc_offsets
;
2576 if (lmax
== 0 || num
>= lmax
)
2579 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2580 xcrealloc (debug_info_p
->loc_offsets
,
2581 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2582 debug_info_p
->loc_views
= (dwarf_vma
*)
2583 xcrealloc (debug_info_p
->loc_views
,
2584 lmax
, sizeof (*debug_info_p
->loc_views
));
2585 debug_info_p
->have_frame_base
= (int *)
2586 xcrealloc (debug_info_p
->have_frame_base
,
2587 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2588 debug_info_p
->max_loc_offsets
= lmax
;
2590 if (this_set
!= NULL
)
2591 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2592 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2593 if (attribute
!= DW_AT_GNU_locviews
)
2595 /* Corrupt DWARF info can produce more offsets than views.
2596 See PR 23062 for an example. */
2597 if (debug_info_p
->num_loc_offsets
2598 > debug_info_p
->num_loc_views
)
2599 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2602 debug_info_p
->loc_offsets
[num
] = uvalue
;
2603 debug_info_p
->num_loc_offsets
++;
2608 assert (debug_info_p
->num_loc_views
<= num
);
2609 num
= debug_info_p
->num_loc_views
;
2610 if (num
> debug_info_p
->num_loc_offsets
)
2611 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2614 debug_info_p
->loc_views
[num
] = uvalue
;
2615 debug_info_p
->num_loc_views
++;
2622 if (need_base_address
)
2623 debug_info_p
->base_address
= uvalue
;
2626 case DW_AT_GNU_addr_base
:
2627 debug_info_p
->addr_base
= uvalue
;
2630 case DW_AT_GNU_ranges_base
:
2631 debug_info_p
->ranges_base
= uvalue
;
2635 if ((dwarf_version
< 4
2636 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2637 || form
== DW_FORM_sec_offset
)
2639 /* Process range list. */
2640 unsigned int lmax
= debug_info_p
->max_range_lists
;
2641 unsigned int num
= debug_info_p
->num_range_lists
;
2643 if (lmax
== 0 || num
>= lmax
)
2646 debug_info_p
->range_lists
= (dwarf_vma
*)
2647 xcrealloc (debug_info_p
->range_lists
,
2648 lmax
, sizeof (*debug_info_p
->range_lists
));
2649 debug_info_p
->max_range_lists
= lmax
;
2651 debug_info_p
->range_lists
[num
] = uvalue
;
2652 debug_info_p
->num_range_lists
++;
2656 case DW_AT_GNU_dwo_name
:
2657 case DW_AT_dwo_name
:
2662 add_dwo_name ((const char *) fetch_indirect_string (uvalue
));
2664 case DW_FORM_GNU_str_index
:
2665 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2667 case DW_FORM_string
:
2668 add_dwo_name ((const char *) orig_data
);
2671 warn (_("Unsupported form (%s) for attribute %s\n"),
2672 get_FORM_name (form
), get_AT_name (attribute
));
2677 case DW_AT_comp_dir
:
2678 /* FIXME: Also extract a build-id in a CU/TU. */
2683 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
));
2685 case DW_FORM_line_strp
:
2686 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
));
2688 case DW_FORM_GNU_str_index
:
2689 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2691 case DW_FORM_string
:
2692 add_dwo_dir ((const char *) orig_data
);
2695 warn (_("Unsupported form (%s) for attribute %s\n"),
2696 get_FORM_name (form
), get_AT_name (attribute
));
2701 case DW_AT_GNU_dwo_id
:
2706 /* FIXME: Record the length of the ID as well ? */
2707 add_dwo_id ((const char *) (data
- 8));
2710 warn (_("Unsupported form (%s) for attribute %s\n"),
2711 get_FORM_name (form
), get_AT_name (attribute
));
2721 if (do_loc
|| attribute
== 0)
2724 /* For some attributes we can display further information. */
2728 if (level
>= 0 && level
< MAX_CU_NESTING
2729 && uvalue
< (size_t) (end
- start
))
2731 bfd_boolean is_signed
= FALSE
;
2733 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
2734 offset_size
, dwarf_version
, & is_signed
, FALSE
);
2735 level_type_signed
[level
] = is_signed
;
2743 case DW_INL_not_inlined
:
2744 printf (_("(not inlined)"));
2746 case DW_INL_inlined
:
2747 printf (_("(inlined)"));
2749 case DW_INL_declared_not_inlined
:
2750 printf (_("(declared as inline but ignored)"));
2752 case DW_INL_declared_inlined
:
2753 printf (_("(declared as inline and inlined)"));
2756 printf (_(" (Unknown inline attribute value: %s)"),
2757 dwarf_vmatoa ("x", uvalue
));
2762 case DW_AT_language
:
2766 /* Ordered by the numeric value of these constants. */
2767 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2768 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2769 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2770 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2771 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2772 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2773 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2774 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2775 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2776 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2777 /* DWARF 2.1 values. */
2778 case DW_LANG_Java
: printf ("(Java)"); break;
2779 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2780 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2781 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2782 /* DWARF 3 values. */
2783 case DW_LANG_PLI
: printf ("(PLI)"); break;
2784 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2785 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2786 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2787 case DW_LANG_D
: printf ("(D)"); break;
2788 /* DWARF 4 values. */
2789 case DW_LANG_Python
: printf ("(Python)"); break;
2790 /* DWARF 5 values. */
2791 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
2792 case DW_LANG_Go
: printf ("(Go)"); break;
2793 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
2794 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
2795 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
2796 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2797 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
2798 case DW_LANG_Rust
: printf ("(Rust)"); break;
2799 case DW_LANG_C11
: printf ("(C11)"); break;
2800 case DW_LANG_Swift
: printf ("(Swift)"); break;
2801 case DW_LANG_Julia
: printf ("(Julia)"); break;
2802 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
2803 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2804 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2805 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2806 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
2807 /* MIPS extension. */
2808 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2809 /* UPC extension. */
2810 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2812 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2813 printf (_("(implementation defined: %s)"),
2814 dwarf_vmatoa ("x", uvalue
));
2816 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2821 case DW_AT_encoding
:
2825 case DW_ATE_void
: printf ("(void)"); break;
2826 case DW_ATE_address
: printf ("(machine address)"); break;
2827 case DW_ATE_boolean
: printf ("(boolean)"); break;
2828 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2829 case DW_ATE_float
: printf ("(float)"); break;
2830 case DW_ATE_signed
: printf ("(signed)"); break;
2831 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2832 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2833 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2834 /* DWARF 2.1 values: */
2835 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2836 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2837 /* DWARF 3 values: */
2838 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2839 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2840 case DW_ATE_edited
: printf ("(edited)"); break;
2841 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2842 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2843 /* DWARF 4 values: */
2844 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2845 /* DWARF 5 values: */
2846 case DW_ATE_UCS
: printf ("(UCS)"); break;
2847 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2849 /* HP extensions: */
2850 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2851 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2852 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2853 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2854 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2855 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2856 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2859 if (uvalue
>= DW_ATE_lo_user
2860 && uvalue
<= DW_ATE_hi_user
)
2861 printf (_("(user defined type)"));
2863 printf (_("(unknown type)"));
2868 case DW_AT_accessibility
:
2872 case DW_ACCESS_public
: printf ("(public)"); break;
2873 case DW_ACCESS_protected
: printf ("(protected)"); break;
2874 case DW_ACCESS_private
: printf ("(private)"); break;
2876 printf (_("(unknown accessibility)"));
2881 case DW_AT_visibility
:
2885 case DW_VIS_local
: printf ("(local)"); break;
2886 case DW_VIS_exported
: printf ("(exported)"); break;
2887 case DW_VIS_qualified
: printf ("(qualified)"); break;
2888 default: printf (_("(unknown visibility)")); break;
2892 case DW_AT_endianity
:
2896 case DW_END_default
: printf ("(default)"); break;
2897 case DW_END_big
: printf ("(big)"); break;
2898 case DW_END_little
: printf ("(little)"); break;
2900 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2901 printf (_("(user specified)"));
2903 printf (_("(unknown endianity)"));
2908 case DW_AT_virtuality
:
2912 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2913 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2914 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2915 default: printf (_("(unknown virtuality)")); break;
2919 case DW_AT_identifier_case
:
2923 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2924 case DW_ID_up_case
: printf ("(up_case)"); break;
2925 case DW_ID_down_case
: printf ("(down_case)"); break;
2926 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2927 default: printf (_("(unknown case)")); break;
2931 case DW_AT_calling_convention
:
2935 case DW_CC_normal
: printf ("(normal)"); break;
2936 case DW_CC_program
: printf ("(program)"); break;
2937 case DW_CC_nocall
: printf ("(nocall)"); break;
2938 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2939 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2940 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2941 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2943 if (uvalue
>= DW_CC_lo_user
2944 && uvalue
<= DW_CC_hi_user
)
2945 printf (_("(user defined)"));
2947 printf (_("(unknown convention)"));
2951 case DW_AT_ordering
:
2956 case -1: printf (_("(undefined)")); break;
2957 case 0: printf ("(row major)"); break;
2958 case 1: printf ("(column major)"); break;
2962 case DW_AT_decimal_sign
:
2966 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2967 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2968 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2969 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2970 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2971 default: printf (_("(unrecognised)")); break;
2975 case DW_AT_defaulted
:
2979 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2980 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2981 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2982 default: printf (_("(unrecognised)")); break;
2986 case DW_AT_discr_list
:
2988 display_discr_list (form
, uvalue
, data
, end
, level
);
2991 case DW_AT_frame_base
:
2992 have_frame_base
= 1;
2994 case DW_AT_location
:
2995 case DW_AT_string_length
:
2996 case DW_AT_return_addr
:
2997 case DW_AT_data_member_location
:
2998 case DW_AT_vtable_elem_location
:
3000 case DW_AT_static_link
:
3001 case DW_AT_use_location
:
3002 case DW_AT_call_value
:
3003 case DW_AT_GNU_call_site_value
:
3004 case DW_AT_call_data_value
:
3005 case DW_AT_GNU_call_site_data_value
:
3006 case DW_AT_call_target
:
3007 case DW_AT_GNU_call_site_target
:
3008 case DW_AT_call_target_clobbered
:
3009 case DW_AT_GNU_call_site_target_clobbered
:
3010 if ((dwarf_version
< 4
3011 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3012 || form
== DW_FORM_sec_offset
)
3013 printf (_(" (location list)"));
3015 case DW_AT_allocated
:
3016 case DW_AT_associated
:
3017 case DW_AT_data_location
:
3019 case DW_AT_upper_bound
:
3020 case DW_AT_lower_bound
:
3023 int need_frame_base
;
3026 need_frame_base
= decode_location_expression (block_start
,
3031 cu_offset
, section
);
3033 if (need_frame_base
&& !have_frame_base
)
3034 printf (_(" [without DW_AT_frame_base]"));
3038 case DW_AT_data_bit_offset
:
3039 case DW_AT_byte_size
:
3040 case DW_AT_bit_size
:
3041 case DW_AT_string_length_byte_size
:
3042 case DW_AT_string_length_bit_size
:
3043 case DW_AT_bit_stride
:
3044 if (form
== DW_FORM_exprloc
)
3047 (void) decode_location_expression (block_start
, pointer_size
,
3048 offset_size
, dwarf_version
,
3049 uvalue
, cu_offset
, section
);
3056 if (form
== DW_FORM_ref_sig8
3057 || form
== DW_FORM_GNU_ref_alt
)
3060 if (form
== DW_FORM_ref1
3061 || form
== DW_FORM_ref2
3062 || form
== DW_FORM_ref4
3063 || form
== DW_FORM_ref_udata
)
3064 uvalue
+= cu_offset
;
3066 if (uvalue
>= section
->size
)
3067 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
3068 dwarf_vmatoa ("x", uvalue
),
3069 (unsigned long) (orig_data
- section
->start
));
3072 unsigned long abbrev_number
;
3073 abbrev_entry
* entry
;
3075 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
3077 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3078 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
3079 use different abbrev table, and we don't track .debug_info chunks
3081 if (form
!= DW_FORM_ref_addr
)
3083 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
3084 if (entry
->entry
== abbrev_number
)
3087 printf (" (%s)", get_TAG_name (entry
->tag
));
3101 static unsigned char *
3102 read_and_display_attr (unsigned long attribute
,
3104 dwarf_signed_vma implicit_const
,
3105 unsigned char * start
,
3106 unsigned char * data
,
3107 unsigned char * end
,
3108 dwarf_vma cu_offset
,
3109 dwarf_vma pointer_size
,
3110 dwarf_vma offset_size
,
3112 debug_info
* debug_info_p
,
3114 struct dwarf_section
* section
,
3115 struct cu_tu_set
* this_set
,
3119 printf (" %-18s:", get_AT_name (attribute
));
3120 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3122 cu_offset
, pointer_size
, offset_size
,
3123 dwarf_version
, debug_info_p
,
3124 do_loc
, section
, this_set
, ' ', level
);
3130 /* Like load_debug_section, but if the ordinary call fails, and we are
3131 following debug links, then attempt to load the requested section
3132 from one of the separate debug info files. */
3135 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3138 if (load_debug_section (sec_enum
, handle
))
3140 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3142 /* See if we can associate a filename with this section. */
3145 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3146 if (i
->handle
== handle
)
3148 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3156 if (do_follow_links
)
3160 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3162 if (load_debug_section (sec_enum
, i
->handle
))
3164 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3166 /* FIXME: We should check to see if any of the remaining debug info
3167 files also contain this section, and, umm, do something about it. */
3177 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
3181 if (do_follow_links
&& section
->filename
)
3182 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3183 section
->name
, section
->filename
);
3185 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3189 if (do_follow_links
&& section
->filename
)
3190 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3191 section
->name
, section
->filename
);
3193 printf (_("Contents of the %s section:\n\n"), section
->name
);
3197 /* Process the contents of a .debug_info section.
3198 If do_loc is TRUE then we are scanning for location lists and dwo tags
3199 and we do not want to display anything to the user.
3200 If do_types is TRUE, we are processing a .debug_types section instead of
3201 a .debug_info section.
3202 The information displayed is restricted by the values in DWARF_START_DIE
3203 and DWARF_CUTOFF_LEVEL.
3204 Returns TRUE upon success. Otherwise an error or warning message is
3205 printed and FALSE is returned. */
3208 process_debug_info (struct dwarf_section
* section
,
3210 enum dwarf_section_display_enum abbrev_sec
,
3212 bfd_boolean do_types
)
3214 unsigned char *start
= section
->start
;
3215 unsigned char *end
= start
+ section
->size
;
3216 unsigned char *section_begin
;
3218 unsigned int num_units
= 0;
3220 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3221 && num_debug_info_entries
== 0
3226 /* First scan the section to get the number of comp units. */
3227 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3230 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3231 will be the length. For a 64-bit DWARF section, it'll be
3232 the escape code 0xffffffff followed by an 8 byte length. */
3233 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
3235 if (length
== 0xffffffff)
3237 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
3238 section_begin
+= length
+ 12;
3240 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3242 warn (_("Reserved length value (0x%s) found in section %s\n"),
3243 dwarf_vmatoa ("x", length
), section
->name
);
3247 section_begin
+= length
+ 4;
3249 /* Negative values are illegal, they may even cause infinite
3250 looping. This can happen if we can't accurately apply
3251 relocations to an object file, or if the file is corrupt. */
3252 if ((signed long) length
<= 0 || section_begin
< start
)
3254 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3255 dwarf_vmatoa ("x", length
), section
->name
);
3262 error (_("No comp units in %s section ?\n"), section
->name
);
3266 /* Then allocate an array to hold the information. */
3267 debug_information
= (debug_info
*) cmalloc (num_units
,
3268 sizeof (* debug_information
));
3269 if (debug_information
== NULL
)
3271 error (_("Not enough memory for a debug info array of %u entries\n"),
3273 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3277 /* PR 17531: file: 92ca3797.
3278 We cannot rely upon the debug_information array being initialised
3279 before it is used. A corrupt file could easily contain references
3280 to a unit for which information has not been made available. So
3281 we ensure that the array is zeroed here. */
3282 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3284 alloc_num_debug_info_entries
= num_units
;
3289 load_debug_section_with_follow (str
, file
);
3290 load_debug_section_with_follow (line_str
, file
);
3291 load_debug_section_with_follow (str_dwo
, file
);
3292 load_debug_section_with_follow (str_index
, file
);
3293 load_debug_section_with_follow (str_index_dwo
, file
);
3294 load_debug_section_with_follow (debug_addr
, file
);
3297 load_debug_section_with_follow (abbrev_sec
, file
);
3298 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3300 warn (_("Unable to locate %s section!\n"),
3301 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3305 if (!do_loc
&& dwarf_start_die
== 0)
3306 introduce (section
, FALSE
);
3308 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
3310 DWARF2_Internal_CompUnit compunit
;
3311 unsigned char *hdrptr
;
3312 unsigned char *tags
;
3313 int level
, last_level
, saved_level
;
3314 dwarf_vma cu_offset
;
3315 unsigned long sec_off
;
3316 unsigned int offset_size
;
3317 unsigned int initial_length_size
;
3318 dwarf_vma signature_high
= 0;
3319 dwarf_vma signature_low
= 0;
3320 dwarf_vma type_offset
= 0;
3321 struct cu_tu_set
*this_set
;
3322 dwarf_vma abbrev_base
;
3327 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3329 if (compunit
.cu_length
== 0xffffffff)
3331 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3333 initial_length_size
= 12;
3338 initial_length_size
= 4;
3341 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3343 cu_offset
= start
- section_begin
;
3345 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3347 if (compunit
.cu_version
< 5)
3349 compunit
.cu_unit_type
= DW_UT_compile
;
3350 /* Initialize it due to a false compiler warning. */
3351 compunit
.cu_pointer_size
= -1;
3355 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3356 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3358 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3361 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3363 if (this_set
== NULL
)
3366 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3370 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3371 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3374 if (compunit
.cu_version
< 5)
3375 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3377 /* PR 17512: file: 001-108546-0.001:0.1. */
3378 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3380 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3381 compunit
.cu_pointer_size
, offset_size
);
3382 compunit
.cu_pointer_size
= offset_size
;
3387 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
3389 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
3392 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
3393 + initial_length_size
))
3395 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3396 + initial_length_size
;
3400 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3401 && num_debug_info_entries
== 0
3404 debug_information
[unit
].cu_offset
= cu_offset
;
3405 debug_information
[unit
].pointer_size
3406 = compunit
.cu_pointer_size
;
3407 debug_information
[unit
].offset_size
= offset_size
;
3408 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3409 debug_information
[unit
].base_address
= 0;
3410 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3411 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3412 debug_information
[unit
].loc_offsets
= NULL
;
3413 debug_information
[unit
].have_frame_base
= NULL
;
3414 debug_information
[unit
].max_loc_offsets
= 0;
3415 debug_information
[unit
].num_loc_offsets
= 0;
3416 debug_information
[unit
].range_lists
= NULL
;
3417 debug_information
[unit
].max_range_lists
= 0;
3418 debug_information
[unit
].num_range_lists
= 0;
3421 if (!do_loc
&& dwarf_start_die
== 0)
3423 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3424 dwarf_vmatoa ("x", cu_offset
));
3425 printf (_(" Length: 0x%s (%s)\n"),
3426 dwarf_vmatoa ("x", compunit
.cu_length
),
3427 offset_size
== 8 ? "64-bit" : "32-bit");
3428 printf (_(" Version: %d\n"), compunit
.cu_version
);
3429 printf (_(" Abbrev Offset: 0x%s\n"),
3430 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3431 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3436 printf (_(" Signature: 0x%s\n"),
3437 dwarf_vmatoa64 (signature_high
, signature_low
,
3438 buf
, sizeof (buf
)));
3439 printf (_(" Type Offset: 0x%s\n"),
3440 dwarf_vmatoa ("x", type_offset
));
3442 if (this_set
!= NULL
)
3444 dwarf_vma
*offsets
= this_set
->section_offsets
;
3445 size_t *sizes
= this_set
->section_sizes
;
3447 printf (_(" Section contributions:\n"));
3448 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3449 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3450 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3451 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3452 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3453 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3454 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3455 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3456 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3457 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3458 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3459 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3463 sec_off
= cu_offset
+ initial_length_size
;
3464 if (sec_off
+ compunit
.cu_length
< sec_off
3465 || sec_off
+ compunit
.cu_length
> section
->size
)
3467 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3469 (unsigned long) cu_offset
,
3470 dwarf_vmatoa ("x", compunit
.cu_length
));
3476 start
+= compunit
.cu_length
+ initial_length_size
;
3478 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3480 warn (_("CU at offset %s contains corrupt or "
3481 "unsupported version number: %d.\n"),
3482 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3486 if (compunit
.cu_unit_type
!= DW_UT_compile
3487 && compunit
.cu_unit_type
!= DW_UT_type
)
3489 warn (_("CU at offset %s contains corrupt or "
3490 "unsupported unit type: %d.\n"),
3491 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3497 /* Process the abbrevs used by this compilation unit. */
3498 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3499 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3500 (unsigned long) compunit
.cu_abbrev_offset
,
3501 (unsigned long) abbrev_size
);
3502 /* PR 17531: file:4bcd9ce9. */
3503 else if ((abbrev_base
+ abbrev_size
)
3504 > debug_displays
[abbrev_sec
].section
.size
)
3505 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3506 (unsigned long) abbrev_base
+ abbrev_size
,
3507 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3509 process_abbrev_section
3510 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3511 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3512 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3513 + abbrev_base
+ abbrev_size
));
3518 while (tags
< start
)
3520 unsigned int bytes_read
;
3521 unsigned long abbrev_number
;
3522 unsigned long die_offset
;
3523 abbrev_entry
*entry
;
3525 int do_printing
= 1;
3527 die_offset
= tags
- section_begin
;
3529 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
3532 /* A null DIE marks the end of a list of siblings or it may also be
3533 a section padding. */
3534 if (abbrev_number
== 0)
3536 /* Check if it can be a section padding for the last CU. */
3537 if (level
== 0 && start
== end
)
3541 for (chk
= tags
; chk
< start
; chk
++)
3548 if (!do_loc
&& die_offset
>= dwarf_start_die
3549 && (dwarf_cutoff_level
== -1
3550 || level
< dwarf_cutoff_level
))
3551 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3557 static unsigned num_bogus_warns
= 0;
3559 if (num_bogus_warns
< 3)
3561 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3562 die_offset
, section
->name
);
3564 if (num_bogus_warns
== 3)
3565 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3568 if (dwarf_start_die
!= 0 && level
< saved_level
)
3575 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3579 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3580 saved_level
= level
;
3581 do_printing
= (dwarf_cutoff_level
== -1
3582 || level
< dwarf_cutoff_level
);
3584 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3585 level
, die_offset
, abbrev_number
);
3586 else if (dwarf_cutoff_level
== -1
3587 || last_level
< dwarf_cutoff_level
)
3588 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3593 /* Scan through the abbreviation list until we reach the
3595 for (entry
= first_abbrev
;
3596 entry
&& entry
->entry
!= abbrev_number
;
3597 entry
= entry
->next
)
3602 if (!do_loc
&& do_printing
)
3607 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3608 die_offset
, abbrev_number
);
3612 if (!do_loc
&& do_printing
)
3613 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3618 need_base_address
= 0;
3620 case DW_TAG_compile_unit
:
3621 need_base_address
= 1;
3622 need_dwo_info
= do_loc
;
3624 case DW_TAG_entry_point
:
3625 case DW_TAG_subprogram
:
3626 need_base_address
= 0;
3627 /* Assuming that there is no DW_AT_frame_base. */
3628 have_frame_base
= 0;
3632 debug_info
*debug_info_p
=
3633 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3634 ? debug_information
+ unit
: NULL
;
3636 assert (!debug_info_p
3637 || (debug_info_p
->num_loc_offsets
3638 == debug_info_p
->num_loc_views
));
3640 for (attr
= entry
->first_attr
;
3641 attr
&& attr
->attribute
;
3644 if (! do_loc
&& do_printing
)
3645 /* Show the offset from where the tag was extracted. */
3646 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3647 tags
= read_and_display_attr (attr
->attribute
,
3649 attr
->implicit_const
,
3654 compunit
.cu_pointer_size
,
3656 compunit
.cu_version
,
3658 do_loc
|| ! do_printing
,
3664 /* If a locview attribute appears before a location one,
3665 make sure we don't associate it with an earlier
3668 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3671 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3672 debug_info_p
->num_loc_views
++;
3673 assert (debug_info_p
->num_loc_views
3674 == debug_info_p
->num_loc_offsets
);
3681 warn(_("DIE has locviews without loclist\n"));
3682 debug_info_p
->num_loc_views
--;
3689 if (entry
->children
)
3694 /* Set num_debug_info_entries here so that it can be used to check if
3695 we need to process .debug_loc and .debug_ranges sections. */
3696 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3697 && num_debug_info_entries
== 0
3700 if (num_units
> alloc_num_debug_info_entries
)
3701 num_debug_info_entries
= alloc_num_debug_info_entries
;
3703 num_debug_info_entries
= num_units
;
3712 /* Locate and scan the .debug_info section in the file and record the pointer
3713 sizes and offsets for the compilation units in it. Usually an executable
3714 will have just one pointer size, but this is not guaranteed, and so we try
3715 not to make any assumptions. Returns zero upon failure, or the number of
3716 compilation units upon success. */
3719 load_debug_info (void * file
)
3721 /* If we have already tried and failed to load the .debug_info
3722 section then do not bother to repeat the task. */
3723 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3726 /* If we already have the information there is nothing else to do. */
3727 if (num_debug_info_entries
> 0)
3728 return num_debug_info_entries
;
3730 /* If this is a DWARF package file, load the CU and TU indexes. */
3731 (void) load_cu_tu_indexes (file
);
3733 if (load_debug_section_with_follow (info
, file
)
3734 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3735 return num_debug_info_entries
;
3737 if (load_debug_section_with_follow (info_dwo
, file
)
3738 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3739 abbrev_dwo
, TRUE
, FALSE
))
3740 return num_debug_info_entries
;
3742 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3746 /* Read a DWARF .debug_line section header starting at DATA.
3747 Upon success returns an updated DATA pointer and the LINFO
3748 structure and the END_OF_SEQUENCE pointer will be filled in.
3749 Otherwise returns NULL. */
3751 static unsigned char *
3752 read_debug_line_header (struct dwarf_section
* section
,
3753 unsigned char * data
,
3754 unsigned char * end
,
3755 DWARF2_Internal_LineInfo
* linfo
,
3756 unsigned char ** end_of_sequence
)
3758 unsigned char *hdrptr
;
3759 unsigned int initial_length_size
;
3760 unsigned char address_size
, segment_selector_size
;
3762 /* Extract information from the Line Number Program Header.
3763 (section 6.2.4 in the Dwarf3 doc). */
3766 /* Get and check the length of the block. */
3767 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3769 if (linfo
->li_length
== 0xffffffff)
3771 /* This section is 64-bit DWARF 3. */
3772 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3773 linfo
->li_offset_size
= 8;
3774 initial_length_size
= 12;
3778 linfo
->li_offset_size
= 4;
3779 initial_length_size
= 4;
3782 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3784 /* If the length field has a relocation against it, then we should
3785 not complain if it is inaccurate (and probably negative). This
3786 happens in object files when the .debug_line section is actually
3787 comprised of several different .debug_line.* sections, (some of
3788 which may be removed by linker garbage collection), and a relocation
3789 is used to compute the correct length once that is done. */
3790 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3792 linfo
->li_length
= (end
- data
) - initial_length_size
;
3796 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3797 (long) linfo
->li_length
);
3802 /* Get and check the version number. */
3803 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3805 if (linfo
->li_version
!= 2
3806 && linfo
->li_version
!= 3
3807 && linfo
->li_version
!= 4
3808 && linfo
->li_version
!= 5)
3810 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3811 "is currently supported.\n"));
3815 if (linfo
->li_version
>= 5)
3817 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
3819 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
3820 if (segment_selector_size
!= 0)
3822 warn (_("The %s section contains "
3823 "unsupported segment selector size: %d.\n"),
3824 section
->name
, segment_selector_size
);
3829 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3830 linfo
->li_offset_size
, end
);
3831 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3833 if (linfo
->li_version
>= 4)
3835 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3837 if (linfo
->li_max_ops_per_insn
== 0)
3839 warn (_("Invalid maximum operations per insn.\n"));
3844 linfo
->li_max_ops_per_insn
= 1;
3846 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3847 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3848 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3849 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3851 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3852 /* PR 17512: file:002-117414-0.004. */
3853 if (* end_of_sequence
> end
)
3855 warn (_("Line length %s extends beyond end of section\n"),
3856 dwarf_vmatoa ("u", linfo
->li_length
));
3857 * end_of_sequence
= end
;
3864 static unsigned char *
3865 display_formatted_table (unsigned char * data
,
3866 unsigned char * start
,
3867 unsigned char * end
,
3868 const DWARF2_Internal_LineInfo
* linfo
,
3869 struct dwarf_section
* section
,
3872 unsigned char *format_start
, format_count
, *format
, formati
;
3873 dwarf_vma data_count
, datai
;
3874 unsigned int bytes_read
, namepass
, last_entry
= 0;
3876 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3877 format_start
= data
;
3878 for (formati
= 0; formati
< format_count
; formati
++)
3880 read_uleb128 (data
, & bytes_read
, end
);
3882 read_uleb128 (data
, & bytes_read
, end
);
3887 warn (_("Corrupt directory format table entry\n"));
3889 warn (_("Corrupt file name format table entry\n"));
3894 data_count
= read_uleb128 (data
, & bytes_read
, end
);
3899 warn (_("Corrupt directory list\n"));
3901 warn (_("Corrupt file name list\n"));
3905 if (data_count
== 0)
3908 printf (_("\n The Directory Table is empty.\n"));
3910 printf (_("\n The File Name Table is empty.\n"));
3915 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3916 (long) (data
- start
));
3918 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3919 (long) (data
- start
));
3921 printf (_(" Entry"));
3922 /* Delay displaying name as the last entry for better screen layout. */
3923 for (namepass
= 0; namepass
< 2; namepass
++)
3925 format
= format_start
;
3926 for (formati
= 0; formati
< format_count
; formati
++)
3928 dwarf_vma content_type
;
3930 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3931 format
+= bytes_read
;
3932 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3933 switch (content_type
)
3936 printf (_("\tName"));
3938 case DW_LNCT_directory_index
:
3939 printf (_("\tDir"));
3941 case DW_LNCT_timestamp
:
3942 printf (_("\tTime"));
3945 printf (_("\tSize"));
3948 printf (_("\tMD5"));
3951 printf (_("\t(Unknown format content type %s)"),
3952 dwarf_vmatoa ("u", content_type
));
3954 read_uleb128 (format
, & bytes_read
, end
);
3955 format
+= bytes_read
;
3960 for (datai
= 0; datai
< data_count
; datai
++)
3962 unsigned char *datapass
= data
;
3964 printf (" %d", last_entry
++);
3965 /* Delay displaying name as the last entry for better screen layout. */
3966 for (namepass
= 0; namepass
< 2; namepass
++)
3968 format
= format_start
;
3970 for (formati
= 0; formati
< format_count
; formati
++)
3972 dwarf_vma content_type
, form
;
3974 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3975 format
+= bytes_read
;
3976 form
= read_uleb128 (format
, & bytes_read
, end
);
3977 format
+= bytes_read
;
3978 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
, 0, 0,
3979 linfo
->li_offset_size
,
3980 linfo
->li_version
, NULL
,
3981 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3982 section
, NULL
, '\t', -1);
3988 warn (_("Corrupt directory entries list\n"));
3990 warn (_("Corrupt file name entries list\n"));
3999 display_debug_lines_raw (struct dwarf_section
* section
,
4000 unsigned char * data
,
4001 unsigned char * end
,
4004 unsigned char *start
= section
->start
;
4005 int verbose_view
= 0;
4007 introduce (section
, TRUE
);
4011 static DWARF2_Internal_LineInfo saved_linfo
;
4012 DWARF2_Internal_LineInfo linfo
;
4013 unsigned char *standard_opcodes
;
4014 unsigned char *end_of_sequence
;
4017 if (const_strneq (section
->name
, ".debug_line.")
4018 /* Note: the following does not apply to .debug_line.dwo sections.
4019 These are full debug_line sections. */
4020 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4022 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4023 section containing just the Line Number Statements. They are
4024 created by the assembler and intended to be used alongside gcc's
4025 -ffunction-sections command line option. When the linker's
4026 garbage collection decides to discard a .text.<foo> section it
4027 can then also discard the line number information in .debug_line.<foo>.
4029 Since the section is a fragment it does not have the details
4030 needed to fill out a LineInfo structure, so instead we use the
4031 details from the last full debug_line section that we processed. */
4032 end_of_sequence
= end
;
4033 standard_opcodes
= NULL
;
4034 linfo
= saved_linfo
;
4035 /* PR 17531: file: 0522b371. */
4036 if (linfo
.li_line_range
== 0)
4038 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4041 reset_state_machine (linfo
.li_default_is_stmt
);
4045 unsigned char * hdrptr
;
4047 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4048 & end_of_sequence
)) == NULL
)
4051 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
4052 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
4053 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4054 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4055 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4056 if (linfo
.li_version
>= 4)
4057 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4058 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4059 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4060 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4061 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4063 /* PR 17512: file: 1665-6428-0.004. */
4064 if (linfo
.li_line_range
== 0)
4066 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4067 linfo
.li_line_range
= 1;
4070 reset_state_machine (linfo
.li_default_is_stmt
);
4072 /* Display the contents of the Opcodes table. */
4073 standard_opcodes
= hdrptr
;
4075 /* PR 17512: file: 002-417945-0.004. */
4076 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4078 warn (_("Line Base extends beyond end of section\n"));
4082 printf (_("\n Opcodes:\n"));
4084 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4085 printf (ngettext (" Opcode %d has %d arg\n",
4086 " Opcode %d has %d args\n",
4087 standard_opcodes
[i
- 1]),
4088 i
, standard_opcodes
[i
- 1]);
4090 /* Display the contents of the Directory table. */
4091 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4093 if (linfo
.li_version
>= 5)
4095 load_debug_section_with_follow (line_str
, file
);
4097 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4099 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4105 printf (_("\n The Directory Table is empty.\n"));
4108 unsigned int last_dir_entry
= 0;
4110 printf (_("\n The Directory Table (offset 0x%lx):\n"),
4111 (long)(data
- start
));
4113 while (data
< end
&& *data
!= 0)
4115 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4117 data
+= strnlen ((char *) data
, end
- data
) + 1;
4120 /* PR 17512: file: 002-132094-0.004. */
4121 if (data
>= end
- 1)
4125 /* Skip the NUL at the end of the table. */
4128 /* Display the contents of the File Name table. */
4130 printf (_("\n The File Name Table is empty.\n"));
4133 printf (_("\n The File Name Table (offset 0x%lx):\n"),
4134 (long)(data
- start
));
4135 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4137 while (data
< end
&& *data
!= 0)
4139 unsigned char *name
;
4140 unsigned int bytes_read
;
4142 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4144 data
+= strnlen ((char *) data
, end
- data
) + 1;
4147 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
4150 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
4153 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
4155 printf ("%.*s\n", (int)(end
- name
), name
);
4159 warn (_("Corrupt file name table entry\n"));
4165 /* Skip the NUL at the end of the table. */
4170 saved_linfo
= linfo
;
4173 /* Now display the statements. */
4174 if (data
>= end_of_sequence
)
4175 printf (_(" No Line Number Statements.\n"));
4178 printf (_(" Line Number Statements:\n"));
4180 while (data
< end_of_sequence
)
4182 unsigned char op_code
;
4183 dwarf_signed_vma adv
;
4185 unsigned int bytes_read
;
4187 printf (" [0x%08lx]", (long)(data
- start
));
4191 if (op_code
>= linfo
.li_opcode_base
)
4193 op_code
-= linfo
.li_opcode_base
;
4194 uladv
= (op_code
/ linfo
.li_line_range
);
4195 if (linfo
.li_max_ops_per_insn
== 1)
4197 uladv
*= linfo
.li_min_insn_length
;
4198 state_machine_regs
.address
+= uladv
;
4200 state_machine_regs
.view
= 0;
4201 printf (_(" Special opcode %d: "
4202 "advance Address by %s to 0x%s%s"),
4203 op_code
, dwarf_vmatoa ("u", uladv
),
4204 dwarf_vmatoa ("x", state_machine_regs
.address
),
4205 verbose_view
&& uladv
4206 ? _(" (reset view)") : "");
4211 = ((state_machine_regs
.op_index
+ uladv
)
4212 / linfo
.li_max_ops_per_insn
)
4213 * linfo
.li_min_insn_length
;
4215 state_machine_regs
.address
+= addrdelta
;
4216 state_machine_regs
.op_index
4217 = (state_machine_regs
.op_index
+ uladv
)
4218 % linfo
.li_max_ops_per_insn
;
4220 state_machine_regs
.view
= 0;
4221 printf (_(" Special opcode %d: "
4222 "advance Address by %s to 0x%s[%d]%s"),
4223 op_code
, dwarf_vmatoa ("u", uladv
),
4224 dwarf_vmatoa ("x", state_machine_regs
.address
),
4225 state_machine_regs
.op_index
,
4226 verbose_view
&& addrdelta
4227 ? _(" (reset view)") : "");
4229 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4230 state_machine_regs
.line
+= adv
;
4231 printf (_(" and Line by %s to %d"),
4232 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4233 if (verbose_view
|| state_machine_regs
.view
)
4234 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4237 state_machine_regs
.view
++;
4239 else switch (op_code
)
4241 case DW_LNS_extended_op
:
4242 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
4246 printf (_(" Copy"));
4247 if (verbose_view
|| state_machine_regs
.view
)
4248 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4251 state_machine_regs
.view
++;
4254 case DW_LNS_advance_pc
:
4255 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4257 if (linfo
.li_max_ops_per_insn
== 1)
4259 uladv
*= linfo
.li_min_insn_length
;
4260 state_machine_regs
.address
+= uladv
;
4262 state_machine_regs
.view
= 0;
4263 printf (_(" Advance PC by %s to 0x%s%s\n"),
4264 dwarf_vmatoa ("u", uladv
),
4265 dwarf_vmatoa ("x", state_machine_regs
.address
),
4266 verbose_view
&& uladv
4267 ? _(" (reset view)") : "");
4272 = ((state_machine_regs
.op_index
+ uladv
)
4273 / linfo
.li_max_ops_per_insn
)
4274 * linfo
.li_min_insn_length
;
4275 state_machine_regs
.address
4277 state_machine_regs
.op_index
4278 = (state_machine_regs
.op_index
+ uladv
)
4279 % linfo
.li_max_ops_per_insn
;
4281 state_machine_regs
.view
= 0;
4282 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4283 dwarf_vmatoa ("u", uladv
),
4284 dwarf_vmatoa ("x", state_machine_regs
.address
),
4285 state_machine_regs
.op_index
,
4286 verbose_view
&& addrdelta
4287 ? _(" (reset view)") : "");
4291 case DW_LNS_advance_line
:
4292 adv
= read_sleb128 (data
, & bytes_read
, end
);
4294 state_machine_regs
.line
+= adv
;
4295 printf (_(" Advance Line by %s to %d\n"),
4296 dwarf_vmatoa ("d", adv
),
4297 state_machine_regs
.line
);
4300 case DW_LNS_set_file
:
4301 adv
= read_uleb128 (data
, & bytes_read
, end
);
4303 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4304 dwarf_vmatoa ("d", adv
));
4305 state_machine_regs
.file
= adv
;
4308 case DW_LNS_set_column
:
4309 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4311 printf (_(" Set column to %s\n"),
4312 dwarf_vmatoa ("u", uladv
));
4313 state_machine_regs
.column
= uladv
;
4316 case DW_LNS_negate_stmt
:
4317 adv
= state_machine_regs
.is_stmt
;
4319 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4320 state_machine_regs
.is_stmt
= adv
;
4323 case DW_LNS_set_basic_block
:
4324 printf (_(" Set basic block\n"));
4325 state_machine_regs
.basic_block
= 1;
4328 case DW_LNS_const_add_pc
:
4329 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4330 if (linfo
.li_max_ops_per_insn
)
4332 uladv
*= linfo
.li_min_insn_length
;
4333 state_machine_regs
.address
+= uladv
;
4335 state_machine_regs
.view
= 0;
4336 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4337 dwarf_vmatoa ("u", uladv
),
4338 dwarf_vmatoa ("x", state_machine_regs
.address
),
4339 verbose_view
&& uladv
4340 ? _(" (reset view)") : "");
4345 = ((state_machine_regs
.op_index
+ uladv
)
4346 / linfo
.li_max_ops_per_insn
)
4347 * linfo
.li_min_insn_length
;
4348 state_machine_regs
.address
4350 state_machine_regs
.op_index
4351 = (state_machine_regs
.op_index
+ uladv
)
4352 % linfo
.li_max_ops_per_insn
;
4354 state_machine_regs
.view
= 0;
4355 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4356 dwarf_vmatoa ("u", uladv
),
4357 dwarf_vmatoa ("x", state_machine_regs
.address
),
4358 state_machine_regs
.op_index
,
4359 verbose_view
&& addrdelta
4360 ? _(" (reset view)") : "");
4364 case DW_LNS_fixed_advance_pc
:
4365 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4366 state_machine_regs
.address
+= uladv
;
4367 state_machine_regs
.op_index
= 0;
4368 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4369 dwarf_vmatoa ("u", uladv
),
4370 dwarf_vmatoa ("x", state_machine_regs
.address
));
4371 /* Do NOT reset view. */
4374 case DW_LNS_set_prologue_end
:
4375 printf (_(" Set prologue_end to true\n"));
4378 case DW_LNS_set_epilogue_begin
:
4379 printf (_(" Set epilogue_begin to true\n"));
4382 case DW_LNS_set_isa
:
4383 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4385 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4389 printf (_(" Unknown opcode %d with operands: "), op_code
);
4391 if (standard_opcodes
!= NULL
)
4392 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4394 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
4396 i
== 1 ? "" : ", ");
4412 unsigned char *name
;
4413 unsigned int directory_index
;
4414 unsigned int modification_date
;
4415 unsigned int length
;
4418 /* Output a decoded representation of the .debug_line section. */
4421 display_debug_lines_decoded (struct dwarf_section
* section
,
4422 unsigned char * start
,
4423 unsigned char * data
,
4424 unsigned char * end
,
4427 static DWARF2_Internal_LineInfo saved_linfo
;
4429 introduce (section
, FALSE
);
4433 /* This loop amounts to one iteration per compilation unit. */
4434 DWARF2_Internal_LineInfo linfo
;
4435 unsigned char *standard_opcodes
;
4436 unsigned char *end_of_sequence
;
4438 File_Entry
*file_table
= NULL
;
4439 unsigned int n_files
= 0;
4440 unsigned char **directory_table
= NULL
;
4441 dwarf_vma n_directories
= 0;
4443 if (const_strneq (section
->name
, ".debug_line.")
4444 /* Note: the following does not apply to .debug_line.dwo sections.
4445 These are full debug_line sections. */
4446 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4448 /* See comment in display_debug_lines_raw(). */
4449 end_of_sequence
= end
;
4450 standard_opcodes
= NULL
;
4451 linfo
= saved_linfo
;
4452 /* PR 17531: file: 0522b371. */
4453 if (linfo
.li_line_range
== 0)
4455 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4458 reset_state_machine (linfo
.li_default_is_stmt
);
4462 unsigned char *hdrptr
;
4464 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4465 & end_of_sequence
)) == NULL
)
4468 /* PR 17531: file: 0522b371. */
4469 if (linfo
.li_line_range
== 0)
4471 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4472 linfo
.li_line_range
= 1;
4474 reset_state_machine (linfo
.li_default_is_stmt
);
4476 /* Save a pointer to the contents of the Opcodes table. */
4477 standard_opcodes
= hdrptr
;
4479 /* Traverse the Directory table just to count entries. */
4480 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4484 warn (_("opcode base of %d extends beyond end of section\n"),
4485 linfo
.li_opcode_base
);
4489 if (linfo
.li_version
>= 5)
4491 unsigned char *format_start
, format_count
, *format
;
4492 dwarf_vma formati
, entryi
;
4493 unsigned int bytes_read
;
4495 load_debug_section_with_follow (line_str
, fileptr
);
4497 /* Skip directories format. */
4498 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4499 format_start
= data
;
4500 for (formati
= 0; formati
< format_count
; formati
++)
4502 read_uleb128 (data
, & bytes_read
, end
);
4504 read_uleb128 (data
, & bytes_read
, end
);
4508 n_directories
= read_uleb128 (data
, & bytes_read
, end
);
4512 warn (_("Corrupt directories list\n"));
4516 directory_table
= (unsigned char **)
4517 xmalloc (n_directories
* sizeof (unsigned char *));
4519 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4521 unsigned char **pathp
= &directory_table
[entryi
];
4523 format
= format_start
;
4524 for (formati
= 0; formati
< format_count
; formati
++)
4526 dwarf_vma content_type
, form
;
4529 content_type
= read_uleb128 (format
, & bytes_read
, end
);
4530 format
+= bytes_read
;
4531 form
= read_uleb128 (format
, & bytes_read
, end
);
4532 format
+= bytes_read
;
4535 warn (_("Corrupt directories list\n"));
4538 switch (content_type
)
4543 case DW_FORM_string
:
4546 case DW_FORM_line_strp
:
4547 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4549 /* Remove const by the cast. */
4550 *pathp
= (unsigned char *)
4551 fetch_indirect_line_string (uvalue
);
4556 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4558 linfo
.li_offset_size
,
4565 warn (_("Corrupt directories list\n"));
4570 /* Skip files format. */
4571 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4572 format_start
= data
;
4573 for (formati
= 0; formati
< format_count
; formati
++)
4575 read_uleb128 (data
, & bytes_read
, end
);
4577 read_uleb128 (data
, & bytes_read
, end
);
4581 n_files
= read_uleb128 (data
, & bytes_read
, end
);
4585 warn (_("Corrupt file name list\n"));
4589 file_table
= (File_Entry
*) xcalloc (1, n_files
4590 * sizeof (File_Entry
));
4592 for (entryi
= 0; entryi
< n_files
; entryi
++)
4594 File_Entry
*file
= &file_table
[entryi
];
4596 format
= format_start
;
4597 for (formati
= 0; formati
< format_count
; formati
++)
4599 dwarf_vma content_type
, form
;
4602 content_type
= read_uleb128 (format
, & bytes_read
, end
);
4603 format
+= bytes_read
;
4604 form
= read_uleb128 (format
, & bytes_read
, end
);
4605 format
+= bytes_read
;
4608 warn (_("Corrupt file name list\n"));
4611 switch (content_type
)
4616 case DW_FORM_string
:
4619 case DW_FORM_line_strp
:
4620 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4622 /* Remove const by the cast. */
4623 file
->name
= (unsigned char *)
4624 fetch_indirect_line_string (uvalue
);
4628 case DW_LNCT_directory_index
:
4632 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4636 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4640 file
->directory_index
= read_uleb128 (data
, NULL
,
4646 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4648 linfo
.li_offset_size
,
4655 warn (_("Corrupt file name list\n"));
4664 unsigned char *ptr_directory_table
= data
;
4666 while (data
< end
&& *data
!= 0)
4668 data
+= strnlen ((char *) data
, end
- data
) + 1;
4675 warn (_("directory table ends unexpectedly\n"));
4680 /* Go through the directory table again to save the directories. */
4681 directory_table
= (unsigned char **)
4682 xmalloc (n_directories
* sizeof (unsigned char *));
4685 while (*ptr_directory_table
!= 0)
4687 directory_table
[i
] = ptr_directory_table
;
4688 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4689 ptr_directory_table
- end
) + 1;
4693 /* Skip the NUL at the end of the table. */
4696 /* Traverse the File Name table just to count the entries. */
4697 if (data
< end
&& *data
!= 0)
4699 unsigned char *ptr_file_name_table
= data
;
4701 while (data
< end
&& *data
!= 0)
4703 unsigned int bytes_read
;
4705 /* Skip Name, directory index, last modification time and length
4707 data
+= strnlen ((char *) data
, end
- data
) + 1;
4708 read_uleb128 (data
, & bytes_read
, end
);
4710 read_uleb128 (data
, & bytes_read
, end
);
4712 read_uleb128 (data
, & bytes_read
, end
);
4720 warn (_("file table ends unexpectedly\n"));
4725 /* Go through the file table again to save the strings. */
4726 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4729 while (*ptr_file_name_table
!= 0)
4731 unsigned int bytes_read
;
4733 file_table
[i
].name
= ptr_file_name_table
;
4734 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4735 end
- ptr_file_name_table
) + 1;
4737 /* We are not interested in directory, time or size. */
4738 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
4740 ptr_file_name_table
+= bytes_read
;
4741 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
4743 ptr_file_name_table
+= bytes_read
;
4744 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
4745 ptr_file_name_table
+= bytes_read
;
4751 /* Skip the NUL at the end of the table. */
4755 /* Print the Compilation Unit's name and a header. */
4756 if (file_table
== NULL
)
4758 else if (directory_table
== NULL
)
4759 printf (_("CU: %s:\n"), file_table
[0].name
);
4762 unsigned int ix
= file_table
[0].directory_index
;
4763 const char *directory
;
4768 else if (n_directories
== 0)
4769 directory
= _("<unknown>");
4770 else if (ix
> n_directories
)
4772 warn (_("directory index %u > number of directories %s\n"),
4773 ix
, dwarf_vmatoa ("u", n_directories
));
4774 directory
= _("<corrupt>");
4777 directory
= (char *) directory_table
[ix
- 1];
4779 if (do_wide
|| strlen (directory
) < 76)
4780 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4782 printf ("%s:\n", file_table
[0].name
);
4785 printf (_("File name Line number Starting address View Stmt\n"));
4786 saved_linfo
= linfo
;
4789 /* This loop iterates through the Dwarf Line Number Program. */
4790 while (data
< end_of_sequence
)
4792 unsigned char op_code
;
4795 unsigned long int uladv
;
4796 unsigned int bytes_read
;
4797 int is_special_opcode
= 0;
4802 if (op_code
>= linfo
.li_opcode_base
)
4804 op_code
-= linfo
.li_opcode_base
;
4805 uladv
= (op_code
/ linfo
.li_line_range
);
4806 if (linfo
.li_max_ops_per_insn
== 1)
4808 uladv
*= linfo
.li_min_insn_length
;
4809 state_machine_regs
.address
+= uladv
;
4811 state_machine_regs
.view
= 0;
4816 = ((state_machine_regs
.op_index
+ uladv
)
4817 / linfo
.li_max_ops_per_insn
)
4818 * linfo
.li_min_insn_length
;
4819 state_machine_regs
.address
4821 state_machine_regs
.op_index
4822 = (state_machine_regs
.op_index
+ uladv
)
4823 % linfo
.li_max_ops_per_insn
;
4825 state_machine_regs
.view
= 0;
4828 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4829 state_machine_regs
.line
+= adv
;
4830 is_special_opcode
= 1;
4831 /* Increment view after printing this row. */
4833 else switch (op_code
)
4835 case DW_LNS_extended_op
:
4837 unsigned int ext_op_code_len
;
4838 unsigned char ext_op_code
;
4839 unsigned char *op_code_data
= data
;
4841 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
4843 op_code_data
+= bytes_read
;
4845 if (ext_op_code_len
== 0)
4847 warn (_("Badly formed extended line op encountered!\n"));
4850 ext_op_code_len
+= bytes_read
;
4851 ext_op_code
= *op_code_data
++;
4855 switch (ext_op_code
)
4857 case DW_LNE_end_sequence
:
4858 /* Reset stuff after printing this row. */
4860 case DW_LNE_set_address
:
4861 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4863 ext_op_code_len
- bytes_read
- 1,
4865 state_machine_regs
.op_index
= 0;
4866 state_machine_regs
.view
= 0;
4868 case DW_LNE_define_file
:
4870 file_table
= (File_Entry
*) xrealloc
4871 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4873 ++state_machine_regs
.last_file_entry
;
4874 /* Source file name. */
4875 file_table
[n_files
].name
= op_code_data
;
4876 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4877 /* Directory index. */
4878 file_table
[n_files
].directory_index
=
4879 read_uleb128 (op_code_data
, & bytes_read
,
4881 op_code_data
+= bytes_read
;
4882 /* Last modification time. */
4883 file_table
[n_files
].modification_date
=
4884 read_uleb128 (op_code_data
, & bytes_read
,
4886 op_code_data
+= bytes_read
;
4888 file_table
[n_files
].length
=
4889 read_uleb128 (op_code_data
, & bytes_read
,
4895 case DW_LNE_set_discriminator
:
4896 case DW_LNE_HP_set_sequence
:
4897 /* Simply ignored. */
4901 printf (_("UNKNOWN (%u): length %d\n"),
4902 ext_op_code
, ext_op_code_len
- bytes_read
);
4905 data
+= ext_op_code_len
;
4909 /* Increment view after printing this row. */
4912 case DW_LNS_advance_pc
:
4913 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4915 if (linfo
.li_max_ops_per_insn
== 1)
4917 uladv
*= linfo
.li_min_insn_length
;
4918 state_machine_regs
.address
+= uladv
;
4920 state_machine_regs
.view
= 0;
4925 = ((state_machine_regs
.op_index
+ uladv
)
4926 / linfo
.li_max_ops_per_insn
)
4927 * linfo
.li_min_insn_length
;
4928 state_machine_regs
.address
4930 state_machine_regs
.op_index
4931 = (state_machine_regs
.op_index
+ uladv
)
4932 % linfo
.li_max_ops_per_insn
;
4934 state_machine_regs
.view
= 0;
4938 case DW_LNS_advance_line
:
4939 adv
= read_sleb128 (data
, & bytes_read
, end
);
4941 state_machine_regs
.line
+= adv
;
4944 case DW_LNS_set_file
:
4945 adv
= read_uleb128 (data
, & bytes_read
, end
);
4947 state_machine_regs
.file
= adv
;
4950 unsigned file
= state_machine_regs
.file
- 1;
4953 if (file_table
== NULL
|| n_files
== 0)
4954 printf (_("\n [Use file table entry %d]\n"), file
);
4956 else if (file
>= n_files
)
4958 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4959 printf (_("\n <over large file table index %u>"), file
);
4961 else if ((dir
= file_table
[file
].directory_index
) == 0)
4962 /* If directory index is 0, that means current directory. */
4963 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4964 else if (directory_table
== NULL
|| n_directories
== 0)
4965 printf (_("\n [Use file %s in directory table entry %d]\n"),
4966 file_table
[file
].name
, dir
);
4968 else if (dir
> n_directories
)
4970 warn (_("directory index %u > number of directories %s\n"),
4971 dir
, dwarf_vmatoa ("u", n_directories
));
4972 printf (_("\n <over large directory table entry %u>\n"), dir
);
4975 printf ("\n%s/%s:\n",
4976 /* The directory index starts counting at 1. */
4977 directory_table
[dir
- 1], file_table
[file
].name
);
4981 case DW_LNS_set_column
:
4982 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4984 state_machine_regs
.column
= uladv
;
4987 case DW_LNS_negate_stmt
:
4988 adv
= state_machine_regs
.is_stmt
;
4990 state_machine_regs
.is_stmt
= adv
;
4993 case DW_LNS_set_basic_block
:
4994 state_machine_regs
.basic_block
= 1;
4997 case DW_LNS_const_add_pc
:
4998 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4999 if (linfo
.li_max_ops_per_insn
== 1)
5001 uladv
*= linfo
.li_min_insn_length
;
5002 state_machine_regs
.address
+= uladv
;
5004 state_machine_regs
.view
= 0;
5009 = ((state_machine_regs
.op_index
+ uladv
)
5010 / linfo
.li_max_ops_per_insn
)
5011 * linfo
.li_min_insn_length
;
5012 state_machine_regs
.address
5014 state_machine_regs
.op_index
5015 = (state_machine_regs
.op_index
+ uladv
)
5016 % linfo
.li_max_ops_per_insn
;
5018 state_machine_regs
.view
= 0;
5022 case DW_LNS_fixed_advance_pc
:
5023 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5024 state_machine_regs
.address
+= uladv
;
5025 state_machine_regs
.op_index
= 0;
5026 /* Do NOT reset view. */
5029 case DW_LNS_set_prologue_end
:
5032 case DW_LNS_set_epilogue_begin
:
5035 case DW_LNS_set_isa
:
5036 uladv
= read_uleb128 (data
, & bytes_read
, end
);
5038 printf (_(" Set ISA to %lu\n"), uladv
);
5042 printf (_(" Unknown opcode %d with operands: "), op_code
);
5044 if (standard_opcodes
!= NULL
)
5045 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5047 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
5049 i
== 1 ? "" : ", ");
5056 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5057 to the DWARF address/line matrix. */
5058 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5059 || (xop
== DW_LNS_copy
))
5061 const unsigned int MAX_FILENAME_LENGTH
= 35;
5063 char *newFileName
= NULL
;
5064 size_t fileNameLength
;
5068 unsigned indx
= state_machine_regs
.file
- 1;
5070 if (indx
>= n_files
)
5072 warn (_("corrupt file index %u encountered\n"), indx
);
5073 fileName
= _("<corrupt>");
5076 fileName
= (char *) file_table
[indx
].name
;
5079 fileName
= _("<unknown>");
5081 fileNameLength
= strlen (fileName
);
5083 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
5085 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5086 /* Truncate file name */
5087 strncpy (newFileName
,
5088 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5089 MAX_FILENAME_LENGTH
+ 1);
5093 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
5094 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
5097 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
5099 if (linfo
.li_max_ops_per_insn
== 1)
5100 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
5101 newFileName
, state_machine_regs
.line
,
5102 state_machine_regs
.address
);
5104 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5105 newFileName
, state_machine_regs
.line
,
5106 state_machine_regs
.address
,
5107 state_machine_regs
.op_index
);
5111 if (linfo
.li_max_ops_per_insn
== 1)
5112 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5113 newFileName
, state_machine_regs
.line
,
5114 state_machine_regs
.address
);
5116 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5117 newFileName
, state_machine_regs
.line
,
5118 state_machine_regs
.address
,
5119 state_machine_regs
.op_index
);
5122 if (state_machine_regs
.view
)
5123 printf (" %6u", state_machine_regs
.view
);
5127 if (state_machine_regs
.is_stmt
)
5131 state_machine_regs
.view
++;
5133 if (xop
== -DW_LNE_end_sequence
)
5135 reset_state_machine (linfo
.li_default_is_stmt
);
5150 if (directory_table
)
5152 free (directory_table
);
5153 directory_table
= NULL
;
5164 display_debug_lines (struct dwarf_section
*section
, void *file
)
5166 unsigned char *data
= section
->start
;
5167 unsigned char *end
= data
+ section
->size
;
5169 int retValDecoded
= 1;
5171 if (do_debug_lines
== 0)
5172 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5174 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5175 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5177 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5178 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5180 if (!retValRaw
|| !retValDecoded
)
5187 find_debug_info_for_offset (unsigned long offset
)
5191 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5194 for (i
= 0; i
< num_debug_info_entries
; i
++)
5195 if (debug_information
[i
].cu_offset
== offset
)
5196 return debug_information
+ i
;
5202 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5204 /* See gdb/gdb-index.h. */
5205 static const char * const kinds
[] =
5217 return _ (kinds
[kind
]);
5221 display_debug_pubnames_worker (struct dwarf_section
*section
,
5222 void *file ATTRIBUTE_UNUSED
,
5225 DWARF2_Internal_PubNames names
;
5226 unsigned char *start
= section
->start
;
5227 unsigned char *end
= start
+ section
->size
;
5229 /* It does not matter if this load fails,
5230 we test for that later on. */
5231 load_debug_info (file
);
5233 introduce (section
, FALSE
);
5237 unsigned char *data
;
5238 unsigned long sec_off
;
5239 unsigned int offset_size
, initial_length_size
;
5241 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5242 if (names
.pn_length
== 0xffffffff)
5244 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5246 initial_length_size
= 12;
5251 initial_length_size
= 4;
5254 sec_off
= start
- section
->start
;
5255 if (sec_off
+ names
.pn_length
< sec_off
5256 || sec_off
+ names
.pn_length
> section
->size
)
5258 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5260 sec_off
- initial_length_size
,
5261 dwarf_vmatoa ("x", names
.pn_length
));
5266 start
+= names
.pn_length
;
5268 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5269 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5271 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5272 && num_debug_info_entries
> 0
5273 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5274 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5275 (unsigned long) names
.pn_offset
, section
->name
);
5277 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5279 printf (_(" Length: %ld\n"),
5280 (long) names
.pn_length
);
5281 printf (_(" Version: %d\n"),
5283 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5284 (unsigned long) names
.pn_offset
);
5285 printf (_(" Size of area in .debug_info section: %ld\n"),
5286 (long) names
.pn_size
);
5288 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5290 static int warned
= 0;
5294 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5302 printf (_("\n Offset Kind Name\n"));
5304 printf (_("\n Offset\tName\n"));
5308 bfd_size_type maxprint
;
5311 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5316 data
+= offset_size
;
5319 maxprint
= (end
- data
) - 1;
5323 unsigned int kind_data
;
5324 gdb_index_symbol_kind kind
;
5325 const char *kind_name
;
5328 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5331 /* GCC computes the kind as the upper byte in the CU index
5332 word, and then right shifts it by the CU index size.
5333 Left shift KIND to where the gdb-index.h accessor macros
5335 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5336 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5337 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5338 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5339 printf (" %-6lx %s,%-10s %.*s\n",
5340 (unsigned long) offset
, is_static
? _("s") : _("g"),
5341 kind_name
, (int) maxprint
, data
);
5344 printf (" %-6lx\t%.*s\n",
5345 (unsigned long) offset
, (int) maxprint
, data
);
5347 data
+= strnlen ((char *) data
, maxprint
) + 1;
5358 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5360 return display_debug_pubnames_worker (section
, file
, 0);
5364 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5366 return display_debug_pubnames_worker (section
, file
, 1);
5370 display_debug_macinfo (struct dwarf_section
*section
,
5371 void *file ATTRIBUTE_UNUSED
)
5373 unsigned char *start
= section
->start
;
5374 unsigned char *end
= start
+ section
->size
;
5375 unsigned char *curr
= start
;
5376 unsigned int bytes_read
;
5377 enum dwarf_macinfo_record_type op
;
5379 introduce (section
, FALSE
);
5383 unsigned int lineno
;
5384 const unsigned char *string
;
5386 op
= (enum dwarf_macinfo_record_type
) *curr
;
5391 case DW_MACINFO_start_file
:
5393 unsigned int filenum
;
5395 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
5397 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
5400 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5405 case DW_MACINFO_end_file
:
5406 printf (_(" DW_MACINFO_end_file\n"));
5409 case DW_MACINFO_define
:
5410 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
5413 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5414 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5418 case DW_MACINFO_undef
:
5419 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
5422 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5423 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5427 case DW_MACINFO_vendor_ext
:
5429 unsigned int constant
;
5431 constant
= read_uleb128 (curr
, & bytes_read
, end
);
5434 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5435 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5445 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5446 filename and dirname corresponding to file name table entry with index
5447 FILEIDX. Return NULL on failure. */
5449 static unsigned char *
5450 get_line_filename_and_dirname (dwarf_vma line_offset
,
5452 unsigned char **dir_name
)
5454 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5455 unsigned char *hdrptr
, *dirtable
, *file_name
;
5456 unsigned int offset_size
, initial_length_size
;
5457 unsigned int version
, opcode_base
, bytes_read
;
5458 dwarf_vma length
, diridx
;
5459 const unsigned char * end
;
5462 if (section
->start
== NULL
5463 || line_offset
>= section
->size
5467 hdrptr
= section
->start
+ line_offset
;
5468 end
= section
->start
+ section
->size
;
5470 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5471 if (length
== 0xffffffff)
5473 /* This section is 64-bit DWARF 3. */
5474 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5476 initial_length_size
= 12;
5481 initial_length_size
= 4;
5483 if (length
+ initial_length_size
< length
5484 || length
+ initial_length_size
> section
->size
)
5487 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5488 if (version
!= 2 && version
!= 3 && version
!= 4)
5490 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5492 hdrptr
++; /* Skip max_ops_per_insn. */
5493 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5495 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5496 if (opcode_base
== 0)
5499 hdrptr
+= opcode_base
- 1;
5504 /* Skip over dirname table. */
5505 while (*hdrptr
!= '\0')
5507 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5511 hdrptr
++; /* Skip the NUL at the end of the table. */
5513 /* Now skip over preceding filename table entries. */
5514 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5516 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5517 read_uleb128 (hdrptr
, &bytes_read
, end
);
5518 hdrptr
+= bytes_read
;
5519 read_uleb128 (hdrptr
, &bytes_read
, end
);
5520 hdrptr
+= bytes_read
;
5521 read_uleb128 (hdrptr
, &bytes_read
, end
);
5522 hdrptr
+= bytes_read
;
5524 if (hdrptr
>= end
|| *hdrptr
== '\0')
5528 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5531 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
5534 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5535 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5536 if (dirtable
>= end
|| *dirtable
== '\0')
5538 *dir_name
= dirtable
;
5543 display_debug_macro (struct dwarf_section
*section
,
5546 unsigned char *start
= section
->start
;
5547 unsigned char *end
= start
+ section
->size
;
5548 unsigned char *curr
= start
;
5549 unsigned char *extended_op_buf
[256];
5550 unsigned int bytes_read
;
5552 load_debug_section_with_follow (str
, file
);
5553 load_debug_section_with_follow (line
, file
);
5555 introduce (section
, FALSE
);
5559 unsigned int lineno
, version
, flags
;
5560 unsigned int offset_size
= 4;
5561 const unsigned char *string
;
5562 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5563 unsigned char **extended_ops
= NULL
;
5565 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5566 if (version
!= 4 && version
!= 5)
5568 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5573 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5576 printf (_(" Offset: 0x%lx\n"),
5577 (unsigned long) sec_offset
);
5578 printf (_(" Version: %d\n"), version
);
5579 printf (_(" Offset size: %d\n"), offset_size
);
5582 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5583 printf (_(" Offset into .debug_line: 0x%lx\n"),
5584 (unsigned long) line_offset
);
5588 unsigned int i
, count
, op
;
5591 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5593 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5594 extended_ops
= extended_op_buf
;
5597 printf (_(" Extension opcode arguments:\n"));
5598 for (i
= 0; i
< count
; i
++)
5600 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5601 extended_ops
[op
] = curr
;
5602 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
5605 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5608 printf (_(" DW_MACRO_%02x arguments: "), op
);
5609 for (n
= 0; n
< nargs
; n
++)
5613 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5614 printf ("%s%s", get_FORM_name (form
),
5615 n
== nargs
- 1 ? "\n" : ", ");
5625 case DW_FORM_block1
:
5626 case DW_FORM_block2
:
5627 case DW_FORM_block4
:
5629 case DW_FORM_string
:
5631 case DW_FORM_sec_offset
:
5634 error (_("Invalid extension opcode form %s\n"),
5635 get_FORM_name (form
));
5651 error (_(".debug_macro section not zero terminated\n"));
5655 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5661 case DW_MACRO_start_file
:
5663 unsigned int filenum
;
5664 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5666 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5668 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
5671 if ((flags
& 2) == 0)
5672 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5675 = get_line_filename_and_dirname (line_offset
, filenum
,
5677 if (file_name
== NULL
)
5678 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5681 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5683 dir_name
!= NULL
? (const char *) dir_name
: "",
5684 dir_name
!= NULL
? "/" : "", file_name
);
5688 case DW_MACRO_end_file
:
5689 printf (_(" DW_MACRO_end_file\n"));
5692 case DW_MACRO_define
:
5693 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5696 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5697 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5701 case DW_MACRO_undef
:
5702 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5705 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5706 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5710 case DW_MACRO_define_strp
:
5711 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5713 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5714 string
= fetch_indirect_string (offset
);
5715 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5719 case DW_MACRO_undef_strp
:
5720 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5722 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5723 string
= fetch_indirect_string (offset
);
5724 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5728 case DW_MACRO_import
:
5729 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5730 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5731 (unsigned long) offset
);
5734 case DW_MACRO_define_sup
:
5735 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5737 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5738 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5739 lineno
, (unsigned long) offset
);
5742 case DW_MACRO_undef_sup
:
5743 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5745 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5746 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5747 lineno
, (unsigned long) offset
);
5750 case DW_MACRO_import_sup
:
5751 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5752 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5753 (unsigned long) offset
);
5757 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5759 error (_(" Unknown macro opcode %02x seen\n"), op
);
5764 /* Skip over unhandled opcodes. */
5766 unsigned char *desc
= extended_ops
[op
];
5767 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
5771 printf (_(" DW_MACRO_%02x\n"), op
);
5774 printf (_(" DW_MACRO_%02x -"), op
);
5775 for (n
= 0; n
< nargs
; n
++)
5779 /* DW_FORM_implicit_const is not expected here. */
5780 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5782 = read_and_display_attr_value (0, val
, 0,
5783 start
, curr
, end
, 0, 0, offset_size
,
5784 version
, NULL
, 0, NULL
,
5802 display_debug_abbrev (struct dwarf_section
*section
,
5803 void *file ATTRIBUTE_UNUSED
)
5805 abbrev_entry
*entry
;
5806 unsigned char *start
= section
->start
;
5807 unsigned char *end
= start
+ section
->size
;
5809 introduce (section
, FALSE
);
5813 unsigned char *last
;
5818 start
= process_abbrev_section (start
, end
);
5820 if (first_abbrev
== NULL
)
5823 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5825 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5829 printf (" %ld %s [%s]\n",
5831 get_TAG_name (entry
->tag
),
5832 entry
->children
? _("has children") : _("no children"));
5834 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5836 printf (" %-18s %s",
5837 get_AT_name (attr
->attribute
),
5838 get_FORM_name (attr
->form
));
5839 if (attr
->form
== DW_FORM_implicit_const
)
5840 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5852 /* Return true when ADDR is the maximum address, when addresses are
5853 POINTER_SIZE bytes long. */
5856 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5858 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5859 return ((addr
& mask
) == mask
);
5862 /* Display a view pair list starting at *VSTART_PTR and ending at
5863 VLISTEND within SECTION. */
5866 display_view_pair_list (struct dwarf_section
*section
,
5867 unsigned char **vstart_ptr
,
5868 unsigned int debug_info_entry
,
5869 unsigned char *vlistend
)
5871 unsigned char *vstart
= *vstart_ptr
;
5872 unsigned char *section_end
= section
->start
+ section
->size
;
5873 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5875 if (vlistend
< section_end
)
5876 section_end
= vlistend
;
5880 while (vstart
< section_end
)
5882 dwarf_vma off
= vstart
- section
->start
;
5883 dwarf_vma vbegin
, vend
;
5885 unsigned int bytes_read
;
5886 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5887 vstart
+= bytes_read
;
5888 if (vstart
== section_end
)
5890 vstart
-= bytes_read
;
5894 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5895 vstart
+= bytes_read
;
5897 printf (" %8.8lx ", (unsigned long) off
);
5899 print_dwarf_view (vbegin
, pointer_size
, 1);
5900 print_dwarf_view (vend
, pointer_size
, 1);
5901 printf (_("location view pair\n"));
5905 *vstart_ptr
= vstart
;
5908 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5911 display_loc_list (struct dwarf_section
*section
,
5912 unsigned char **start_ptr
,
5913 unsigned int debug_info_entry
,
5915 dwarf_vma base_address
,
5916 unsigned char **vstart_ptr
,
5919 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5920 unsigned char *section_end
= section
->start
+ section
->size
;
5921 unsigned long cu_offset
;
5922 unsigned int pointer_size
;
5923 unsigned int offset_size
;
5928 unsigned short length
;
5929 int need_frame_base
;
5931 if (debug_info_entry
>= num_debug_info_entries
)
5933 warn (_("No debug information available for loc lists of entry: %u\n"),
5938 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5939 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5940 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5941 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5943 if (pointer_size
< 2 || pointer_size
> 8)
5945 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5946 pointer_size
, debug_info_entry
);
5952 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5953 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5955 if (start
+ 2 * pointer_size
> section_end
)
5957 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5958 (unsigned long) offset
);
5962 printf (" %8.8lx ", (unsigned long) off
);
5964 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5965 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5967 if (begin
== 0 && end
== 0)
5969 /* PR 18374: In a object file we can have a location list that
5970 starts with a begin and end of 0 because there are relocations
5971 that need to be applied to the addresses. Actually applying
5972 the relocations now does not help as they will probably resolve
5973 to 0, since the object file has not been fully linked. Real
5974 end of list markers will not have any relocations against them. */
5975 if (! reloc_at (section
, off
)
5976 && ! reloc_at (section
, off
+ pointer_size
))
5978 printf (_("<End of list>\n"));
5983 /* Check base address specifiers. */
5984 if (is_max_address (begin
, pointer_size
)
5985 && !is_max_address (end
, pointer_size
))
5988 print_dwarf_vma (begin
, pointer_size
);
5989 print_dwarf_vma (end
, pointer_size
);
5990 printf (_("(base address)\n"));
5996 unsigned int bytes_read
;
5998 off
= offset
+ (vstart
- *start_ptr
);
6000 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
6001 vstart
+= bytes_read
;
6002 print_dwarf_view (vbegin
, pointer_size
, 1);
6004 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
6005 vstart
+= bytes_read
;
6006 print_dwarf_view (vend
, pointer_size
, 1);
6008 printf (_("views at %8.8lx for:\n %*s "),
6009 (unsigned long) off
, 8, "");
6012 if (start
+ 2 > section_end
)
6014 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6015 (unsigned long) offset
);
6019 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6021 if (start
+ length
> section_end
)
6023 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6024 (unsigned long) offset
);
6028 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6029 print_dwarf_vma (end
+ base_address
, pointer_size
);
6032 need_frame_base
= decode_location_expression (start
,
6037 cu_offset
, section
);
6040 if (need_frame_base
&& !has_frame_base
)
6041 printf (_(" [without DW_AT_frame_base]"));
6043 if (begin
== end
&& vbegin
== vend
)
6044 fputs (_(" (start == end)"), stdout
);
6045 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6046 fputs (_(" (start > end)"), stdout
);
6054 *vstart_ptr
= vstart
;
6057 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6060 display_loclists_list (struct dwarf_section
*section
,
6061 unsigned char **start_ptr
,
6062 unsigned int debug_info_entry
,
6064 dwarf_vma base_address
,
6065 unsigned char **vstart_ptr
,
6068 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6069 unsigned char *section_end
= section
->start
+ section
->size
;
6070 unsigned long cu_offset
;
6071 unsigned int pointer_size
;
6072 unsigned int offset_size
;
6074 unsigned int bytes_read
;
6076 /* Initialize it due to a false compiler warning. */
6077 dwarf_vma begin
= -1, vbegin
= -1;
6078 dwarf_vma end
= -1, vend
= -1;
6080 int need_frame_base
;
6082 if (debug_info_entry
>= num_debug_info_entries
)
6084 warn (_("No debug information available for "
6085 "loclists lists of entry: %u\n"),
6090 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6091 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6092 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6093 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6095 if (pointer_size
< 2 || pointer_size
> 8)
6097 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6098 pointer_size
, debug_info_entry
);
6104 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6105 enum dwarf_location_list_entry_type llet
;
6107 if (start
+ 1 > section_end
)
6109 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6110 (unsigned long) offset
);
6114 printf (" %8.8lx ", (unsigned long) off
);
6116 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6118 if (vstart
&& llet
== DW_LLE_offset_pair
)
6120 off
= offset
+ (vstart
- *start_ptr
);
6122 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
6123 vstart
+= bytes_read
;
6124 print_dwarf_view (vbegin
, pointer_size
, 1);
6126 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
6127 vstart
+= bytes_read
;
6128 print_dwarf_view (vend
, pointer_size
, 1);
6130 printf (_("views at %8.8lx for:\n %*s "),
6131 (unsigned long) off
, 8, "");
6136 case DW_LLE_end_of_list
:
6137 printf (_("<End of list>\n"));
6139 case DW_LLE_offset_pair
:
6140 begin
= read_uleb128 (start
, &bytes_read
, section_end
);
6141 start
+= bytes_read
;
6142 end
= read_uleb128 (start
, &bytes_read
, section_end
);
6143 start
+= bytes_read
;
6145 case DW_LLE_base_address
:
6146 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6148 print_dwarf_vma (base_address
, pointer_size
);
6149 printf (_("(base address)\n"));
6151 #ifdef DW_LLE_view_pair
6152 case DW_LLE_view_pair
:
6154 printf (_("View pair entry in loclist with locviews attribute\n"));
6155 vbegin
= read_uleb128 (start
, &bytes_read
, section_end
);
6156 start
+= bytes_read
;
6157 print_dwarf_view (vbegin
, pointer_size
, 1);
6159 vend
= read_uleb128 (start
, &bytes_read
, section_end
);
6160 start
+= bytes_read
;
6161 print_dwarf_view (vend
, pointer_size
, 1);
6163 printf (_("views for:\n"));
6167 error (_("Invalid location list entry type %d\n"), llet
);
6170 if (llet
== DW_LLE_end_of_list
)
6172 if (llet
!= DW_LLE_offset_pair
)
6175 if (start
+ 2 > section_end
)
6177 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6178 (unsigned long) offset
);
6182 length
= read_uleb128 (start
, &bytes_read
, section_end
);
6183 start
+= bytes_read
;
6185 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6186 print_dwarf_vma (end
+ base_address
, pointer_size
);
6189 need_frame_base
= decode_location_expression (start
,
6194 cu_offset
, section
);
6197 if (need_frame_base
&& !has_frame_base
)
6198 printf (_(" [without DW_AT_frame_base]"));
6200 if (begin
== end
&& vbegin
== vend
)
6201 fputs (_(" (start == end)"), stdout
);
6202 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6203 fputs (_(" (start > end)"), stdout
);
6211 if (vbegin
!= vm1
|| vend
!= vm1
)
6212 printf (_("Trailing view pair not used in a range"));
6215 *vstart_ptr
= vstart
;
6218 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6219 right-adjusted in a field of length LEN, and followed by a space. */
6222 print_addr_index (unsigned int idx
, unsigned int len
)
6224 static char buf
[15];
6225 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6226 printf ("%*s ", len
, buf
);
6229 /* Display a location list from a .dwo section. It uses address indexes rather
6230 than embedded addresses. This code closely follows display_loc_list, but the
6231 two are sufficiently different that combining things is very ugly. */
6234 display_loc_list_dwo (struct dwarf_section
*section
,
6235 unsigned char **start_ptr
,
6236 unsigned int debug_info_entry
,
6238 unsigned char **vstart_ptr
,
6241 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6242 unsigned char *section_end
= section
->start
+ section
->size
;
6243 unsigned long cu_offset
;
6244 unsigned int pointer_size
;
6245 unsigned int offset_size
;
6248 unsigned short length
;
6249 int need_frame_base
;
6251 unsigned int bytes_read
;
6253 if (debug_info_entry
>= num_debug_info_entries
)
6255 warn (_("No debug information for loc lists of entry: %u\n"),
6260 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6261 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6262 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6263 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6265 if (pointer_size
< 2 || pointer_size
> 8)
6267 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6268 pointer_size
, debug_info_entry
);
6274 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6276 if (start
>= section_end
)
6278 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6279 (unsigned long) offset
);
6283 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6296 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6298 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
6299 vstart
+= bytes_read
;
6300 print_dwarf_view (view
, 8, 1);
6302 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
6303 vstart
+= bytes_read
;
6304 print_dwarf_view (view
, 8, 1);
6306 printf (_("views at %8.8lx for:\n %*s "),
6307 (unsigned long) off
, 8, "");
6315 case 0: /* A terminating entry. */
6317 *vstart_ptr
= vstart
;
6318 printf (_("<End of list>\n"));
6320 case 1: /* A base-address entry. */
6321 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
6322 start
+= bytes_read
;
6323 print_addr_index (idx
, 8);
6324 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6325 printf (_("(base address selection entry)\n"));
6327 case 2: /* A start/end entry. */
6328 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
6329 start
+= bytes_read
;
6330 print_addr_index (idx
, 8);
6331 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
6332 start
+= bytes_read
;
6333 print_addr_index (idx
, 8);
6335 case 3: /* A start/length entry. */
6336 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
6337 start
+= bytes_read
;
6338 print_addr_index (idx
, 8);
6339 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6340 printf ("%08x ", idx
);
6342 case 4: /* An offset pair entry. */
6343 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6344 printf ("%08x ", idx
);
6345 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6346 printf ("%08x ", idx
);
6349 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6351 *vstart_ptr
= vstart
;
6355 if (start
+ 2 > section_end
)
6357 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6358 (unsigned long) offset
);
6362 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6363 if (start
+ length
> section_end
)
6365 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6366 (unsigned long) offset
);
6371 need_frame_base
= decode_location_expression (start
,
6376 cu_offset
, section
);
6379 if (need_frame_base
&& !has_frame_base
)
6380 printf (_(" [without DW_AT_frame_base]"));
6388 *vstart_ptr
= vstart
;
6391 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6394 static dwarf_vma
*loc_offsets
, *loc_views
;
6397 loc_offsets_compar (const void *ap
, const void *bp
)
6399 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6400 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6402 int ret
= (a
> b
) - (b
> a
);
6406 a
= loc_views
[*(const unsigned int *) ap
];
6407 b
= loc_views
[*(const unsigned int *) bp
];
6409 ret
= (a
> b
) - (b
> a
);
6415 display_debug_loc (struct dwarf_section
*section
, void *file
)
6417 unsigned char *start
= section
->start
, *vstart
= NULL
;
6418 unsigned long bytes
;
6419 unsigned char *section_begin
= start
;
6420 unsigned int num_loc_list
= 0;
6421 unsigned long last_offset
= 0;
6422 unsigned long last_view
= 0;
6423 unsigned int first
= 0;
6426 int seen_first_offset
= 0;
6427 int locs_sorted
= 1;
6428 unsigned char *next
= start
, *vnext
= vstart
;
6429 unsigned int *array
= NULL
;
6430 const char *suffix
= strrchr (section
->name
, '.');
6431 bfd_boolean is_dwo
= FALSE
;
6432 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6433 dwarf_vma expected_start
= 0;
6435 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6438 bytes
= section
->size
;
6442 printf (_("\nThe %s section is empty.\n"), section
->name
);
6448 unsigned char *hdrptr
= section_begin
;
6449 dwarf_vma ll_length
;
6450 unsigned short ll_version
;
6451 unsigned char *end
= section_begin
+ section
->size
;
6452 unsigned char address_size
, segment_selector_size
;
6453 uint32_t offset_entry_count
;
6455 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6456 if (ll_length
== 0xffffffff)
6457 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6459 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6460 if (ll_version
!= 5)
6462 warn (_("The %s section contains corrupt or "
6463 "unsupported version number: %d.\n"),
6464 section
->name
, ll_version
);
6468 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6470 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6471 if (segment_selector_size
!= 0)
6473 warn (_("The %s section contains "
6474 "unsupported segment selector size: %d.\n"),
6475 section
->name
, segment_selector_size
);
6479 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6480 if (offset_entry_count
!= 0)
6482 warn (_("The %s section contains "
6483 "unsupported offset entry count: %d.\n"),
6484 section
->name
, offset_entry_count
);
6488 expected_start
= hdrptr
- section_begin
;
6491 if (load_debug_info (file
) == 0)
6493 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6498 /* Check the order of location list in .debug_info section. If
6499 offsets of location lists are in the ascending order, we can
6500 use `debug_information' directly. */
6501 for (i
= 0; i
< num_debug_info_entries
; i
++)
6505 num
= debug_information
[i
].num_loc_offsets
;
6506 if (num
> num_loc_list
)
6509 /* Check if we can use `debug_information' directly. */
6510 if (locs_sorted
&& num
!= 0)
6512 if (!seen_first_offset
)
6514 /* This is the first location list. */
6515 last_offset
= debug_information
[i
].loc_offsets
[0];
6516 last_view
= debug_information
[i
].loc_views
[0];
6518 seen_first_offset
= 1;
6524 for (; j
< num
; j
++)
6527 debug_information
[i
].loc_offsets
[j
]
6528 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6529 && last_view
> debug_information
[i
].loc_views
[j
]))
6534 last_offset
= debug_information
[i
].loc_offsets
[j
];
6535 last_view
= debug_information
[i
].loc_views
[j
];
6540 if (!seen_first_offset
)
6541 error (_("No location lists in .debug_info section!\n"));
6543 if (debug_information
[first
].num_loc_offsets
> 0
6544 && debug_information
[first
].loc_offsets
[0] != expected_start
6545 && debug_information
[first
].loc_views
[0] != expected_start
)
6546 warn (_("Location lists in %s section start at 0x%s\n"),
6548 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6551 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6553 introduce (section
, FALSE
);
6555 if (reloc_at (section
, 0))
6556 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6558 printf (_(" Offset Begin End Expression\n"));
6560 seen_first_offset
= 0;
6561 for (i
= first
; i
< num_debug_info_entries
; i
++)
6563 dwarf_vma offset
, voffset
;
6564 dwarf_vma base_address
;
6570 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6572 loc_offsets
= debug_information
[i
].loc_offsets
;
6573 loc_views
= debug_information
[i
].loc_views
;
6574 qsort (array
, debug_information
[i
].num_loc_offsets
,
6575 sizeof (*array
), loc_offsets_compar
);
6578 int adjacent_view_loclists
= 1;
6579 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6581 j
= locs_sorted
? k
: array
[k
];
6583 && (debug_information
[i
].loc_offsets
[locs_sorted
6584 ? k
- 1 : array
[k
- 1]]
6585 == debug_information
[i
].loc_offsets
[j
])
6586 && (debug_information
[i
].loc_views
[locs_sorted
6587 ? k
- 1 : array
[k
- 1]]
6588 == debug_information
[i
].loc_views
[j
]))
6590 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6591 offset
= debug_information
[i
].loc_offsets
[j
];
6592 next
= section_begin
+ offset
;
6593 voffset
= debug_information
[i
].loc_views
[j
];
6595 vnext
= section_begin
+ voffset
;
6598 base_address
= debug_information
[i
].base_address
;
6600 if (vnext
&& vnext
< next
)
6603 display_view_pair_list (section
, &vstart
, i
, next
);
6608 if (!seen_first_offset
|| !adjacent_view_loclists
)
6609 seen_first_offset
= 1;
6613 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6614 (unsigned long) (start
- section_begin
),
6615 (unsigned long) offset
);
6616 else if (start
> next
)
6617 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6618 (unsigned long) (start
- section_begin
),
6619 (unsigned long) offset
);
6624 if (offset
>= bytes
)
6626 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6627 (unsigned long) offset
);
6631 if (vnext
&& voffset
>= bytes
)
6633 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6634 (unsigned long) voffset
);
6641 display_loc_list_dwo (section
, &start
, i
, offset
,
6642 &vstart
, has_frame_base
);
6644 display_loc_list (section
, &start
, i
, offset
, base_address
,
6645 &vstart
, has_frame_base
);
6650 warn (_("DWO is not yet supported.\n"));
6652 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6653 &vstart
, has_frame_base
);
6656 /* FIXME: this arrangement is quite simplistic. Nothing
6657 requires locview lists to be adjacent to corresponding
6658 loclists, and a single loclist could be augmented by
6659 different locview lists, and vice-versa, unlikely as it
6660 is that it would make sense to do so. Hopefully we'll
6661 have view pair support built into loclists before we ever
6662 need to address all these possibilities. */
6663 if (adjacent_view_loclists
&& vnext
6664 && vnext
!= start
&& vstart
!= next
)
6666 adjacent_view_loclists
= 0;
6667 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6670 if (vnext
&& vnext
== start
)
6671 display_view_pair_list (section
, &start
, i
, vstart
);
6675 if (start
< section
->start
+ section
->size
)
6676 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6677 "There are %ld unused bytes at the end of section %s\n",
6678 (long) (section
->start
+ section
->size
- start
)),
6679 (long) (section
->start
+ section
->size
- start
), section
->name
);
6686 display_debug_str (struct dwarf_section
*section
,
6687 void *file ATTRIBUTE_UNUSED
)
6689 unsigned char *start
= section
->start
;
6690 unsigned long bytes
= section
->size
;
6691 dwarf_vma addr
= section
->address
;
6695 printf (_("\nThe %s section is empty.\n"), section
->name
);
6699 introduce (section
, FALSE
);
6707 lbytes
= (bytes
> 16 ? 16 : bytes
);
6709 printf (" 0x%8.8lx ", (unsigned long) addr
);
6711 for (j
= 0; j
< 16; j
++)
6714 printf ("%2.2x", start
[j
]);
6722 for (j
= 0; j
< lbytes
; j
++)
6725 if (k
>= ' ' && k
< 0x80)
6744 display_debug_info (struct dwarf_section
*section
, void *file
)
6746 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6750 display_debug_types (struct dwarf_section
*section
, void *file
)
6752 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6756 display_trace_info (struct dwarf_section
*section
, void *file
)
6758 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6762 display_debug_aranges (struct dwarf_section
*section
,
6763 void *file ATTRIBUTE_UNUSED
)
6765 unsigned char *start
= section
->start
;
6766 unsigned char *end
= start
+ section
->size
;
6768 introduce (section
, FALSE
);
6770 /* It does not matter if this load fails,
6771 we test for that later on. */
6772 load_debug_info (file
);
6776 unsigned char *hdrptr
;
6777 DWARF2_Internal_ARange arange
;
6778 unsigned char *addr_ranges
;
6781 unsigned long sec_off
;
6782 unsigned char address_size
;
6784 unsigned int offset_size
;
6785 unsigned int initial_length_size
;
6789 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6790 if (arange
.ar_length
== 0xffffffff)
6792 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6794 initial_length_size
= 12;
6799 initial_length_size
= 4;
6802 sec_off
= hdrptr
- section
->start
;
6803 if (sec_off
+ arange
.ar_length
< sec_off
6804 || sec_off
+ arange
.ar_length
> section
->size
)
6806 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6808 sec_off
- initial_length_size
,
6809 dwarf_vmatoa ("x", arange
.ar_length
));
6813 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6814 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6816 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6817 && num_debug_info_entries
> 0
6818 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6819 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6820 (unsigned long) arange
.ar_info_offset
, section
->name
);
6822 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6823 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6825 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6827 /* PR 19872: A version number of 0 probably means that there is
6828 padding at the end of the .debug_aranges section. Gold puts
6829 it there when performing an incremental link, for example.
6830 So do not generate a warning in this case. */
6831 if (arange
.ar_version
)
6832 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6836 printf (_(" Length: %ld\n"),
6837 (long) arange
.ar_length
);
6838 printf (_(" Version: %d\n"), arange
.ar_version
);
6839 printf (_(" Offset into .debug_info: 0x%lx\n"),
6840 (unsigned long) arange
.ar_info_offset
);
6841 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6842 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6844 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6846 /* PR 17512: file: 001-108546-0.001:0.1. */
6847 if (address_size
== 0 || address_size
> 8)
6849 error (_("Invalid address size in %s section!\n"),
6854 /* The DWARF spec does not require that the address size be a power
6855 of two, but we do. This will have to change if we ever encounter
6856 an uneven architecture. */
6857 if ((address_size
& (address_size
- 1)) != 0)
6859 warn (_("Pointer size + Segment size is not a power of two.\n"));
6863 if (address_size
> 4)
6864 printf (_("\n Address Length\n"));
6866 printf (_("\n Address Length\n"));
6868 addr_ranges
= hdrptr
;
6870 /* Must pad to an alignment boundary that is twice the address size. */
6871 excess
= (hdrptr
- start
) % (2 * address_size
);
6873 addr_ranges
+= (2 * address_size
) - excess
;
6875 start
+= arange
.ar_length
+ initial_length_size
;
6877 while (addr_ranges
+ 2 * address_size
<= start
)
6879 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6880 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6883 print_dwarf_vma (address
, address_size
);
6884 print_dwarf_vma (length
, address_size
);
6894 /* Comparison function for qsort. */
6896 comp_addr_base (const void * v0
, const void * v1
)
6898 debug_info
*info0
= *(debug_info
**) v0
;
6899 debug_info
*info1
= *(debug_info
**) v1
;
6900 return info0
->addr_base
- info1
->addr_base
;
6903 /* Display the debug_addr section. */
6905 display_debug_addr (struct dwarf_section
*section
,
6908 debug_info
**debug_addr_info
;
6909 unsigned char *entry
;
6914 if (section
->size
== 0)
6916 printf (_("\nThe %s section is empty.\n"), section
->name
);
6920 if (load_debug_info (file
) == 0)
6922 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6927 introduce (section
, FALSE
);
6929 /* PR 17531: file: cf38d01b.
6930 We use xcalloc because a corrupt file may not have initialised all of the
6931 fields in the debug_info structure, which means that the sort below might
6932 try to move uninitialised data. */
6933 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6934 sizeof (debug_info
*));
6937 for (i
= 0; i
< num_debug_info_entries
; i
++)
6938 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6940 /* PR 17531: file: cf38d01b. */
6941 if (debug_information
[i
].addr_base
>= section
->size
)
6942 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6943 (unsigned long) debug_information
[i
].addr_base
, i
);
6945 debug_addr_info
[count
++] = debug_information
+ i
;
6948 /* Add a sentinel to make iteration convenient. */
6949 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6950 debug_addr_info
[count
]->addr_base
= section
->size
;
6951 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6953 for (i
= 0; i
< count
; i
++)
6956 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6958 printf (_(" For compilation unit at offset 0x%s:\n"),
6959 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6961 printf (_("\tIndex\tAddress\n"));
6962 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6963 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6967 dwarf_vma base
= byte_get (entry
, address_size
);
6968 printf (_("\t%d:\t"), idx
);
6969 print_dwarf_vma (base
, address_size
);
6971 entry
+= address_size
;
6977 free (debug_addr_info
);
6981 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6984 display_debug_str_offsets (struct dwarf_section
*section
,
6985 void *file ATTRIBUTE_UNUSED
)
6987 if (section
->size
== 0)
6989 printf (_("\nThe %s section is empty.\n"), section
->name
);
6992 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6993 what the offset size is for this section. */
6997 /* Each debug_information[x].range_lists[y] gets this representation for
6998 sorting purposes. */
7002 /* The debug_information[x].range_lists[y] value. */
7003 dwarf_vma ranges_offset
;
7005 /* Original debug_information to find parameters of the data. */
7006 debug_info
*debug_info_p
;
7009 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7012 range_entry_compar (const void *ap
, const void *bp
)
7014 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7015 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7016 const dwarf_vma a
= a_re
->ranges_offset
;
7017 const dwarf_vma b
= b_re
->ranges_offset
;
7019 return (a
> b
) - (b
> a
);
7023 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
7024 unsigned int pointer_size
, unsigned long offset
,
7025 unsigned long base_address
)
7027 while (start
< finish
)
7032 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7033 if (start
>= finish
)
7035 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7038 printf (" %8.8lx ", offset
);
7040 if (begin
== 0 && end
== 0)
7042 printf (_("<End of list>\n"));
7046 /* Check base address specifiers. */
7047 if (is_max_address (begin
, pointer_size
)
7048 && !is_max_address (end
, pointer_size
))
7051 print_dwarf_vma (begin
, pointer_size
);
7052 print_dwarf_vma (end
, pointer_size
);
7053 printf ("(base address)\n");
7057 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7058 print_dwarf_vma (end
+ base_address
, pointer_size
);
7061 fputs (_("(start == end)"), stdout
);
7062 else if (begin
> end
)
7063 fputs (_("(start > end)"), stdout
);
7070 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7071 unsigned int pointer_size
, unsigned long offset
,
7072 unsigned long base_address
)
7074 unsigned char *next
= start
;
7078 unsigned long off
= offset
+ (start
- next
);
7079 enum dwarf_range_list_entry rlet
;
7080 /* Initialize it due to a false compiler warning. */
7081 dwarf_vma begin
= -1, length
, end
= -1;
7082 unsigned int bytes_read
;
7084 if (start
+ 1 > finish
)
7086 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7091 printf (" %8.8lx ", off
);
7093 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7097 case DW_RLE_end_of_list
:
7098 printf (_("<End of list>\n"));
7100 case DW_RLE_base_address
:
7101 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7102 print_dwarf_vma (base_address
, pointer_size
);
7103 printf (_("(base address)\n"));
7105 case DW_RLE_start_length
:
7106 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7107 length
= read_uleb128 (start
, &bytes_read
, finish
);
7108 start
+= bytes_read
;
7109 end
= begin
+ length
;
7111 case DW_RLE_offset_pair
:
7112 begin
= read_uleb128 (start
, &bytes_read
, finish
);
7113 start
+= bytes_read
;
7114 end
= read_uleb128 (start
, &bytes_read
, finish
);
7115 start
+= bytes_read
;
7117 case DW_RLE_start_end
:
7118 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7119 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7122 error (_("Invalid range list entry type %d\n"), rlet
);
7123 rlet
= DW_RLE_end_of_list
;
7126 if (rlet
== DW_RLE_end_of_list
)
7128 if (rlet
== DW_RLE_base_address
)
7131 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7132 print_dwarf_vma (end
+ base_address
, pointer_size
);
7135 fputs (_("(start == end)"), stdout
);
7136 else if (begin
> end
)
7137 fputs (_("(start > end)"), stdout
);
7144 display_debug_ranges (struct dwarf_section
*section
,
7145 void *file ATTRIBUTE_UNUSED
)
7147 unsigned char *start
= section
->start
;
7148 unsigned char *last_start
= start
;
7149 unsigned long bytes
= section
->size
;
7150 unsigned char *section_begin
= start
;
7151 unsigned char *finish
= start
+ bytes
;
7152 unsigned int num_range_list
, i
;
7153 struct range_entry
*range_entries
, *range_entry_fill
;
7154 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7155 /* Initialize it due to a false compiler warning. */
7156 unsigned char address_size
= 0;
7160 printf (_("\nThe %s section is empty.\n"), section
->name
);
7166 dwarf_vma initial_length
;
7167 unsigned int initial_length_size
;
7168 unsigned char segment_selector_size
;
7169 unsigned int offset_size
, offset_entry_count
;
7170 unsigned short version
;
7172 /* Get and check the length of the block. */
7173 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7175 if (initial_length
== 0xffffffff)
7177 /* This section is 64-bit DWARF 3. */
7178 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7180 initial_length_size
= 12;
7185 initial_length_size
= 4;
7188 if (initial_length
+ initial_length_size
> section
->size
)
7190 /* If the length field has a relocation against it, then we should
7191 not complain if it is inaccurate (and probably negative).
7192 It is copied from .debug_line handling code. */
7193 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7195 initial_length
= (finish
- start
) - initial_length_size
;
7199 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7200 (long) initial_length
);
7205 /* Get and check the version number. */
7206 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7210 warn (_("Only DWARF version 5 debug_rnglists info "
7211 "is currently supported.\n"));
7215 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7217 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7218 if (segment_selector_size
!= 0)
7220 warn (_("The %s section contains "
7221 "unsupported segment selector size: %d.\n"),
7222 section
->name
, segment_selector_size
);
7226 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7227 if (offset_entry_count
!= 0)
7229 warn (_("The %s section contains "
7230 "unsupported offset entry count: %u.\n"),
7231 section
->name
, offset_entry_count
);
7236 if (load_debug_info (file
) == 0)
7238 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7244 for (i
= 0; i
< num_debug_info_entries
; i
++)
7245 num_range_list
+= debug_information
[i
].num_range_lists
;
7247 if (num_range_list
== 0)
7249 /* This can happen when the file was compiled with -gsplit-debug
7250 which removes references to range lists from the primary .o file. */
7251 printf (_("No range lists in .debug_info section.\n"));
7255 range_entries
= (struct range_entry
*)
7256 xmalloc (sizeof (*range_entries
) * num_range_list
);
7257 range_entry_fill
= range_entries
;
7259 for (i
= 0; i
< num_debug_info_entries
; i
++)
7261 debug_info
*debug_info_p
= &debug_information
[i
];
7264 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7266 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7267 range_entry_fill
->debug_info_p
= debug_info_p
;
7272 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7273 range_entry_compar
);
7275 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7276 warn (_("Range lists in %s section start at 0x%lx\n"),
7277 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7279 introduce (section
, FALSE
);
7281 printf (_(" Offset Begin End\n"));
7283 for (i
= 0; i
< num_range_list
; i
++)
7285 struct range_entry
*range_entry
= &range_entries
[i
];
7286 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7287 unsigned int pointer_size
;
7289 unsigned char *next
;
7290 dwarf_vma base_address
;
7292 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7293 offset
= range_entry
->ranges_offset
;
7294 next
= section_begin
+ offset
;
7295 base_address
= debug_info_p
->base_address
;
7297 /* PR 17512: file: 001-101485-0.001:0.1. */
7298 if (pointer_size
< 2 || pointer_size
> 8)
7300 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7301 pointer_size
, (unsigned long) offset
);
7305 if (next
< section_begin
|| next
>= finish
)
7307 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7308 (unsigned long) offset
, i
);
7312 if (dwarf_check
!= 0 && i
> 0)
7315 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7316 (unsigned long) (start
- section_begin
),
7317 (unsigned long) (next
- section_begin
), section
->name
);
7318 else if (start
> next
)
7320 if (next
== last_start
)
7322 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7323 (unsigned long) (start
- section_begin
),
7324 (unsigned long) (next
- section_begin
), section
->name
);
7331 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7332 (start
, finish
, pointer_size
, offset
, base_address
);
7336 free (range_entries
);
7341 typedef struct Frame_Chunk
7343 struct Frame_Chunk
*next
;
7344 unsigned char *chunk_start
;
7346 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7347 short int *col_type
;
7350 unsigned int code_factor
;
7354 unsigned int cfa_reg
;
7355 dwarf_vma cfa_offset
;
7357 unsigned char fde_encoding
;
7358 unsigned char cfa_exp
;
7359 unsigned char ptr_size
;
7360 unsigned char segment_size
;
7364 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7365 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7366 static const char *const *dwarf_regnames
;
7367 static unsigned int dwarf_regnames_count
;
7370 /* A marker for a col_type that means this column was never referenced
7371 in the frame info. */
7372 #define DW_CFA_unreferenced (-1)
7374 /* Return 0 if no more space is needed, 1 if more space is needed,
7375 -1 for invalid reg. */
7378 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7380 unsigned int prev
= fc
->ncols
;
7382 if (reg
< (unsigned int) fc
->ncols
)
7385 if (dwarf_regnames_count
> 0
7386 && reg
> dwarf_regnames_count
)
7389 fc
->ncols
= reg
+ 1;
7390 /* PR 17512: file: 10450-2643-0.004.
7391 If reg == -1 then this can happen... */
7395 /* PR 17512: file: 2844a11d. */
7396 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7398 error (_("Unfeasibly large register number: %u\n"), reg
);
7400 /* FIXME: 1024 is an arbitrary limit. Increase it if
7401 we ever encounter a valid binary that exceeds it. */
7405 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7406 sizeof (short int));
7407 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7408 /* PR 17512: file:002-10025-0.005. */
7409 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7411 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7417 while (prev
< fc
->ncols
)
7419 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7420 fc
->col_offset
[prev
] = 0;
7426 static const char *const dwarf_regnames_i386
[] =
7428 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7429 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7430 "eip", "eflags", NULL
, /* 8 - 10 */
7431 "st0", "st1", "st2", "st3", /* 11 - 14 */
7432 "st4", "st5", "st6", "st7", /* 15 - 18 */
7433 NULL
, NULL
, /* 19 - 20 */
7434 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7435 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7436 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7437 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7438 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7439 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7440 "tr", "ldtr", /* 48 - 49 */
7441 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7442 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7443 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7444 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7445 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7446 NULL
, NULL
, NULL
, /* 90 - 92 */
7447 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7450 static const char *const dwarf_regnames_iamcu
[] =
7452 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7453 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7454 "eip", "eflags", NULL
, /* 8 - 10 */
7455 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7456 NULL
, NULL
, /* 19 - 20 */
7457 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7458 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7459 NULL
, NULL
, NULL
, /* 37 - 39 */
7460 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7461 "tr", "ldtr", /* 48 - 49 */
7462 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7463 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7464 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7465 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7466 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7467 NULL
, NULL
, NULL
, /* 90 - 92 */
7468 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7472 init_dwarf_regnames_i386 (void)
7474 dwarf_regnames
= dwarf_regnames_i386
;
7475 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7476 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7480 init_dwarf_regnames_iamcu (void)
7482 dwarf_regnames
= dwarf_regnames_iamcu
;
7483 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7484 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7487 static const char *const dwarf_regnames_x86_64
[] =
7489 "rax", "rdx", "rcx", "rbx",
7490 "rsi", "rdi", "rbp", "rsp",
7491 "r8", "r9", "r10", "r11",
7492 "r12", "r13", "r14", "r15",
7494 "xmm0", "xmm1", "xmm2", "xmm3",
7495 "xmm4", "xmm5", "xmm6", "xmm7",
7496 "xmm8", "xmm9", "xmm10", "xmm11",
7497 "xmm12", "xmm13", "xmm14", "xmm15",
7498 "st0", "st1", "st2", "st3",
7499 "st4", "st5", "st6", "st7",
7500 "mm0", "mm1", "mm2", "mm3",
7501 "mm4", "mm5", "mm6", "mm7",
7503 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7504 "fs.base", "gs.base", NULL
, NULL
,
7506 "mxcsr", "fcw", "fsw",
7507 "xmm16", "xmm17", "xmm18", "xmm19",
7508 "xmm20", "xmm21", "xmm22", "xmm23",
7509 "xmm24", "xmm25", "xmm26", "xmm27",
7510 "xmm28", "xmm29", "xmm30", "xmm31",
7511 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7512 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7513 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7514 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7515 NULL
, NULL
, NULL
, /* 115 - 117 */
7516 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7520 init_dwarf_regnames_x86_64 (void)
7522 dwarf_regnames
= dwarf_regnames_x86_64
;
7523 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7524 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7527 static const char *const dwarf_regnames_aarch64
[] =
7529 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7530 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7531 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7532 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7533 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7534 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7535 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7536 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7537 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7538 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7539 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7540 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7541 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7542 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7543 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7544 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7548 init_dwarf_regnames_aarch64 (void)
7550 dwarf_regnames
= dwarf_regnames_aarch64
;
7551 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7552 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7555 static const char *const dwarf_regnames_s390
[] =
7557 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7558 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7559 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7560 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7561 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7562 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7563 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7564 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7565 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7568 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7569 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7573 init_dwarf_regnames_s390 (void)
7575 dwarf_regnames
= dwarf_regnames_s390
;
7576 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7577 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7580 static const char *const dwarf_regnames_riscv
[] =
7582 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7583 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7584 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7585 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7586 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7587 "fs0", "fs1", /* 40 - 41 */
7588 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7589 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7590 "fs10", "fs11", /* 58 - 59 */
7591 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7594 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
7595 the large number of CSRs. */
7598 regname_internal_riscv (unsigned int regno
)
7600 const char *name
= NULL
;
7602 /* Lookup in the table first, this covers GPR and FPR. */
7603 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
7604 name
= dwarf_regnames_riscv
[regno
];
7605 else if (regno
>= 4096 && regno
<= 8191)
7607 /* This might be a CSR, these live in a sparse number space from 4096
7608 to 8191 These numbers are defined in the RISC-V ELF ABI
7612 #define DECLARE_CSR(NAME,VALUE) case VALUE + 4096: name = #NAME; break;
7613 #include "opcode/riscv-opc.h"
7618 static char csr_name
[10];
7619 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7630 init_dwarf_regnames_riscv (void)
7632 dwarf_regnames
= NULL
;
7633 dwarf_regnames_count
= 8192;
7634 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7638 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7640 dwarf_regnames_lookup_func
= NULL
;
7645 init_dwarf_regnames_i386 ();
7649 init_dwarf_regnames_iamcu ();
7655 init_dwarf_regnames_x86_64 ();
7659 init_dwarf_regnames_aarch64 ();
7663 init_dwarf_regnames_s390 ();
7667 init_dwarf_regnames_riscv ();
7675 /* Initialize the DWARF register name lookup state based on the
7676 architecture and specific machine type of a BFD. */
7679 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7682 dwarf_regnames_lookup_func
= NULL
;
7689 case bfd_mach_x86_64
:
7690 case bfd_mach_x86_64_intel_syntax
:
7691 case bfd_mach_x86_64_nacl
:
7692 case bfd_mach_x64_32
:
7693 case bfd_mach_x64_32_intel_syntax
:
7694 case bfd_mach_x64_32_nacl
:
7695 init_dwarf_regnames_x86_64 ();
7699 init_dwarf_regnames_i386 ();
7704 case bfd_arch_iamcu
:
7705 init_dwarf_regnames_iamcu ();
7708 case bfd_arch_aarch64
:
7709 init_dwarf_regnames_aarch64();
7713 init_dwarf_regnames_s390 ();
7716 case bfd_arch_riscv
:
7717 init_dwarf_regnames_riscv ();
7726 regname_internal_by_table_only (unsigned int regno
)
7728 if (dwarf_regnames
!= NULL
7729 && regno
< dwarf_regnames_count
7730 && dwarf_regnames
[regno
] != NULL
)
7731 return dwarf_regnames
[regno
];
7737 regname (unsigned int regno
, int name_only_p
)
7739 static char reg
[64];
7741 const char *name
= NULL
;
7743 if (dwarf_regnames_lookup_func
!= NULL
)
7744 name
= dwarf_regnames_lookup_func (regno
);
7750 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7753 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7758 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7763 if (*max_regs
!= fc
->ncols
)
7764 *max_regs
= fc
->ncols
;
7766 if (*need_col_headers
)
7768 static const char *sloc
= " LOC";
7770 *need_col_headers
= 0;
7772 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7774 for (r
= 0; r
< *max_regs
; r
++)
7775 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7780 printf ("%-5s ", regname (r
, 1));
7786 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7788 strcpy (tmp
, "exp");
7790 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7791 printf ("%-8s ", tmp
);
7793 for (r
= 0; r
< fc
->ncols
; r
++)
7795 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7797 switch (fc
->col_type
[r
])
7799 case DW_CFA_undefined
:
7802 case DW_CFA_same_value
:
7806 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7808 case DW_CFA_val_offset
:
7809 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7811 case DW_CFA_register
:
7812 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7814 case DW_CFA_expression
:
7815 strcpy (tmp
, "exp");
7817 case DW_CFA_val_expression
:
7818 strcpy (tmp
, "vexp");
7821 strcpy (tmp
, "n/a");
7824 printf ("%-5s ", tmp
);
7830 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7832 static unsigned char *
7833 read_cie (unsigned char *start
, unsigned char *end
,
7834 Frame_Chunk
**p_cie
, int *p_version
,
7835 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7839 unsigned int length_return
;
7840 unsigned char *augmentation_data
= NULL
;
7841 bfd_size_type augmentation_data_len
= 0;
7844 /* PR 17512: file: 001-228113-0.004. */
7848 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7849 memset (fc
, 0, sizeof (Frame_Chunk
));
7851 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7852 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7856 fc
->augmentation
= (char *) start
;
7857 /* PR 17512: file: 001-228113-0.004.
7858 Skip past augmentation name, but avoid running off the end of the data. */
7860 if (* start
++ == '\0')
7864 warn (_("No terminator for augmentation name\n"));
7868 if (strcmp (fc
->augmentation
, "eh") == 0)
7869 start
+= eh_addr_size
;
7873 GET (fc
->ptr_size
, 1);
7874 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7876 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7880 GET (fc
->segment_size
, 1);
7881 /* PR 17512: file: e99d2804. */
7882 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7884 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7888 eh_addr_size
= fc
->ptr_size
;
7892 fc
->ptr_size
= eh_addr_size
;
7893 fc
->segment_size
= 0;
7896 READ_ULEB (fc
->code_factor
);
7897 READ_SLEB (fc
->data_factor
);
7908 if (fc
->augmentation
[0] == 'z')
7910 READ_ULEB (augmentation_data_len
);
7911 augmentation_data
= start
;
7912 /* PR 17512: file: 11042-2589-0.004. */
7913 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7915 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7916 dwarf_vmatoa ("x", augmentation_data_len
),
7917 (unsigned long) (end
- start
));
7920 start
+= augmentation_data_len
;
7923 if (augmentation_data_len
)
7927 unsigned char *qend
;
7929 p
= (unsigned char *) fc
->augmentation
+ 1;
7930 q
= augmentation_data
;
7931 qend
= q
+ augmentation_data_len
;
7933 while (p
< end
&& q
< qend
)
7938 q
+= 1 + size_of_encoded_value (*q
);
7940 fc
->fde_encoding
= *q
++;
7949 /* Note - it is OK if this loop terminates with q < qend.
7950 Padding may have been inserted to align the end of the CIE. */
7955 *p_version
= version
;
7958 *p_aug_len
= augmentation_data_len
;
7959 *p_aug
= augmentation_data
;
7964 free (fc
->col_offset
);
7965 free (fc
->col_type
);
7970 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7971 If do_wide is not enabled, then formats the output to fit into 80 columns.
7972 PRINTED contains the number of characters already written to the current
7976 display_data (bfd_size_type printed
,
7977 const unsigned char * data
,
7978 const bfd_size_type len
)
7980 if (do_wide
|| len
< ((80 - printed
) / 3))
7981 for (printed
= 0; printed
< len
; ++printed
)
7982 printf (" %02x", data
[printed
]);
7985 for (printed
= 0; printed
< len
; ++printed
)
7987 if (printed
% (80 / 3) == 0)
7989 printf (" %02x", data
[printed
]);
7994 /* Prints out the contents on the augmentation data array.
7995 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7998 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
8002 i
= printf (_(" Augmentation data: "));
8003 display_data (i
, data
, len
);
8007 display_debug_frames (struct dwarf_section
*section
,
8008 void *file ATTRIBUTE_UNUSED
)
8010 unsigned char *start
= section
->start
;
8011 unsigned char *end
= start
+ section
->size
;
8012 unsigned char *section_start
= start
;
8013 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8014 Frame_Chunk
*remembered_state
= NULL
;
8016 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8017 unsigned int length_return
;
8018 unsigned int max_regs
= 0;
8019 const char *bad_reg
= _("bad register: ");
8020 unsigned int saved_eh_addr_size
= eh_addr_size
;
8022 introduce (section
, FALSE
);
8026 unsigned char *saved_start
;
8027 unsigned char *block_end
;
8032 int need_col_headers
= 1;
8033 unsigned char *augmentation_data
= NULL
;
8034 bfd_size_type augmentation_data_len
= 0;
8035 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8036 unsigned int offset_size
;
8037 unsigned int initial_length_size
;
8038 bfd_boolean all_nops
;
8040 saved_start
= start
;
8042 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8046 printf ("\n%08lx ZERO terminator\n\n",
8047 (unsigned long)(saved_start
- section_start
));
8048 /* Skip any zero terminators that directly follow.
8049 A corrupt section size could have loaded a whole
8050 slew of zero filled memory bytes. eg
8051 PR 17512: file: 070-19381-0.004. */
8052 while (start
< end
&& * start
== 0)
8057 if (length
== 0xffffffff)
8059 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8061 initial_length_size
= 12;
8066 initial_length_size
= 4;
8069 block_end
= saved_start
+ length
+ initial_length_size
;
8070 if (block_end
> end
|| block_end
< start
)
8072 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8073 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8074 (unsigned long) (saved_start
- section_start
));
8078 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
8080 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8081 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8086 start
= read_cie (start
, end
, &cie
, &version
,
8087 &augmentation_data_len
, &augmentation_data
);
8088 /* PR 17512: file: 027-135133-0.005. */
8095 fc
->chunk_start
= saved_start
;
8096 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8099 if (frame_need_space (fc
, mreg
) < 0)
8101 if (fc
->fde_encoding
)
8102 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8104 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8105 print_dwarf_vma (length
, fc
->ptr_size
);
8106 print_dwarf_vma (cie_id
, offset_size
);
8108 if (do_debug_frames_interp
)
8110 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8111 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8116 printf (" Version: %d\n", version
);
8117 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8120 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8121 printf (" Segment Size: %u\n", fc
->segment_size
);
8123 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8124 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8125 printf (" Return address column: %d\n", fc
->ra
);
8127 if (augmentation_data_len
)
8128 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8135 unsigned char *look_for
;
8136 static Frame_Chunk fde_fc
;
8137 unsigned long segment_selector
;
8141 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8142 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
8145 look_for
= section_start
+ cie_id
;
8147 if (look_for
<= saved_start
)
8149 for (cie
= chunks
; cie
; cie
= cie
->next
)
8150 if (cie
->chunk_start
== look_for
)
8155 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8156 if (cie
->chunk_start
== look_for
)
8160 unsigned int off_size
;
8161 unsigned char *cie_scan
;
8163 cie_scan
= look_for
;
8165 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8166 if (length
== 0xffffffff)
8168 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8175 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
8178 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8179 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8184 read_cie (cie_scan
, end
, &cie
, &version
,
8185 &augmentation_data_len
, &augmentation_data
);
8186 /* PR 17512: file: 3450-2098-0.004. */
8189 warn (_("Failed to read CIE information\n"));
8192 cie
->next
= forward_refs
;
8194 cie
->chunk_start
= look_for
;
8195 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8198 if (frame_need_space (cie
, mreg
) < 0)
8200 warn (_("Invalid max register\n"));
8203 if (cie
->fde_encoding
)
8205 = size_of_encoded_value (cie
->fde_encoding
);
8212 memset (fc
, 0, sizeof (Frame_Chunk
));
8216 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8217 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8218 (unsigned long) (saved_start
- section_start
));
8220 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8221 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8222 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8224 warn (_("Invalid max register\n"));
8228 fc
->augmentation
= "";
8229 fc
->fde_encoding
= 0;
8230 fc
->ptr_size
= eh_addr_size
;
8231 fc
->segment_size
= 0;
8235 fc
->ncols
= cie
->ncols
;
8236 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8237 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8238 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8239 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8240 fc
->augmentation
= cie
->augmentation
;
8241 fc
->ptr_size
= cie
->ptr_size
;
8242 eh_addr_size
= cie
->ptr_size
;
8243 fc
->segment_size
= cie
->segment_size
;
8244 fc
->code_factor
= cie
->code_factor
;
8245 fc
->data_factor
= cie
->data_factor
;
8246 fc
->cfa_reg
= cie
->cfa_reg
;
8247 fc
->cfa_offset
= cie
->cfa_offset
;
8249 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8251 warn (_("Invalid max register\n"));
8254 fc
->fde_encoding
= cie
->fde_encoding
;
8257 if (fc
->fde_encoding
)
8258 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8260 segment_selector
= 0;
8261 if (fc
->segment_size
)
8263 if (fc
->segment_size
> sizeof (segment_selector
))
8265 /* PR 17512: file: 9e196b3e. */
8266 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8267 fc
->segment_size
= 4;
8269 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8272 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8274 /* FIXME: It appears that sometimes the final pc_range value is
8275 encoded in less than encoded_ptr_size bytes. See the x86_64
8276 run of the "objcopy on compressed debug sections" test for an
8278 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8280 if (cie
->augmentation
[0] == 'z')
8282 READ_ULEB (augmentation_data_len
);
8283 augmentation_data
= start
;
8284 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8285 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8287 warn (_("Augmentation data too long: 0x%s, "
8288 "expected at most %#lx\n"),
8289 dwarf_vmatoa ("x", augmentation_data_len
),
8290 (unsigned long) (end
- start
));
8292 augmentation_data
= NULL
;
8293 augmentation_data_len
= 0;
8295 start
+= augmentation_data_len
;
8298 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8299 (unsigned long)(saved_start
- section_start
),
8300 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8301 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8302 (unsigned long)(cie
->chunk_start
- section_start
));
8304 if (fc
->segment_size
)
8305 printf ("%04lx:", segment_selector
);
8308 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8309 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8311 if (! do_debug_frames_interp
&& augmentation_data_len
)
8313 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8318 /* At this point, fc is the current chunk, cie (if any) is set, and
8319 we're about to interpret instructions for the chunk. */
8320 /* ??? At present we need to do this always, since this sizes the
8321 fc->col_type and fc->col_offset arrays, which we write into always.
8322 We should probably split the interpreted and non-interpreted bits
8323 into two different routines, since there's so much that doesn't
8324 really overlap between them. */
8325 if (1 || do_debug_frames_interp
)
8327 /* Start by making a pass over the chunk, allocating storage
8328 and taking note of what registers are used. */
8329 unsigned char *tmp
= start
;
8331 while (start
< block_end
)
8333 unsigned int reg
, op
, opa
;
8335 unsigned char * new_start
;
8342 /* Warning: if you add any more cases to this switch, be
8343 sure to add them to the corresponding switch below. */
8346 case DW_CFA_advance_loc
:
8350 if (frame_need_space (fc
, opa
) >= 0)
8351 fc
->col_type
[opa
] = DW_CFA_undefined
;
8353 case DW_CFA_restore
:
8354 if (frame_need_space (fc
, opa
) >= 0)
8355 fc
->col_type
[opa
] = DW_CFA_undefined
;
8357 case DW_CFA_set_loc
:
8358 start
+= encoded_ptr_size
;
8360 case DW_CFA_advance_loc1
:
8363 case DW_CFA_advance_loc2
:
8366 case DW_CFA_advance_loc4
:
8369 case DW_CFA_offset_extended
:
8370 case DW_CFA_val_offset
:
8373 if (frame_need_space (fc
, reg
) >= 0)
8374 fc
->col_type
[reg
] = DW_CFA_undefined
;
8376 case DW_CFA_restore_extended
:
8378 if (frame_need_space (fc
, reg
) >= 0)
8379 fc
->col_type
[reg
] = DW_CFA_undefined
;
8381 case DW_CFA_undefined
:
8383 if (frame_need_space (fc
, reg
) >= 0)
8384 fc
->col_type
[reg
] = DW_CFA_undefined
;
8386 case DW_CFA_same_value
:
8388 if (frame_need_space (fc
, reg
) >= 0)
8389 fc
->col_type
[reg
] = DW_CFA_undefined
;
8391 case DW_CFA_register
:
8394 if (frame_need_space (fc
, reg
) >= 0)
8395 fc
->col_type
[reg
] = DW_CFA_undefined
;
8397 case DW_CFA_def_cfa
:
8401 case DW_CFA_def_cfa_register
:
8404 case DW_CFA_def_cfa_offset
:
8407 case DW_CFA_def_cfa_expression
:
8409 new_start
= start
+ temp
;
8410 if (new_start
< start
)
8412 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8418 case DW_CFA_expression
:
8419 case DW_CFA_val_expression
:
8422 new_start
= start
+ temp
;
8423 if (new_start
< start
)
8425 /* PR 17512: file:306-192417-0.005. */
8426 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8431 if (frame_need_space (fc
, reg
) >= 0)
8432 fc
->col_type
[reg
] = DW_CFA_undefined
;
8434 case DW_CFA_offset_extended_sf
:
8435 case DW_CFA_val_offset_sf
:
8438 if (frame_need_space (fc
, reg
) >= 0)
8439 fc
->col_type
[reg
] = DW_CFA_undefined
;
8441 case DW_CFA_def_cfa_sf
:
8445 case DW_CFA_def_cfa_offset_sf
:
8448 case DW_CFA_MIPS_advance_loc8
:
8451 case DW_CFA_GNU_args_size
:
8454 case DW_CFA_GNU_negative_offset_extended
:
8457 if (frame_need_space (fc
, reg
) >= 0)
8458 fc
->col_type
[reg
] = DW_CFA_undefined
;
8469 /* Now we know what registers are used, make a second pass over
8470 the chunk, this time actually printing out the info. */
8472 while (start
< block_end
)
8474 unsigned char * tmp
;
8476 unsigned long ul
, roffs
;
8477 /* Note: It is tempting to use an unsigned long for 'reg' but there
8478 are various functions, notably frame_space_needed() that assume that
8479 reg is an unsigned int. */
8484 const char *reg_prefix
= "";
8491 /* Make a note if something other than DW_CFA_nop happens. */
8492 if (op
!= DW_CFA_nop
)
8495 /* Warning: if you add any more cases to this switch, be
8496 sure to add them to the corresponding switch above. */
8499 case DW_CFA_advance_loc
:
8500 if (do_debug_frames_interp
)
8501 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8503 printf (" DW_CFA_advance_loc: %d to %s\n",
8504 opa
* fc
->code_factor
,
8505 dwarf_vmatoa_1 (NULL
,
8506 fc
->pc_begin
+ opa
* fc
->code_factor
,
8508 fc
->pc_begin
+= opa
* fc
->code_factor
;
8513 if (opa
>= (unsigned int) fc
->ncols
)
8514 reg_prefix
= bad_reg
;
8515 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8516 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8517 reg_prefix
, regname (opa
, 0),
8518 roffs
* fc
->data_factor
);
8519 if (*reg_prefix
== '\0')
8521 fc
->col_type
[opa
] = DW_CFA_offset
;
8522 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8526 case DW_CFA_restore
:
8527 if (opa
>= (unsigned int) fc
->ncols
)
8528 reg_prefix
= bad_reg
;
8529 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8530 printf (" DW_CFA_restore: %s%s\n",
8531 reg_prefix
, regname (opa
, 0));
8532 if (*reg_prefix
!= '\0')
8535 if (opa
>= (unsigned int) cie
->ncols
8536 || (do_debug_frames_interp
8537 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8539 fc
->col_type
[opa
] = DW_CFA_undefined
;
8540 fc
->col_offset
[opa
] = 0;
8544 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8545 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8549 case DW_CFA_set_loc
:
8550 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8551 if (do_debug_frames_interp
)
8552 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8554 printf (" DW_CFA_set_loc: %s\n",
8555 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8559 case DW_CFA_advance_loc1
:
8560 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8561 if (do_debug_frames_interp
)
8562 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8564 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8565 (unsigned long) (ofs
* fc
->code_factor
),
8566 dwarf_vmatoa_1 (NULL
,
8567 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8569 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8572 case DW_CFA_advance_loc2
:
8573 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8574 if (do_debug_frames_interp
)
8575 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8577 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8578 (unsigned long) (ofs
* fc
->code_factor
),
8579 dwarf_vmatoa_1 (NULL
,
8580 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8582 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8585 case DW_CFA_advance_loc4
:
8586 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8587 if (do_debug_frames_interp
)
8588 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8590 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8591 (unsigned long) (ofs
* fc
->code_factor
),
8592 dwarf_vmatoa_1 (NULL
,
8593 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8595 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8598 case DW_CFA_offset_extended
:
8601 if (reg
>= (unsigned int) fc
->ncols
)
8602 reg_prefix
= bad_reg
;
8603 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8604 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8605 reg_prefix
, regname (reg
, 0),
8606 roffs
* fc
->data_factor
);
8607 if (*reg_prefix
== '\0')
8609 fc
->col_type
[reg
] = DW_CFA_offset
;
8610 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8614 case DW_CFA_val_offset
:
8617 if (reg
>= (unsigned int) fc
->ncols
)
8618 reg_prefix
= bad_reg
;
8619 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8620 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8621 reg_prefix
, regname (reg
, 0),
8622 roffs
* fc
->data_factor
);
8623 if (*reg_prefix
== '\0')
8625 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8626 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8630 case DW_CFA_restore_extended
:
8632 if (reg
>= (unsigned int) fc
->ncols
)
8633 reg_prefix
= bad_reg
;
8634 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8635 printf (" DW_CFA_restore_extended: %s%s\n",
8636 reg_prefix
, regname (reg
, 0));
8637 if (*reg_prefix
!= '\0')
8640 if (reg
>= (unsigned int) cie
->ncols
)
8642 fc
->col_type
[reg
] = DW_CFA_undefined
;
8643 fc
->col_offset
[reg
] = 0;
8647 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8648 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8652 case DW_CFA_undefined
:
8654 if (reg
>= (unsigned int) fc
->ncols
)
8655 reg_prefix
= bad_reg
;
8656 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8657 printf (" DW_CFA_undefined: %s%s\n",
8658 reg_prefix
, regname (reg
, 0));
8659 if (*reg_prefix
== '\0')
8661 fc
->col_type
[reg
] = DW_CFA_undefined
;
8662 fc
->col_offset
[reg
] = 0;
8666 case DW_CFA_same_value
:
8668 if (reg
>= (unsigned int) fc
->ncols
)
8669 reg_prefix
= bad_reg
;
8670 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8671 printf (" DW_CFA_same_value: %s%s\n",
8672 reg_prefix
, regname (reg
, 0));
8673 if (*reg_prefix
== '\0')
8675 fc
->col_type
[reg
] = DW_CFA_same_value
;
8676 fc
->col_offset
[reg
] = 0;
8680 case DW_CFA_register
:
8683 if (reg
>= (unsigned int) fc
->ncols
)
8684 reg_prefix
= bad_reg
;
8685 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8687 printf (" DW_CFA_register: %s%s in ",
8688 reg_prefix
, regname (reg
, 0));
8689 puts (regname (roffs
, 0));
8691 if (*reg_prefix
== '\0')
8693 fc
->col_type
[reg
] = DW_CFA_register
;
8694 fc
->col_offset
[reg
] = roffs
;
8698 case DW_CFA_remember_state
:
8699 if (! do_debug_frames_interp
)
8700 printf (" DW_CFA_remember_state\n");
8701 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8702 rs
->cfa_offset
= fc
->cfa_offset
;
8703 rs
->cfa_reg
= fc
->cfa_reg
;
8705 rs
->cfa_exp
= fc
->cfa_exp
;
8706 rs
->ncols
= fc
->ncols
;
8707 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8708 sizeof (* rs
->col_type
));
8709 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8710 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8711 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8712 rs
->next
= remembered_state
;
8713 remembered_state
= rs
;
8716 case DW_CFA_restore_state
:
8717 if (! do_debug_frames_interp
)
8718 printf (" DW_CFA_restore_state\n");
8719 rs
= remembered_state
;
8722 remembered_state
= rs
->next
;
8723 fc
->cfa_offset
= rs
->cfa_offset
;
8724 fc
->cfa_reg
= rs
->cfa_reg
;
8726 fc
->cfa_exp
= rs
->cfa_exp
;
8727 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8729 warn (_("Invalid column number in saved frame state\n"));
8733 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8734 memcpy (fc
->col_offset
, rs
->col_offset
,
8735 rs
->ncols
* sizeof (* rs
->col_offset
));
8736 free (rs
->col_type
);
8737 free (rs
->col_offset
);
8740 else if (do_debug_frames_interp
)
8741 printf ("Mismatched DW_CFA_restore_state\n");
8744 case DW_CFA_def_cfa
:
8745 READ_ULEB (fc
->cfa_reg
);
8746 READ_ULEB (fc
->cfa_offset
);
8748 if (! do_debug_frames_interp
)
8749 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8750 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8753 case DW_CFA_def_cfa_register
:
8754 READ_ULEB (fc
->cfa_reg
);
8756 if (! do_debug_frames_interp
)
8757 printf (" DW_CFA_def_cfa_register: %s\n",
8758 regname (fc
->cfa_reg
, 0));
8761 case DW_CFA_def_cfa_offset
:
8762 READ_ULEB (fc
->cfa_offset
);
8763 if (! do_debug_frames_interp
)
8764 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8768 if (! do_debug_frames_interp
)
8769 printf (" DW_CFA_nop\n");
8772 case DW_CFA_def_cfa_expression
:
8774 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8776 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8779 if (! do_debug_frames_interp
)
8781 printf (" DW_CFA_def_cfa_expression (");
8782 decode_location_expression (start
, eh_addr_size
, 0, -1,
8790 case DW_CFA_expression
:
8793 if (reg
>= (unsigned int) fc
->ncols
)
8794 reg_prefix
= bad_reg
;
8795 /* PR 17512: file: 069-133014-0.006. */
8796 /* PR 17512: file: 98c02eb4. */
8798 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8800 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8803 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8805 printf (" DW_CFA_expression: %s%s (",
8806 reg_prefix
, regname (reg
, 0));
8807 decode_location_expression (start
, eh_addr_size
, 0, -1,
8811 if (*reg_prefix
== '\0')
8812 fc
->col_type
[reg
] = DW_CFA_expression
;
8816 case DW_CFA_val_expression
:
8819 if (reg
>= (unsigned int) fc
->ncols
)
8820 reg_prefix
= bad_reg
;
8822 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8824 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8827 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8829 printf (" DW_CFA_val_expression: %s%s (",
8830 reg_prefix
, regname (reg
, 0));
8831 decode_location_expression (start
, eh_addr_size
, 0, -1,
8835 if (*reg_prefix
== '\0')
8836 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8840 case DW_CFA_offset_extended_sf
:
8843 if (frame_need_space (fc
, reg
) < 0)
8844 reg_prefix
= bad_reg
;
8845 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8846 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8847 reg_prefix
, regname (reg
, 0),
8848 (long)(l
* fc
->data_factor
));
8849 if (*reg_prefix
== '\0')
8851 fc
->col_type
[reg
] = DW_CFA_offset
;
8852 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8856 case DW_CFA_val_offset_sf
:
8859 if (frame_need_space (fc
, reg
) < 0)
8860 reg_prefix
= bad_reg
;
8861 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8862 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8863 reg_prefix
, regname (reg
, 0),
8864 (long)(l
* fc
->data_factor
));
8865 if (*reg_prefix
== '\0')
8867 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8868 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8872 case DW_CFA_def_cfa_sf
:
8873 READ_ULEB (fc
->cfa_reg
);
8874 READ_ULEB (fc
->cfa_offset
);
8875 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8877 if (! do_debug_frames_interp
)
8878 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8879 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8882 case DW_CFA_def_cfa_offset_sf
:
8883 READ_ULEB (fc
->cfa_offset
);
8884 fc
->cfa_offset
*= fc
->data_factor
;
8885 if (! do_debug_frames_interp
)
8886 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8889 case DW_CFA_MIPS_advance_loc8
:
8890 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8891 if (do_debug_frames_interp
)
8892 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8894 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8895 (unsigned long) (ofs
* fc
->code_factor
),
8896 dwarf_vmatoa_1 (NULL
,
8897 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8899 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8902 case DW_CFA_GNU_window_save
:
8903 if (! do_debug_frames_interp
)
8904 printf (" DW_CFA_GNU_window_save\n");
8907 case DW_CFA_GNU_args_size
:
8909 if (! do_debug_frames_interp
)
8910 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8913 case DW_CFA_GNU_negative_offset_extended
:
8917 if (frame_need_space (fc
, reg
) < 0)
8918 reg_prefix
= bad_reg
;
8919 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8920 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8921 reg_prefix
, regname (reg
, 0),
8922 (long)(l
* fc
->data_factor
));
8923 if (*reg_prefix
== '\0')
8925 fc
->col_type
[reg
] = DW_CFA_offset
;
8926 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8931 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8932 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8934 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8939 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8940 if (do_debug_frames_interp
&& ! all_nops
)
8941 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8944 eh_addr_size
= saved_eh_addr_size
;
8949 while (remembered_state
!= NULL
)
8951 rs
= remembered_state
;
8952 remembered_state
= rs
->next
;
8953 free (rs
->col_type
);
8954 free (rs
->col_offset
);
8955 rs
->next
= NULL
; /* Paranoia. */
8959 while (chunks
!= NULL
)
8963 free (rs
->col_type
);
8964 free (rs
->col_offset
);
8965 rs
->next
= NULL
; /* Paranoia. */
8969 while (forward_refs
!= NULL
)
8972 forward_refs
= rs
->next
;
8973 free (rs
->col_type
);
8974 free (rs
->col_offset
);
8975 rs
->next
= NULL
; /* Paranoia. */
8985 display_debug_names (struct dwarf_section
*section
, void *file
)
8987 unsigned char *hdrptr
= section
->start
;
8988 dwarf_vma unit_length
;
8989 unsigned char *unit_start
;
8990 const unsigned char *const section_end
= section
->start
+ section
->size
;
8991 unsigned char *unit_end
;
8993 introduce (section
, FALSE
);
8995 load_debug_section_with_follow (str
, file
);
8997 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8999 unsigned int offset_size
;
9000 uint16_t dwarf_version
, padding
;
9001 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9002 uint32_t bucket_count
, name_count
, abbrev_table_size
;
9003 uint32_t augmentation_string_size
;
9005 unsigned long sec_off
;
9006 bfd_boolean augmentation_printable
;
9007 const char *augmentation_string
;
9009 unit_start
= hdrptr
;
9011 /* Get and check the length of the block. */
9012 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9014 if (unit_length
== 0xffffffff)
9016 /* This section is 64-bit DWARF. */
9017 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9022 unit_end
= hdrptr
+ unit_length
;
9024 sec_off
= hdrptr
- section
->start
;
9025 if (sec_off
+ unit_length
< sec_off
9026 || sec_off
+ unit_length
> section
->size
)
9028 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9030 (unsigned long) (unit_start
- section
->start
),
9031 dwarf_vmatoa ("x", unit_length
));
9035 /* Get and check the version number. */
9036 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9037 printf (_("Version %ld\n"), (long) dwarf_version
);
9039 /* Prior versions did not exist, and future versions may not be
9040 backwards compatible. */
9041 if (dwarf_version
!= 5)
9043 warn (_("Only DWARF version 5 .debug_names "
9044 "is currently supported.\n"));
9048 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9050 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9053 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9054 if (comp_unit_count
== 0)
9055 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9057 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9058 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9059 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9060 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9061 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9063 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9064 if (augmentation_string_size
% 4 != 0)
9066 warn (_("Augmentation string length %u must be rounded up "
9067 "to a multiple of 4 in .debug_names.\n"),
9068 augmentation_string_size
);
9069 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9072 printf (_("Augmentation string:"));
9074 augmentation_printable
= TRUE
;
9075 augmentation_string
= (const char *) hdrptr
;
9077 for (i
= 0; i
< augmentation_string_size
; i
++)
9081 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9082 printf (" %02x", uc
);
9084 if (uc
!= 0 && !ISPRINT (uc
))
9085 augmentation_printable
= FALSE
;
9088 if (augmentation_printable
)
9092 i
< augmentation_string_size
&& augmentation_string
[i
];
9094 putchar (augmentation_string
[i
]);
9099 printf (_("CU table:\n"));
9100 for (i
= 0; i
< comp_unit_count
; i
++)
9104 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9105 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9109 printf (_("TU table:\n"));
9110 for (i
= 0; i
< local_type_unit_count
; i
++)
9114 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9115 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9119 printf (_("Foreign TU table:\n"));
9120 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9124 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9125 printf (_("[%3u] "), i
);
9126 print_dwarf_vma (signature
, 8);
9131 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9132 hdrptr
+= bucket_count
* sizeof (uint32_t);
9133 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9134 hdrptr
+= name_count
* sizeof (uint32_t);
9135 unsigned char *const name_table_string_offsets
= hdrptr
;
9136 hdrptr
+= name_count
* offset_size
;
9137 unsigned char *const name_table_entry_offsets
= hdrptr
;
9138 hdrptr
+= name_count
* offset_size
;
9139 unsigned char *const abbrev_table
= hdrptr
;
9140 hdrptr
+= abbrev_table_size
;
9141 const unsigned char *const abbrev_table_end
= hdrptr
;
9142 unsigned char *const entry_pool
= hdrptr
;
9143 if (hdrptr
> unit_end
)
9145 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9146 "for unit 0x%lx in the debug_names\n"),
9147 (long) (hdrptr
- section
->start
),
9148 (long) (unit_end
- section
->start
),
9149 (long) (unit_start
- section
->start
));
9153 size_t buckets_filled
= 0;
9155 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9157 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9162 printf (ngettext ("Used %zu of %lu bucket.\n",
9163 "Used %zu of %lu buckets.\n",
9165 buckets_filled
, (unsigned long) bucket_count
);
9167 uint32_t hash_prev
= 0;
9168 size_t hash_clash_count
= 0;
9169 size_t longest_clash
= 0;
9170 size_t this_length
= 0;
9172 for (hashi
= 0; hashi
< name_count
; hashi
++)
9174 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9178 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9182 longest_clash
= MAX (longest_clash
, this_length
);
9187 hash_prev
= hash_this
;
9189 printf (_("Out of %lu items there are %zu bucket clashes"
9190 " (longest of %zu entries).\n"),
9191 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9192 assert (name_count
== buckets_filled
+ hash_clash_count
);
9194 struct abbrev_lookup_entry
9196 dwarf_vma abbrev_tag
;
9197 unsigned char *abbrev_lookup_ptr
;
9199 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9200 size_t abbrev_lookup_used
= 0;
9201 size_t abbrev_lookup_allocated
= 0;
9203 unsigned char *abbrevptr
= abbrev_table
;
9206 unsigned int bytes_read
;
9207 const dwarf_vma abbrev_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
9209 abbrevptr
+= bytes_read
;
9210 if (abbrev_tag
== 0)
9212 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9214 abbrev_lookup_allocated
= MAX (0x100,
9215 abbrev_lookup_allocated
* 2);
9216 abbrev_lookup
= xrealloc (abbrev_lookup
,
9217 (abbrev_lookup_allocated
9218 * sizeof (*abbrev_lookup
)));
9220 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9221 struct abbrev_lookup_entry
*entry
;
9222 for (entry
= abbrev_lookup
;
9223 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9225 if (entry
->abbrev_tag
== abbrev_tag
)
9227 warn (_("Duplicate abbreviation tag %lu "
9228 "in unit 0x%lx in the debug_names\n"),
9229 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9232 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9233 entry
->abbrev_tag
= abbrev_tag
;
9234 entry
->abbrev_lookup_ptr
= abbrevptr
;
9236 /* Skip DWARF tag. */
9237 read_uleb128 (abbrevptr
, &bytes_read
, abbrev_table_end
);
9238 abbrevptr
+= bytes_read
;
9241 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
9244 abbrevptr
+= bytes_read
;
9245 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
9247 abbrevptr
+= bytes_read
;
9248 if (xindex
== 0 && form
== 0)
9253 printf (_("\nSymbol table:\n"));
9255 for (namei
= 0; namei
< name_count
; ++namei
)
9257 uint64_t string_offset
, entry_offset
;
9259 SAFE_BYTE_GET (string_offset
,
9260 name_table_string_offsets
+ namei
* offset_size
,
9261 offset_size
, unit_end
);
9262 SAFE_BYTE_GET (entry_offset
,
9263 name_table_entry_offsets
+ namei
* offset_size
,
9264 offset_size
, unit_end
);
9266 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9267 fetch_indirect_string (string_offset
));
9269 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9271 // We need to scan first whether there is a single or multiple
9272 // entries. TAGNO is -2 for the first entry, it is -1 for the
9273 // initial tag read of the second entry, then it becomes 0 for the
9274 // first entry for real printing etc.
9276 /* Initialize it due to a false compiler warning. */
9277 dwarf_vma second_abbrev_tag
= -1;
9280 unsigned int bytes_read
;
9281 const dwarf_vma abbrev_tag
= read_uleb128 (entryptr
, &bytes_read
,
9283 entryptr
+= bytes_read
;
9286 second_abbrev_tag
= abbrev_tag
;
9288 entryptr
= entry_pool
+ entry_offset
;
9291 if (abbrev_tag
== 0)
9295 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9296 (unsigned long) abbrev_tag
);
9298 const struct abbrev_lookup_entry
*entry
;
9299 for (entry
= abbrev_lookup
;
9300 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9302 if (entry
->abbrev_tag
== abbrev_tag
)
9304 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9306 warn (_("Undefined abbreviation tag %lu "
9307 "in unit 0x%lx in the debug_names\n"),
9309 (long) (unit_start
- section
->start
));
9312 abbrevptr
= entry
->abbrev_lookup_ptr
;
9313 const dwarf_vma dwarf_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
9315 abbrevptr
+= bytes_read
;
9317 printf (" %s", get_TAG_name (dwarf_tag
));
9320 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
9323 abbrevptr
+= bytes_read
;
9324 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
9326 abbrevptr
+= bytes_read
;
9327 if (xindex
== 0 && form
== 0)
9331 printf (" %s", get_IDX_name (xindex
));
9332 entryptr
= read_and_display_attr_value (0, form
, 0,
9333 unit_start
, entryptr
, unit_end
,
9335 dwarf_version
, NULL
,
9342 printf (_(" <no entries>"));
9346 free (abbrev_lookup
);
9353 display_debug_links (struct dwarf_section
* section
,
9354 void * file ATTRIBUTE_UNUSED
)
9356 const unsigned char * filename
;
9357 unsigned int filelen
;
9359 introduce (section
, FALSE
);
9361 /* The .gnu_debuglink section is formatted as:
9362 (c-string) Filename.
9363 (padding) If needed to reach a 4 byte boundary.
9364 (uint32_t) CRC32 value.
9366 The .gun_debugaltlink section is formatted as:
9367 (c-string) Filename.
9368 (binary) Build-ID. */
9370 filename
= section
->start
;
9371 filelen
= strnlen ((const char *) filename
, section
->size
);
9372 if (filelen
== section
->size
)
9374 warn (_("The debuglink filename is corrupt/missing\n"));
9378 printf (_(" Separate debug info file: %s\n"), filename
);
9380 if (const_strneq (section
->name
, ".gnu_debuglink"))
9383 unsigned int crc_offset
;
9385 crc_offset
= filelen
+ 1;
9386 crc_offset
= (crc_offset
+ 3) & ~3;
9387 if (crc_offset
+ 4 > section
->size
)
9389 warn (_("CRC offset missing/truncated\n"));
9393 crc32
= byte_get (filename
+ crc_offset
, 4);
9395 printf (_(" CRC value: %#x\n"), crc32
);
9397 if (crc_offset
+ 4 < section
->size
)
9399 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9400 (long)(section
->size
- (crc_offset
+ 4)));
9404 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9406 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9407 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9408 bfd_size_type printed
;
9410 /* FIXME: Should we support smaller build-id notes ? */
9411 if (build_id_len
< 0x14)
9413 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9417 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9418 display_data (printed
, build_id
, build_id_len
);
9427 display_gdb_index (struct dwarf_section
*section
,
9428 void *file ATTRIBUTE_UNUSED
)
9430 unsigned char *start
= section
->start
;
9432 uint32_t cu_list_offset
, tu_list_offset
;
9433 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9434 unsigned int cu_list_elements
, tu_list_elements
;
9435 unsigned int address_table_size
, symbol_table_slots
;
9436 unsigned char *cu_list
, *tu_list
;
9437 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9440 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9442 introduce (section
, FALSE
);
9444 if (section
->size
< 6 * sizeof (uint32_t))
9446 warn (_("Truncated header in the %s section.\n"), section
->name
);
9450 version
= byte_get_little_endian (start
, 4);
9451 printf (_("Version %ld\n"), (long) version
);
9453 /* Prior versions are obsolete, and future versions may not be
9454 backwards compatible. */
9455 if (version
< 3 || version
> 8)
9457 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9461 warn (_("The address table data in version 3 may be wrong.\n"));
9463 warn (_("Version 4 does not support case insensitive lookups.\n"));
9465 warn (_("Version 5 does not include inlined functions.\n"));
9467 warn (_("Version 6 does not include symbol attributes.\n"));
9468 /* Version 7 indices generated by Gold have bad type unit references,
9469 PR binutils/15021. But we don't know if the index was generated by
9470 Gold or not, so to avoid worrying users with gdb-generated indices
9471 we say nothing for version 7 here. */
9473 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9474 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9475 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9476 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9477 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9479 if (cu_list_offset
> section
->size
9480 || tu_list_offset
> section
->size
9481 || address_table_offset
> section
->size
9482 || symbol_table_offset
> section
->size
9483 || constant_pool_offset
> section
->size
)
9485 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9489 /* PR 17531: file: 418d0a8a. */
9490 if (tu_list_offset
< cu_list_offset
)
9492 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9493 tu_list_offset
, cu_list_offset
);
9497 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9499 if (address_table_offset
< tu_list_offset
)
9501 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9502 address_table_offset
, tu_list_offset
);
9506 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9508 /* PR 17531: file: 18a47d3d. */
9509 if (symbol_table_offset
< address_table_offset
)
9511 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9512 symbol_table_offset
, address_table_offset
);
9516 address_table_size
= symbol_table_offset
- address_table_offset
;
9518 if (constant_pool_offset
< symbol_table_offset
)
9520 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9521 constant_pool_offset
, symbol_table_offset
);
9525 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9527 cu_list
= start
+ cu_list_offset
;
9528 tu_list
= start
+ tu_list_offset
;
9529 address_table
= start
+ address_table_offset
;
9530 symbol_table
= start
+ symbol_table_offset
;
9531 constant_pool
= start
+ constant_pool_offset
;
9533 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9535 warn (_("Address table extends beyond end of section.\n"));
9539 printf (_("\nCU table:\n"));
9540 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9542 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9543 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9545 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9546 (unsigned long) cu_offset
,
9547 (unsigned long) (cu_offset
+ cu_length
- 1));
9550 printf (_("\nTU table:\n"));
9551 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9553 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9554 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9555 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9557 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9558 (unsigned long) tu_offset
,
9559 (unsigned long) type_offset
);
9560 print_dwarf_vma (signature
, 8);
9564 printf (_("\nAddress table:\n"));
9565 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9568 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9569 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9570 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9572 print_dwarf_vma (low
, 8);
9573 print_dwarf_vma (high
, 8);
9574 printf (_("%lu\n"), (unsigned long) cu_index
);
9577 printf (_("\nSymbol table:\n"));
9578 for (i
= 0; i
< symbol_table_slots
; ++i
)
9580 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9581 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9582 uint32_t num_cus
, cu
;
9584 if (name_offset
!= 0
9585 || cu_vector_offset
!= 0)
9588 unsigned char * adr
;
9590 adr
= constant_pool
+ name_offset
;
9591 /* PR 17531: file: 5b7b07ad. */
9592 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9594 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9595 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9599 printf ("[%3u] %.*s:", i
,
9600 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9601 constant_pool
+ name_offset
);
9603 adr
= constant_pool
+ cu_vector_offset
;
9604 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9606 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9607 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9608 cu_vector_offset
, i
);
9612 num_cus
= byte_get_little_endian (adr
, 4);
9614 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9615 if (num_cus
* 4 < num_cus
9616 || adr
>= section
->start
+ section
->size
9617 || adr
< constant_pool
)
9619 printf ("<invalid number of CUs: %d>\n", num_cus
);
9620 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9628 for (j
= 0; j
< num_cus
; ++j
)
9631 gdb_index_symbol_kind kind
;
9633 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9634 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9635 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9636 cu
= GDB_INDEX_CU_VALUE (cu
);
9637 /* Convert to TU number if it's for a type unit. */
9638 if (cu
>= cu_list_elements
/ 2)
9639 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9640 (unsigned long) (cu
- cu_list_elements
/ 2));
9642 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9644 printf (" [%s, %s]",
9645 is_static
? _("static") : _("global"),
9646 get_gdb_index_symbol_kind_name (kind
));
9658 /* Pre-allocate enough space for the CU/TU sets needed. */
9661 prealloc_cu_tu_list (unsigned int nshndx
)
9663 if (shndx_pool
== NULL
)
9665 shndx_pool_size
= nshndx
;
9666 shndx_pool_used
= 0;
9667 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9668 sizeof (unsigned int));
9672 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9673 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9674 sizeof (unsigned int));
9679 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9681 if (shndx_pool_used
>= shndx_pool_size
)
9683 error (_("Internal error: out of space in the shndx pool.\n"));
9686 shndx_pool
[shndx_pool_used
++] = shndx
;
9690 end_cu_tu_entry (void)
9692 if (shndx_pool_used
>= shndx_pool_size
)
9694 error (_("Internal error: out of space in the shndx pool.\n"));
9697 shndx_pool
[shndx_pool_used
++] = 0;
9700 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9703 get_DW_SECT_short_name (unsigned int dw_sect
)
9705 static char buf
[16];
9713 case DW_SECT_ABBREV
:
9719 case DW_SECT_STR_OFFSETS
:
9721 case DW_SECT_MACINFO
:
9729 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9733 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9734 These sections are extensions for Fission.
9735 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9738 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9740 unsigned char *phdr
= section
->start
;
9741 unsigned char *limit
= phdr
+ section
->size
;
9742 unsigned char *phash
;
9743 unsigned char *pindex
;
9744 unsigned char *ppool
;
9745 unsigned int version
;
9746 unsigned int ncols
= 0;
9748 unsigned int nslots
;
9751 dwarf_vma signature_high
;
9752 dwarf_vma signature_low
;
9755 /* PR 17512: file: 002-168123-0.004. */
9758 warn (_("Section %s is empty\n"), section
->name
);
9761 /* PR 17512: file: 002-376-0.004. */
9762 if (section
->size
< 24)
9764 warn (_("Section %s is too small to contain a CU/TU header\n"),
9769 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9771 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9772 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9773 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9776 pindex
= phash
+ (size_t) nslots
* 8;
9777 ppool
= pindex
+ (size_t) nslots
* 4;
9781 introduce (section
, FALSE
);
9783 printf (_(" Version: %u\n"), version
);
9785 printf (_(" Number of columns: %u\n"), ncols
);
9786 printf (_(" Number of used entries: %u\n"), nused
);
9787 printf (_(" Number of slots: %u\n\n"), nslots
);
9790 /* PR 17531: file: 45d69832. */
9791 if ((size_t) nslots
* 8 / 8 != nslots
9792 || phash
< phdr
|| phash
> limit
9793 || pindex
< phash
|| pindex
> limit
9794 || ppool
< pindex
|| ppool
> limit
)
9796 warn (ngettext ("Section %s is too small for %u slot\n",
9797 "Section %s is too small for %u slots\n",
9799 section
->name
, nslots
);
9806 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9807 for (i
= 0; i
< nslots
; i
++)
9809 unsigned char *shndx_list
;
9812 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9813 if (signature_high
!= 0 || signature_low
!= 0)
9815 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9816 shndx_list
= ppool
+ j
* 4;
9817 /* PR 17531: file: 705e010d. */
9818 if (shndx_list
< ppool
)
9820 warn (_("Section index pool located before start of section\n"));
9825 printf (_(" [%3d] Signature: 0x%s Sections: "),
9826 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9827 buf
, sizeof (buf
)));
9830 if (shndx_list
>= limit
)
9832 warn (_("Section %s too small for shndx pool\n"),
9836 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9840 printf (" %d", shndx
);
9842 add_shndx_to_cu_tu_entry (shndx
);
9854 else if (version
== 2)
9857 unsigned int dw_sect
;
9858 unsigned char *ph
= phash
;
9859 unsigned char *pi
= pindex
;
9860 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9861 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9862 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9863 bfd_boolean is_tu_index
;
9864 struct cu_tu_set
*this_set
= NULL
;
9866 unsigned char *prow
;
9868 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9870 /* PR 17531: file: 0dd159bf.
9871 Check for integer overflow (can occur when size_t is 32-bit)
9872 with overlarge ncols or nused values. */
9874 && ((size_t) ncols
* 4 / 4 != ncols
9875 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9876 || poffsets
< ppool
|| poffsets
> limit
9877 || psizes
< poffsets
|| psizes
> limit
9878 || pend
< psizes
|| pend
> limit
))
9880 warn (_("Section %s too small for offset and size tables\n"),
9887 printf (_(" Offset table\n"));
9888 printf (" slot %-16s ",
9889 is_tu_index
? _("signature") : _("dwo_id"));
9896 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9902 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9909 for (j
= 0; j
< ncols
; j
++)
9911 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9912 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9917 for (i
= 0; i
< nslots
; i
++)
9919 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9921 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9924 /* PR 17531: file: a05f6ab3. */
9927 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9934 size_t num_copy
= sizeof (uint64_t);
9936 /* PR 23064: Beware of buffer overflow. */
9937 if (ph
+ num_copy
< limit
)
9938 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9941 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9946 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9947 /* PR 17531: file: b8ce60a8. */
9948 if (prow
< poffsets
|| prow
> limit
)
9950 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9956 printf (_(" [%3d] 0x%s"),
9957 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9958 buf
, sizeof (buf
)));
9959 for (j
= 0; j
< ncols
; j
++)
9961 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9963 printf (" %8d", val
);
9966 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9968 /* PR 17531: file: 10796eb3. */
9969 if (dw_sect
>= DW_SECT_MAX
)
9970 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9972 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9988 printf (_(" Size table\n"));
9989 printf (" slot %-16s ",
9990 is_tu_index
? _("signature") : _("dwo_id"));
9993 for (j
= 0; j
< ncols
; j
++)
9995 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9997 printf (" %8s", get_DW_SECT_short_name (val
));
10003 for (i
= 0; i
< nslots
; i
++)
10005 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
10007 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10010 prow
= psizes
+ (row
- 1) * ncols
* 4;
10013 printf (_(" [%3d] 0x%s"),
10014 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10015 buf
, sizeof (buf
)));
10017 for (j
= 0; j
< ncols
; j
++)
10019 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
10021 printf (" %8d", val
);
10024 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10025 if (dw_sect
>= DW_SECT_MAX
)
10026 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10028 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10040 else if (do_display
)
10041 printf (_(" Unsupported version (%d)\n"), version
);
10049 /* Load the CU and TU indexes if present. This will build a list of
10050 section sets that we can use to associate a .debug_info.dwo section
10051 with its associated .debug_abbrev.dwo section in a .dwp file. */
10054 load_cu_tu_indexes (void *file
)
10056 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10058 /* If we have already loaded (or tried to load) the CU and TU indexes
10059 then do not bother to repeat the task. */
10060 if (cu_tu_indexes_read
== -1)
10062 cu_tu_indexes_read
= TRUE
;
10064 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10065 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10066 cu_tu_indexes_read
= FALSE
;
10068 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10069 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10070 cu_tu_indexes_read
= FALSE
;
10073 return (bfd_boolean
) cu_tu_indexes_read
;
10076 /* Find the set of sections that includes section SHNDX. */
10079 find_cu_tu_set (void *file
, unsigned int shndx
)
10083 if (! load_cu_tu_indexes (file
))
10086 /* Find SHNDX in the shndx pool. */
10087 for (i
= 0; i
< shndx_pool_used
; i
++)
10088 if (shndx_pool
[i
] == shndx
)
10091 if (i
>= shndx_pool_used
)
10094 /* Now backup to find the first entry in the set. */
10095 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10098 return shndx_pool
+ i
;
10101 /* Display a .debug_cu_index or .debug_tu_index section. */
10104 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10106 return process_cu_tu_index (section
, 1);
10110 display_debug_not_supported (struct dwarf_section
*section
,
10111 void *file ATTRIBUTE_UNUSED
)
10113 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10119 /* Like malloc, but takes two parameters like calloc.
10120 Verifies that the first parameter is not too large.
10121 Note: does *not* initialise the allocated memory to zero. */
10124 cmalloc (size_t nmemb
, size_t size
)
10126 /* Check for overflow. */
10127 if (nmemb
>= ~(size_t) 0 / size
)
10130 return xmalloc (nmemb
* size
);
10133 /* Like xmalloc, but takes two parameters like calloc.
10134 Verifies that the first parameter is not too large.
10135 Note: does *not* initialise the allocated memory to zero. */
10138 xcmalloc (size_t nmemb
, size_t size
)
10140 /* Check for overflow. */
10141 if (nmemb
>= ~(size_t) 0 / size
)
10144 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10149 return xmalloc (nmemb
* size
);
10152 /* Like xrealloc, but takes three parameters.
10153 Verifies that the second parameter is not too large.
10154 Note: does *not* initialise any new memory to zero. */
10157 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10159 /* Check for overflow. */
10160 if (nmemb
>= ~(size_t) 0 / size
)
10162 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10167 return xrealloc (ptr
, nmemb
* size
);
10170 /* Like xcalloc, but verifies that the first parameter is not too large. */
10173 xcalloc2 (size_t nmemb
, size_t size
)
10175 /* Check for overflow. */
10176 if (nmemb
>= ~(size_t) 0 / size
)
10178 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10183 return xcalloc (nmemb
, size
);
10186 static unsigned long
10187 calc_gnu_debuglink_crc32 (unsigned long crc
,
10188 const unsigned char * buf
,
10191 static const unsigned long crc32_table
[256] =
10193 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10194 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10195 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10196 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10197 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10198 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10199 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10200 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10201 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10202 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10203 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10204 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10205 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10206 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10207 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10208 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10209 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10210 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10211 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10212 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10213 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10214 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10215 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10216 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10217 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10218 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10219 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10220 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10221 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10222 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10223 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10224 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10225 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10226 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10227 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10228 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10229 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10230 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10231 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10232 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10233 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10234 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10235 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10236 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10237 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10238 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10239 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10240 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10241 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10242 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10243 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10246 const unsigned char *end
;
10248 crc
= ~crc
& 0xffffffff;
10249 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10250 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10251 return ~crc
& 0xffffffff;
10254 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10255 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10258 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10260 static unsigned char buffer
[8 * 1024];
10262 bfd_size_type count
;
10263 unsigned long crc
= 0;
10266 sep_data
= open_debug_file (pathname
);
10267 if (sep_data
== NULL
)
10270 /* Yes - we are opening the file twice... */
10271 f
= fopen (pathname
, "rb");
10274 /* Paranoia: This should never happen. */
10275 close_debug_file (sep_data
);
10276 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10280 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10281 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10285 if (crc
!= * (unsigned long *) crc_pointer
)
10287 close_debug_file (sep_data
);
10288 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10296 static const char *
10297 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10300 unsigned int crc_offset
;
10301 unsigned long * crc32
= (unsigned long *) data
;
10303 /* The name is first.
10304 The CRC value is stored after the filename, aligned up to 4 bytes. */
10305 name
= (const char *) section
->start
;
10308 crc_offset
= strnlen (name
, section
->size
) + 1;
10309 crc_offset
= (crc_offset
+ 3) & ~3;
10310 if (crc_offset
+ 4 > section
->size
)
10313 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10318 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10320 void * sep_data
= open_debug_file (filename
);
10322 if (sep_data
== NULL
)
10325 /* FIXME: We should now extract the build-id in the separate file
10331 typedef struct build_id_data
10334 const unsigned char * data
;
10337 static const char *
10338 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10341 bfd_size_type namelen
;
10342 bfd_size_type id_len
;
10343 Build_id_data
* build_id_data
;
10345 /* The name is first.
10346 The build-id follows immediately, with no padding, up to the section's end. */
10348 name
= (const char *) section
->start
;
10349 namelen
= strnlen (name
, section
->size
) + 1;
10350 if (namelen
>= section
->size
)
10353 id_len
= section
->size
- namelen
;
10357 build_id_data
= calloc (1, sizeof * build_id_data
);
10358 if (build_id_data
== NULL
)
10361 build_id_data
->len
= id_len
;
10362 build_id_data
->data
= section
->start
+ namelen
;
10364 * (Build_id_data
**) data
= build_id_data
;
10370 add_separate_debug_file (const char * filename
, void * handle
)
10372 separate_info
* i
= xmalloc (sizeof * i
);
10374 i
->filename
= filename
;
10375 i
->handle
= handle
;
10376 i
->next
= first_separate_info
;
10377 first_separate_info
= i
;
10381 load_separate_debug_info (const char * main_filename
,
10382 struct dwarf_section
* xlink
,
10383 parse_func_type parse_func
,
10384 check_func_type check_func
,
10387 const char * separate_filename
;
10388 char * debug_filename
;
10390 size_t canon_dirlen
;
10393 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10395 warn (_("Corrupt debuglink section: %s\n"),
10396 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10400 /* Attempt to locate the separate file.
10401 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10403 canon_dir
= lrealpath (main_filename
);
10405 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10406 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10408 canon_dir
[canon_dirlen
] = '\0';
10411 #define DEBUGDIR "/lib/debug"
10413 #ifndef EXTRA_DEBUG_ROOT1
10414 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10416 #ifndef EXTRA_DEBUG_ROOT2
10417 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10420 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10422 + strlen (".debug/")
10423 #ifdef EXTRA_DEBUG_ROOT1
10424 + strlen (EXTRA_DEBUG_ROOT1
)
10426 #ifdef EXTRA_DEBUG_ROOT2
10427 + strlen (EXTRA_DEBUG_ROOT2
)
10429 + strlen (separate_filename
)
10431 if (debug_filename
== NULL
)
10433 warn (_("Out of memory"));
10438 /* First try in the current directory. */
10439 sprintf (debug_filename
, "%s", separate_filename
);
10440 if (check_func (debug_filename
, func_data
))
10443 /* Then try in a subdirectory called .debug. */
10444 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10445 if (check_func (debug_filename
, func_data
))
10448 /* Then try in the same directory as the original file. */
10449 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10450 if (check_func (debug_filename
, func_data
))
10453 /* And the .debug subdirectory of that directory. */
10454 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10455 if (check_func (debug_filename
, func_data
))
10458 #ifdef EXTRA_DEBUG_ROOT1
10459 /* Try the first extra debug file root. */
10460 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10461 if (check_func (debug_filename
, func_data
))
10464 /* Try the first extra debug file root. */
10465 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10466 if (check_func (debug_filename
, func_data
))
10470 #ifdef EXTRA_DEBUG_ROOT2
10471 /* Try the second extra debug file root. */
10472 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10473 if (check_func (debug_filename
, func_data
))
10477 /* Then try in the global debug_filename directory. */
10478 strcpy (debug_filename
, DEBUGDIR
);
10479 dirlen
= strlen (DEBUGDIR
) - 1;
10480 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10481 strcat (debug_filename
, "/");
10482 strcat (debug_filename
, (const char *) separate_filename
);
10484 if (check_func (debug_filename
, func_data
))
10487 /* Failed to find the file. */
10488 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10489 warn (_("tried: %s\n"), debug_filename
);
10491 #ifdef EXTRA_DEBUG_ROOT2
10492 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10493 warn (_("tried: %s\n"), debug_filename
);
10496 #ifdef EXTRA_DEBUG_ROOT1
10497 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10498 warn (_("tried: %s\n"), debug_filename
);
10500 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10501 warn (_("tried: %s\n"), debug_filename
);
10504 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10505 warn (_("tried: %s\n"), debug_filename
);
10507 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10508 warn (_("tried: %s\n"), debug_filename
);
10510 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10511 warn (_("tried: %s\n"), debug_filename
);
10513 sprintf (debug_filename
, "%s", separate_filename
);
10514 warn (_("tried: %s\n"), debug_filename
);
10517 free (debug_filename
);
10523 void * debug_handle
;
10525 /* Now open the file.... */
10526 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10528 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10529 free (debug_filename
);
10533 /* FIXME: We do not check to see if there are any other separate debug info
10534 files that would also match. */
10536 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10537 add_separate_debug_file (debug_filename
, debug_handle
);
10539 /* Do not free debug_filename - it might be referenced inside
10540 the structure returned by open_debug_file(). */
10541 return debug_handle
;
10544 /* Attempt to load a separate dwarf object file. */
10547 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10549 char * separate_filename
;
10550 void * separate_handle
;
10552 /* FIXME: Skip adding / if dwo_dir ends in /. */
10553 separate_filename
= concat (dir
, "/", name
, NULL
);
10554 if (separate_filename
== NULL
)
10556 warn (_("Out of memory allocating dwo filename\n"));
10560 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10562 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10563 free (separate_filename
);
10567 /* FIXME: We should check the dwo_id. */
10569 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10570 add_separate_debug_file (separate_filename
, separate_handle
);
10571 /* Note - separate_filename will be freed in free_debug_memory(). */
10572 return separate_handle
;
10575 /* Load the separate debug info file(s) attached to FILE, if any exist.
10576 Returns TRUE if any were found, FALSE otherwise.
10577 If TRUE is returned then the linked list starting at first_separate_info
10578 will be populated with open file handles. */
10581 load_separate_debug_files (void * file
, const char * filename
)
10583 /* Skip this operation if we are not interested in debug links. */
10584 if (! do_follow_links
&& ! do_debug_links
)
10587 /* See if there are any dwo links. */
10588 if (load_debug_section (str
, file
)
10589 && load_debug_section (abbrev
, file
)
10590 && load_debug_section (info
, file
))
10594 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10596 bfd_boolean introduced
= FALSE
;
10598 const char * dir
= NULL
;
10599 const char * id
= NULL
;
10601 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10603 switch (dwinfo
->type
)
10606 if (do_debug_links
)
10610 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10611 debug_displays
[info
].section
.uncompressed_name
);
10615 printf (_(" Name: %s\n"), dwinfo
->value
);
10616 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10618 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10620 printf (_(" ID: <unknown>\n"));
10624 if (do_follow_links
)
10625 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10629 dir
= dwinfo
->value
;
10633 id
= dwinfo
->value
;
10637 error (_("Unexpected DWO INFO type"));
10644 if (! do_follow_links
)
10645 /* The other debug links will be displayed by display_debug_links()
10646 so we do not need to do any further processing here. */
10649 /* FIXME: We do not check for the presence of both link sections in the same file. */
10650 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10651 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10652 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10654 if (load_debug_section (gnu_debugaltlink
, file
))
10656 Build_id_data
* build_id_data
;
10658 load_separate_debug_info (filename
,
10659 & debug_displays
[gnu_debugaltlink
].section
,
10660 parse_gnu_debugaltlink
,
10661 check_gnu_debugaltlink
,
10665 if (load_debug_section (gnu_debuglink
, file
))
10667 unsigned long crc32
;
10669 load_separate_debug_info (filename
,
10670 & debug_displays
[gnu_debuglink
].section
,
10671 parse_gnu_debuglink
,
10672 check_gnu_debuglink
,
10676 if (first_separate_info
!= NULL
)
10679 do_follow_links
= 0;
10684 free_debug_memory (void)
10690 for (i
= 0; i
< max
; i
++)
10691 free_debug_section ((enum dwarf_section_display_enum
) i
);
10693 if (debug_information
!= NULL
)
10695 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10697 for (i
= 0; i
< num_debug_info_entries
; i
++)
10699 if (!debug_information
[i
].max_loc_offsets
)
10701 free (debug_information
[i
].loc_offsets
);
10702 free (debug_information
[i
].have_frame_base
);
10704 if (!debug_information
[i
].max_range_lists
)
10705 free (debug_information
[i
].range_lists
);
10708 free (debug_information
);
10709 debug_information
= NULL
;
10710 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10714 separate_info
* next
;
10716 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10718 close_debug_file (d
->handle
);
10719 free ((void *) d
->filename
);
10723 first_separate_info
= NULL
;
10729 dwarf_select_sections_by_names (const char *names
)
10733 const char * option
;
10737 debug_dump_long_opts
;
10739 static const debug_dump_long_opts opts_table
[] =
10741 /* Please keep this table alpha- sorted. */
10742 { "Ranges", & do_debug_ranges
, 1 },
10743 { "abbrev", & do_debug_abbrevs
, 1 },
10744 { "addr", & do_debug_addr
, 1 },
10745 { "aranges", & do_debug_aranges
, 1 },
10746 { "cu_index", & do_debug_cu_index
, 1 },
10747 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10748 { "follow-links", & do_follow_links
, 1 },
10749 { "frames", & do_debug_frames
, 1 },
10750 { "frames-interp", & do_debug_frames_interp
, 1 },
10751 /* The special .gdb_index section. */
10752 { "gdb_index", & do_gdb_index
, 1 },
10753 { "info", & do_debug_info
, 1 },
10754 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10755 { "links", & do_debug_links
, 1 },
10756 { "loc", & do_debug_loc
, 1 },
10757 { "macro", & do_debug_macinfo
, 1 },
10758 { "pubnames", & do_debug_pubnames
, 1 },
10759 { "pubtypes", & do_debug_pubtypes
, 1 },
10760 /* This entry is for compatibility
10761 with earlier versions of readelf. */
10762 { "ranges", & do_debug_aranges
, 1 },
10763 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10764 { "str", & do_debug_str
, 1 },
10765 /* These trace_* sections are used by Itanium VMS. */
10766 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10767 { "trace_aranges", & do_trace_aranges
, 1 },
10768 { "trace_info", & do_trace_info
, 1 },
10777 const debug_dump_long_opts
* entry
;
10779 for (entry
= opts_table
; entry
->option
; entry
++)
10781 size_t len
= strlen (entry
->option
);
10783 if (strncmp (p
, entry
->option
, len
) == 0
10784 && (p
[len
] == ',' || p
[len
] == '\0'))
10786 * entry
->variable
|= entry
->val
;
10788 /* The --debug-dump=frames-interp option also
10789 enables the --debug-dump=frames option. */
10790 if (do_debug_frames_interp
)
10791 do_debug_frames
= 1;
10798 if (entry
->option
== NULL
)
10800 warn (_("Unrecognized debug option '%s'\n"), p
);
10801 p
= strchr (p
, ',');
10812 dwarf_select_sections_by_letters (const char *letters
)
10814 unsigned int lindex
= 0;
10816 while (letters
[lindex
])
10817 switch (letters
[lindex
++])
10819 case 'A': do_debug_addr
= 1; break;
10820 case 'a': do_debug_abbrevs
= 1; break;
10821 case 'c': do_debug_cu_index
= 1; break;
10822 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10823 case 'f': do_debug_frames
= 1; break;
10824 case 'g': do_gdb_index
= 1; break;
10825 case 'i': do_debug_info
= 1; break;
10826 case 'K': do_follow_links
= 1; break;
10827 case 'k': do_debug_links
= 1; break;
10828 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10829 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10830 case 'm': do_debug_macinfo
= 1; break;
10831 case 'o': do_debug_loc
= 1; break;
10832 case 'p': do_debug_pubnames
= 1; break;
10833 case 'R': do_debug_ranges
= 1; break;
10834 case 'r': do_debug_aranges
= 1; break;
10835 case 's': do_debug_str
= 1; break;
10836 case 'T': do_trace_aranges
= 1; break;
10837 case 't': do_debug_pubtypes
= 1; break;
10838 case 'U': do_trace_info
= 1; break;
10839 case 'u': do_trace_abbrevs
= 1; break;
10842 warn (_("Unrecognized debug option '%s'\n"), letters
);
10848 dwarf_select_sections_all (void)
10851 do_debug_abbrevs
= 1;
10852 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10853 do_debug_pubnames
= 1;
10854 do_debug_pubtypes
= 1;
10855 do_debug_aranges
= 1;
10856 do_debug_ranges
= 1;
10857 do_debug_frames
= 1;
10858 do_debug_macinfo
= 1;
10863 do_trace_abbrevs
= 1;
10864 do_trace_aranges
= 1;
10866 do_debug_cu_index
= 1;
10867 do_follow_links
= 1;
10868 do_debug_links
= 1;
10871 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10872 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10874 /* N.B. The order here must match the order in section_display_enum. */
10876 struct dwarf_section_display debug_displays
[] =
10878 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10879 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10880 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10881 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10882 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10883 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10884 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10885 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10886 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10887 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10888 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10889 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10890 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10891 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10892 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10893 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10894 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10895 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10896 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10897 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10898 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10899 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10900 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10901 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10902 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10903 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10904 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10905 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10906 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10907 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10908 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10909 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10910 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10911 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10912 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10913 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10914 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10915 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10916 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10917 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10918 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10919 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10920 /* Separate debug info files can containt their own .debug_str section,
10921 and this might be in *addition* to a .debug_str section already present
10922 in the main file. Hence we need to have two entries for .debug_str. */
10923 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10926 /* A static assertion. */
10927 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];