1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2020 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 #include "libiberty.h"
24 #include "bfd_stdint.h"
27 #include "elf/common.h"
30 #include "gdb/gdb-index.h"
31 #include "filenames.h"
32 #include "safe-ctype.h"
35 #ifdef HAVE_LIBDEBUGINFOD
36 #include <elfutils/debuginfod.h>
41 #define MAX(a, b) ((a) > (b) ? (a) : (b))
42 #define MIN(a, b) ((a) < (b) ? (a) : (b))
44 static const char *regname (unsigned int regno
, int row
);
45 static const char *regname_internal_by_table_only (unsigned int regno
);
47 static int have_frame_base
;
48 static int need_base_address
;
50 static unsigned int num_debug_info_entries
= 0;
51 static unsigned int alloc_num_debug_info_entries
= 0;
52 static debug_info
*debug_information
= NULL
;
53 /* Special value for num_debug_info_entries to indicate
54 that the .debug_info section could not be loaded/parsed. */
55 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
57 /* A .debug_info section can contain multiple links to separate
58 DWO object files. We use these structures to record these links. */
66 typedef struct dwo_info
70 struct dwo_info
* next
;
73 static dwo_info
* first_dwo_info
= NULL
;
74 static bfd_boolean need_dwo_info
;
76 separate_info
* first_separate_info
= NULL
;
78 unsigned int eh_addr_size
;
83 int do_debug_pubnames
;
84 int do_debug_pubtypes
;
88 int do_debug_frames_interp
;
97 int do_debug_cu_index
;
102 int dwarf_cutoff_level
= -1;
103 unsigned long dwarf_start_die
;
107 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
108 testing whether e.g. a locview list is present. */
109 static const dwarf_vma vm1
= -1;
111 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
112 sections. For version 1 package files, each set is stored in SHNDX_POOL
113 as a zero-terminated list of section indexes comprising one set of debug
114 sections from a .dwo file. */
116 static unsigned int *shndx_pool
= NULL
;
117 static unsigned int shndx_pool_size
= 0;
118 static unsigned int shndx_pool_used
= 0;
120 /* For version 2 package files, each set contains an array of section offsets
121 and an array of section sizes, giving the offset and size of the
122 contribution from a CU or TU within one of the debug sections.
123 When displaying debug info from a package file, we need to use these
124 tables to locate the corresponding contributions to each section. */
129 dwarf_vma section_offsets
[DW_SECT_MAX
];
130 size_t section_sizes
[DW_SECT_MAX
];
133 static int cu_count
= 0;
134 static int tu_count
= 0;
135 static struct cu_tu_set
*cu_sets
= NULL
;
136 static struct cu_tu_set
*tu_sets
= NULL
;
138 static bfd_boolean
load_cu_tu_indexes (void *);
140 /* An array that indicates for a given level of CU nesting whether
141 the latest DW_AT_type seen for that level was a signed type or
143 #define MAX_CU_NESTING (1 << 8)
144 static bfd_boolean level_type_signed
[MAX_CU_NESTING
];
146 /* Values for do_debug_lines. */
147 #define FLAG_DEBUG_LINES_RAW 1
148 #define FLAG_DEBUG_LINES_DECODED 2
151 size_of_encoded_value (int encoding
)
153 switch (encoding
& 0x7)
156 case 0: return eh_addr_size
;
164 get_encoded_value (unsigned char **pdata
,
166 struct dwarf_section
*section
,
169 unsigned char * data
= * pdata
;
170 unsigned int size
= size_of_encoded_value (encoding
);
173 if (data
+ size
>= end
)
175 warn (_("Encoded value extends past end of section\n"));
180 /* PR 17512: file: 002-829853-0.004. */
183 warn (_("Encoded size of %d is too large to read\n"), size
);
188 /* PR 17512: file: 1085-5603-0.004. */
191 warn (_("Encoded size of 0 is too small to read\n"));
196 if (encoding
& DW_EH_PE_signed
)
197 val
= byte_get_signed (data
, size
);
199 val
= byte_get (data
, size
);
201 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
202 val
+= section
->address
+ (data
- section
->start
);
204 * pdata
= data
+ size
;
208 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
210 # define DWARF_VMA_FMT "ll"
211 # define DWARF_VMA_FMT_LONG "%16.16llx"
213 # define DWARF_VMA_FMT "I64"
214 # define DWARF_VMA_FMT_LONG "%016I64x"
217 # define DWARF_VMA_FMT "l"
218 # define DWARF_VMA_FMT_LONG "%16.16lx"
221 /* Convert a dwarf vma value into a string. Returns a pointer to a static
222 buffer containing the converted VALUE. The value is converted according
223 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
224 it specifies the maximum number of bytes to be displayed in the converted
225 value and FMTCH is ignored - hex is always used. */
228 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
230 /* As dwarf_vmatoa is used more then once in a printf call
231 for output, we are cycling through an fixed array of pointers
232 for return address. */
233 static int buf_pos
= 0;
234 static struct dwarf_vmatoa_buf
240 ret
= buf
[buf_pos
++].place
;
241 buf_pos
%= ARRAY_SIZE (buf
);
245 /* Printf does not have a way of specifying a maximum field width for an
246 integer value, so we print the full value into a buffer and then select
247 the precision we need. */
248 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
251 return ret
+ (16 - 2 * num_bytes
);
258 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
260 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
261 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
266 static inline const char *
267 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
269 return dwarf_vmatoa_1 (fmtch
, value
, 0);
272 /* Print a dwarf_vma value (typically an address, offset or length) in
273 hexadecimal format, followed by a space. The length of the VALUE (and
274 hence the precision displayed) is determined by the NUM_BYTES parameter. */
277 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
279 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
282 /* Print a view number in hexadecimal value, with the same width
283 print_dwarf_vma would have printed it with the same num_bytes.
284 Print blanks for zero view, unless force is nonzero. */
287 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
295 assert (value
== (unsigned long) value
);
297 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
299 printf ("%*s", len
+ 1, "");
302 /* Format a 64-bit value, given as two 32-bit values, in hex.
303 For reentrancy, this uses a buffer provided by the caller. */
306 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
307 unsigned int buf_len
)
312 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
315 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
316 snprintf (buf
+ len
, buf_len
- len
,
317 "%08" DWARF_VMA_FMT
"x", lvalue
);
323 /* Read in a LEB128 encoded value starting at address DATA.
324 If SIGN is true, return a signed LEB128 value.
325 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
326 If STATUS_RETURN in not NULL, return with bit 0 (LSB) set if the
327 terminating byte was not found and with bit 1 set if the value
328 overflows a dwarf_vma.
329 No bytes will be read at address END or beyond. */
332 read_leb128 (unsigned char *data
,
333 const unsigned char *const end
,
335 unsigned int *length_return
,
338 dwarf_vma result
= 0;
339 unsigned int num_read
= 0;
340 unsigned int shift
= 0;
345 unsigned char byte
= *data
++;
348 if (shift
< sizeof (result
) * 8)
350 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
351 if ((result
>> shift
) != (byte
& 0x7f))
356 else if ((byte
& 0x7f) != 0)
359 if ((byte
& 0x80) == 0)
362 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
363 result
|= -((dwarf_vma
) 1 << shift
);
368 if (length_return
!= NULL
)
369 *length_return
= num_read
;
370 if (status_return
!= NULL
)
371 *status_return
= status
;
376 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
377 Checks to make sure that the read will not reach or pass END
378 and that VAL is big enough to hold AMOUNT bytes. */
379 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
382 unsigned int amount = (AMOUNT); \
383 if (sizeof (VAL) < amount) \
385 error (ngettext ("internal error: attempt to read %d byte " \
386 "of data in to %d sized variable", \
387 "internal error: attempt to read %d bytes " \
388 "of data in to %d sized variable", \
390 amount, (int) sizeof (VAL)); \
391 amount = sizeof (VAL); \
393 if (((PTR) + amount) >= (END)) \
396 amount = (END) - (PTR); \
400 if (amount == 0 || amount > 8) \
403 VAL = byte_get ((PTR), amount); \
407 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */
408 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
411 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
416 /* Like SAFE_BYTE_GET, but reads a signed value. */
417 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
420 unsigned int amount = (AMOUNT); \
421 if (((PTR) + amount) >= (END)) \
424 amount = (END) - (PTR); \
429 VAL = byte_get_signed ((PTR), amount); \
435 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */
436 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
439 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
444 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
447 if (((PTR) + 8) <= (END)) \
449 byte_get_64 ((PTR), (HIGH), (LOW)); \
453 * (LOW) = * (HIGH) = 0; \
458 typedef struct State_Machine_Registers
467 unsigned char op_index
;
468 unsigned char end_sequence
;
469 /* This variable hold the number of the last entry seen
470 in the File Table. */
471 unsigned int last_file_entry
;
474 static SMR state_machine_regs
;
477 reset_state_machine (int is_stmt
)
479 state_machine_regs
.address
= 0;
480 state_machine_regs
.view
= 0;
481 state_machine_regs
.op_index
= 0;
482 state_machine_regs
.file
= 1;
483 state_machine_regs
.line
= 1;
484 state_machine_regs
.column
= 0;
485 state_machine_regs
.is_stmt
= is_stmt
;
486 state_machine_regs
.basic_block
= 0;
487 state_machine_regs
.end_sequence
= 0;
488 state_machine_regs
.last_file_entry
= 0;
491 /* Handled an extend line op.
492 Returns the number of bytes read. */
495 process_extended_line_op (unsigned char * data
,
499 unsigned char op_code
;
500 size_t len
, header_len
;
502 unsigned char *orig_data
= data
;
505 READ_ULEB (len
, data
, end
);
506 header_len
= data
- orig_data
;
508 if (len
== 0 || data
== end
|| len
> (size_t) (end
- data
))
510 warn (_("Badly formed extended line op encountered!\n"));
516 printf (_(" Extended opcode %d: "), op_code
);
520 case DW_LNE_end_sequence
:
521 printf (_("End of Sequence\n\n"));
522 reset_state_machine (is_stmt
);
525 case DW_LNE_set_address
:
526 /* PR 17512: file: 002-100480-0.004. */
529 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
530 (unsigned long) len
- 1);
534 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
535 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
536 state_machine_regs
.address
= adr
;
537 state_machine_regs
.view
= 0;
538 state_machine_regs
.op_index
= 0;
541 case DW_LNE_define_file
:
542 printf (_("define new File Table entry\n"));
543 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
544 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
550 l
= strnlen ((char *) data
, end
- data
);
552 READ_ULEB (val
, data
, end
);
553 printf ("%s\t", dwarf_vmatoa ("u", val
));
554 READ_ULEB (val
, data
, end
);
555 printf ("%s\t", dwarf_vmatoa ("u", val
));
556 READ_ULEB (val
, data
, end
);
557 printf ("%s\t", dwarf_vmatoa ("u", val
));
558 printf ("%.*s\n\n", (int) l
, name
);
561 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
== end
)
562 warn (_("DW_LNE_define_file: Bad opcode length\n"));
565 case DW_LNE_set_discriminator
:
566 READ_ULEB (val
, data
, end
);
567 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val
));
571 case DW_LNE_HP_negate_is_UV_update
:
572 printf ("DW_LNE_HP_negate_is_UV_update\n");
574 case DW_LNE_HP_push_context
:
575 printf ("DW_LNE_HP_push_context\n");
577 case DW_LNE_HP_pop_context
:
578 printf ("DW_LNE_HP_pop_context\n");
580 case DW_LNE_HP_set_file_line_column
:
581 printf ("DW_LNE_HP_set_file_line_column\n");
583 case DW_LNE_HP_set_routine_name
:
584 printf ("DW_LNE_HP_set_routine_name\n");
586 case DW_LNE_HP_set_sequence
:
587 printf ("DW_LNE_HP_set_sequence\n");
589 case DW_LNE_HP_negate_post_semantics
:
590 printf ("DW_LNE_HP_negate_post_semantics\n");
592 case DW_LNE_HP_negate_function_exit
:
593 printf ("DW_LNE_HP_negate_function_exit\n");
595 case DW_LNE_HP_negate_front_end_logical
:
596 printf ("DW_LNE_HP_negate_front_end_logical\n");
598 case DW_LNE_HP_define_proc
:
599 printf ("DW_LNE_HP_define_proc\n");
601 case DW_LNE_HP_source_file_correlation
:
603 unsigned char *edata
= data
+ len
- 1;
605 printf ("DW_LNE_HP_source_file_correlation\n");
611 READ_ULEB (opc
, data
, edata
);
615 case DW_LNE_HP_SFC_formfeed
:
616 printf (" DW_LNE_HP_SFC_formfeed\n");
618 case DW_LNE_HP_SFC_set_listing_line
:
619 READ_ULEB (val
, data
, edata
);
620 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
621 dwarf_vmatoa ("u", val
));
623 case DW_LNE_HP_SFC_associate
:
624 printf (" DW_LNE_HP_SFC_associate ");
625 READ_ULEB (val
, data
, edata
);
626 printf ("(%s", dwarf_vmatoa ("u", val
));
627 READ_ULEB (val
, data
, edata
);
628 printf (",%s", dwarf_vmatoa ("u", val
));
629 READ_ULEB (val
, data
, edata
);
630 printf (",%s)\n", dwarf_vmatoa ("u", val
));
633 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
643 unsigned int rlen
= len
- 1;
645 if (op_code
>= DW_LNE_lo_user
646 /* The test against DW_LNW_hi_user is redundant due to
647 the limited range of the unsigned char data type used
649 /*&& op_code <= DW_LNE_hi_user*/)
650 printf (_("user defined: "));
652 printf (_("UNKNOWN: "));
653 printf (_("length %d ["), rlen
);
655 printf (" %02x", *data
++);
661 return len
+ header_len
;
664 static const unsigned char *
665 fetch_indirect_string (dwarf_vma offset
)
667 struct dwarf_section
*section
= &debug_displays
[str
].section
;
668 const unsigned char * ret
;
670 if (section
->start
== NULL
)
671 return (const unsigned char *) _("<no .debug_str section>");
673 if (offset
>= section
->size
)
675 warn (_("DW_FORM_strp offset too big: %s\n"),
676 dwarf_vmatoa ("x", offset
));
677 return (const unsigned char *) _("<offset is too big>");
680 ret
= section
->start
+ offset
;
681 /* Unfortunately we cannot rely upon the .debug_str section ending with a
682 NUL byte. Since our caller is expecting to receive a well formed C
683 string we test for the lack of a terminating byte here. */
684 if (strnlen ((const char *) ret
, section
->size
- offset
)
685 == section
->size
- offset
)
686 ret
= (const unsigned char *)
687 _("<no NUL byte at end of .debug_str section>");
692 static const unsigned char *
693 fetch_indirect_line_string (dwarf_vma offset
)
695 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
696 const unsigned char * ret
;
698 if (section
->start
== NULL
)
699 return (const unsigned char *) _("<no .debug_line_str section>");
701 if (offset
>= section
->size
)
703 warn (_("DW_FORM_line_strp offset too big: %s\n"),
704 dwarf_vmatoa ("x", offset
));
705 return (const unsigned char *) _("<offset is too big>");
708 ret
= section
->start
+ offset
;
709 /* Unfortunately we cannot rely upon the .debug_line_str section ending
710 with a NUL byte. Since our caller is expecting to receive a well formed
711 C string we test for the lack of a terminating byte here. */
712 if (strnlen ((const char *) ret
, section
->size
- offset
)
713 == section
->size
- offset
)
714 ret
= (const unsigned char *)
715 _("<no NUL byte at end of .debug_line_str section>");
721 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
722 dwarf_vma offset_size
, bfd_boolean dwo
)
724 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
725 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
726 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
727 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
728 dwarf_vma index_offset
= idx
* offset_size
;
729 dwarf_vma str_offset
;
732 if (index_section
->start
== NULL
)
733 return (dwo
? _("<no .debug_str_offsets.dwo section>")
734 : _("<no .debug_str_offsets section>"));
736 if (this_set
!= NULL
)
737 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
738 if (index_offset
>= index_section
->size
)
740 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
741 dwarf_vmatoa ("x", index_offset
));
742 return _("<index offset is too big>");
745 if (str_section
->start
== NULL
)
746 return (dwo
? _("<no .debug_str.dwo section>")
747 : _("<no .debug_str section>"));
749 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
750 str_offset
-= str_section
->address
;
751 if (str_offset
>= str_section
->size
)
753 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
754 dwarf_vmatoa ("x", str_offset
));
755 return _("<indirect index offset is too big>");
758 ret
= (const char *) str_section
->start
+ str_offset
;
759 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
760 Since our caller is expecting to receive a well formed C string we test
761 for the lack of a terminating byte here. */
762 if (strnlen (ret
, str_section
->size
- str_offset
)
763 == str_section
->size
- str_offset
)
764 ret
= (const char *) _("<no NUL byte at end of section>");
770 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
772 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
774 if (section
->start
== NULL
)
775 return (_("<no .debug_addr section>"));
777 if (offset
+ bytes
> section
->size
)
779 warn (_("Offset into section %s too big: %s\n"),
780 section
->name
, dwarf_vmatoa ("x", offset
));
781 return "<offset too big>";
784 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
788 /* FIXME: There are better and more efficient ways to handle
789 these structures. For now though, I just want something that
790 is simple to implement. */
791 typedef struct abbrev_attr
793 unsigned long attribute
;
795 bfd_signed_vma implicit_const
;
796 struct abbrev_attr
*next
;
800 typedef struct abbrev_entry
805 struct abbrev_attr
*first_attr
;
806 struct abbrev_attr
*last_attr
;
807 struct abbrev_entry
*next
;
811 static abbrev_entry
*first_abbrev
= NULL
;
812 static abbrev_entry
*last_abbrev
= NULL
;
819 for (abbrv
= first_abbrev
; abbrv
;)
821 abbrev_entry
*next_abbrev
= abbrv
->next
;
824 for (attr
= abbrv
->first_attr
; attr
;)
826 abbrev_attr
*next_attr
= attr
->next
;
836 last_abbrev
= first_abbrev
= NULL
;
840 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
844 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
849 entry
->entry
= number
;
851 entry
->children
= children
;
852 entry
->first_attr
= NULL
;
853 entry
->last_attr
= NULL
;
856 if (first_abbrev
== NULL
)
857 first_abbrev
= entry
;
859 last_abbrev
->next
= entry
;
865 add_abbrev_attr (unsigned long attribute
, unsigned long form
,
866 bfd_signed_vma implicit_const
)
870 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
875 attr
->attribute
= attribute
;
877 attr
->implicit_const
= implicit_const
;
880 if (last_abbrev
->first_attr
== NULL
)
881 last_abbrev
->first_attr
= attr
;
883 last_abbrev
->last_attr
->next
= attr
;
885 last_abbrev
->last_attr
= attr
;
888 /* Processes the (partial) contents of a .debug_abbrev section.
889 Returns NULL if the end of the section was encountered.
890 Returns the address after the last byte read if the end of
891 an abbreviation set was found. */
893 static unsigned char *
894 process_abbrev_section (unsigned char *start
, unsigned char *end
)
896 if (first_abbrev
!= NULL
)
903 unsigned long attribute
;
906 READ_ULEB (entry
, start
, end
);
908 /* A single zero is supposed to end the section according
909 to the standard. If there's more, then signal that to
916 READ_ULEB (tag
, start
, end
);
922 add_abbrev (entry
, tag
, children
);
927 /* Initialize it due to a false compiler warning. */
928 bfd_signed_vma implicit_const
= -1;
930 READ_ULEB (attribute
, start
, end
);
934 READ_ULEB (form
, start
, end
);
938 if (form
== DW_FORM_implicit_const
)
940 READ_SLEB (implicit_const
, start
, end
);
945 add_abbrev_attr (attribute
, form
, implicit_const
);
947 while (attribute
!= 0);
950 /* Report the missing single zero which ends the section. */
951 error (_(".debug_abbrev section not zero terminated\n"));
957 get_TAG_name (unsigned long tag
)
959 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
963 static char buffer
[100];
965 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
966 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
968 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
976 get_FORM_name (unsigned long form
)
981 return "DW_FORM value: 0";
983 name
= get_DW_FORM_name (form
);
986 static char buffer
[100];
988 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
996 get_IDX_name (unsigned long idx
)
998 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1002 static char buffer
[100];
1004 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1011 static unsigned char *
1012 display_block (unsigned char *data
,
1014 const unsigned char * const end
, char delimiter
)
1018 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1020 return (unsigned char *) end
;
1022 maxlen
= (dwarf_vma
) (end
- data
);
1023 length
= length
> maxlen
? maxlen
: length
;
1026 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1032 decode_location_expression (unsigned char * data
,
1033 unsigned int pointer_size
,
1034 unsigned int offset_size
,
1037 dwarf_vma cu_offset
,
1038 struct dwarf_section
* section
)
1042 dwarf_signed_vma svalue
;
1043 unsigned char *end
= data
+ length
;
1044 int need_frame_base
= 0;
1053 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1054 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1057 printf ("DW_OP_deref");
1060 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1061 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1064 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1065 printf ("DW_OP_const1s: %ld", (long) svalue
);
1068 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1069 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1072 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1073 printf ("DW_OP_const2s: %ld", (long) svalue
);
1076 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1077 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1080 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1081 printf ("DW_OP_const4s: %ld", (long) svalue
);
1084 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1085 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1086 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1087 printf ("%lu", (unsigned long) uvalue
);
1090 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1091 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1092 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1093 printf ("%ld", (long) svalue
);
1096 READ_ULEB (uvalue
, data
, end
);
1097 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue
));
1100 READ_SLEB (svalue
, data
, end
);
1101 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue
));
1104 printf ("DW_OP_dup");
1107 printf ("DW_OP_drop");
1110 printf ("DW_OP_over");
1113 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1114 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1117 printf ("DW_OP_swap");
1120 printf ("DW_OP_rot");
1123 printf ("DW_OP_xderef");
1126 printf ("DW_OP_abs");
1129 printf ("DW_OP_and");
1132 printf ("DW_OP_div");
1135 printf ("DW_OP_minus");
1138 printf ("DW_OP_mod");
1141 printf ("DW_OP_mul");
1144 printf ("DW_OP_neg");
1147 printf ("DW_OP_not");
1150 printf ("DW_OP_or");
1153 printf ("DW_OP_plus");
1155 case DW_OP_plus_uconst
:
1156 READ_ULEB (uvalue
, data
, end
);
1157 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue
));
1160 printf ("DW_OP_shl");
1163 printf ("DW_OP_shr");
1166 printf ("DW_OP_shra");
1169 printf ("DW_OP_xor");
1172 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1173 printf ("DW_OP_bra: %ld", (long) svalue
);
1176 printf ("DW_OP_eq");
1179 printf ("DW_OP_ge");
1182 printf ("DW_OP_gt");
1185 printf ("DW_OP_le");
1188 printf ("DW_OP_lt");
1191 printf ("DW_OP_ne");
1194 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1195 printf ("DW_OP_skip: %ld", (long) svalue
);
1230 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1265 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1266 regname (op
- DW_OP_reg0
, 1));
1301 READ_SLEB (svalue
, data
, end
);
1302 printf ("DW_OP_breg%d (%s): %s", op
- DW_OP_breg0
,
1303 regname (op
- DW_OP_breg0
, 1), dwarf_vmatoa ("d", svalue
));
1307 READ_ULEB (uvalue
, data
, end
);
1308 printf ("DW_OP_regx: %s (%s)",
1309 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1312 need_frame_base
= 1;
1313 READ_SLEB (svalue
, data
, end
);
1314 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue
));
1317 READ_ULEB (uvalue
, data
, end
);
1318 READ_SLEB (svalue
, data
, end
);
1319 printf ("DW_OP_bregx: %s (%s) %s",
1320 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1321 dwarf_vmatoa ("d", svalue
));
1324 READ_ULEB (uvalue
, data
, end
);
1325 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue
));
1327 case DW_OP_deref_size
:
1328 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1329 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1331 case DW_OP_xderef_size
:
1332 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1333 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1336 printf ("DW_OP_nop");
1339 /* DWARF 3 extensions. */
1340 case DW_OP_push_object_address
:
1341 printf ("DW_OP_push_object_address");
1344 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1345 this ought to be an 8-byte wide computation. */
1346 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1347 printf ("DW_OP_call2: <0x%s>",
1348 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1351 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1352 this ought to be an 8-byte wide computation. */
1353 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1354 printf ("DW_OP_call4: <0x%s>",
1355 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1357 case DW_OP_call_ref
:
1358 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1359 this ought to be an 8-byte wide computation. */
1360 if (dwarf_version
== -1)
1362 printf (_("(DW_OP_call_ref in frame info)"));
1363 /* No way to tell where the next op is, so just bail. */
1364 return need_frame_base
;
1366 if (dwarf_version
== 2)
1368 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1372 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1374 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1376 case DW_OP_form_tls_address
:
1377 printf ("DW_OP_form_tls_address");
1379 case DW_OP_call_frame_cfa
:
1380 printf ("DW_OP_call_frame_cfa");
1382 case DW_OP_bit_piece
:
1383 printf ("DW_OP_bit_piece: ");
1384 READ_ULEB (uvalue
, data
, end
);
1385 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue
));
1386 READ_ULEB (uvalue
, data
, end
);
1387 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue
));
1390 /* DWARF 4 extensions. */
1391 case DW_OP_stack_value
:
1392 printf ("DW_OP_stack_value");
1395 case DW_OP_implicit_value
:
1396 printf ("DW_OP_implicit_value");
1397 READ_ULEB (uvalue
, data
, end
);
1398 data
= display_block (data
, uvalue
, end
, ' ');
1401 /* GNU extensions. */
1402 case DW_OP_GNU_push_tls_address
:
1403 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1405 case DW_OP_GNU_uninit
:
1406 printf ("DW_OP_GNU_uninit");
1407 /* FIXME: Is there data associated with this OP ? */
1409 case DW_OP_GNU_encoded_addr
:
1416 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1418 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1419 print_dwarf_vma (addr
, pointer_size
);
1422 case DW_OP_implicit_pointer
:
1423 case DW_OP_GNU_implicit_pointer
:
1424 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1425 this ought to be an 8-byte wide computation. */
1426 if (dwarf_version
== -1)
1428 printf (_("(%s in frame info)"),
1429 (op
== DW_OP_implicit_pointer
1430 ? "DW_OP_implicit_pointer"
1431 : "DW_OP_GNU_implicit_pointer"));
1432 /* No way to tell where the next op is, so just bail. */
1433 return need_frame_base
;
1435 if (dwarf_version
== 2)
1437 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1441 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1443 READ_SLEB (svalue
, data
, end
);
1444 printf ("%s: <0x%s> %s",
1445 (op
== DW_OP_implicit_pointer
1446 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1447 dwarf_vmatoa ("x", uvalue
),
1448 dwarf_vmatoa ("d", svalue
));
1450 case DW_OP_entry_value
:
1451 case DW_OP_GNU_entry_value
:
1452 READ_ULEB (uvalue
, data
, end
);
1453 /* PR 17531: file: 0cc9cd00. */
1454 if (uvalue
> (dwarf_vma
) (end
- data
))
1455 uvalue
= end
- data
;
1456 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1457 : "DW_OP_GNU_entry_value"));
1458 if (decode_location_expression (data
, pointer_size
, offset_size
,
1459 dwarf_version
, uvalue
,
1460 cu_offset
, section
))
1461 need_frame_base
= 1;
1467 case DW_OP_const_type
:
1468 case DW_OP_GNU_const_type
:
1469 READ_ULEB (uvalue
, data
, end
);
1470 printf ("%s: <0x%s> ",
1471 (op
== DW_OP_const_type
? "DW_OP_const_type"
1472 : "DW_OP_GNU_const_type"),
1473 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1474 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1475 data
= display_block (data
, uvalue
, end
, ' ');
1477 case DW_OP_regval_type
:
1478 case DW_OP_GNU_regval_type
:
1479 READ_ULEB (uvalue
, data
, end
);
1480 printf ("%s: %s (%s)",
1481 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1482 : "DW_OP_GNU_regval_type"),
1483 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1484 READ_ULEB (uvalue
, data
, end
);
1485 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1487 case DW_OP_deref_type
:
1488 case DW_OP_GNU_deref_type
:
1489 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1491 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1492 : "DW_OP_GNU_deref_type"),
1494 READ_ULEB (uvalue
, data
, end
);
1495 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1498 case DW_OP_GNU_convert
:
1499 READ_ULEB (uvalue
, data
, end
);
1500 printf ("%s <0x%s>",
1501 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1502 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1504 case DW_OP_reinterpret
:
1505 case DW_OP_GNU_reinterpret
:
1506 READ_ULEB (uvalue
, data
, end
);
1507 printf ("%s <0x%s>",
1508 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1509 : "DW_OP_GNU_reinterpret"),
1510 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1512 case DW_OP_GNU_parameter_ref
:
1513 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1514 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1515 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1517 case DW_OP_GNU_addr_index
:
1518 READ_ULEB (uvalue
, data
, end
);
1519 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1521 case DW_OP_GNU_const_index
:
1522 READ_ULEB (uvalue
, data
, end
);
1523 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1525 case DW_OP_GNU_variable_value
:
1526 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1527 this ought to be an 8-byte wide computation. */
1528 if (dwarf_version
== -1)
1530 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1531 /* No way to tell where the next op is, so just bail. */
1532 return need_frame_base
;
1534 if (dwarf_version
== 2)
1536 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1540 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1542 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1545 /* HP extensions. */
1546 case DW_OP_HP_is_value
:
1547 printf ("DW_OP_HP_is_value");
1548 /* FIXME: Is there data associated with this OP ? */
1550 case DW_OP_HP_fltconst4
:
1551 printf ("DW_OP_HP_fltconst4");
1552 /* FIXME: Is there data associated with this OP ? */
1554 case DW_OP_HP_fltconst8
:
1555 printf ("DW_OP_HP_fltconst8");
1556 /* FIXME: Is there data associated with this OP ? */
1558 case DW_OP_HP_mod_range
:
1559 printf ("DW_OP_HP_mod_range");
1560 /* FIXME: Is there data associated with this OP ? */
1562 case DW_OP_HP_unmod_range
:
1563 printf ("DW_OP_HP_unmod_range");
1564 /* FIXME: Is there data associated with this OP ? */
1567 printf ("DW_OP_HP_tls");
1568 /* FIXME: Is there data associated with this OP ? */
1571 /* PGI (STMicroelectronics) extensions. */
1572 case DW_OP_PGI_omp_thread_num
:
1573 /* Pushes the thread number for the current thread as it would be
1574 returned by the standard OpenMP library function:
1575 omp_get_thread_num(). The "current thread" is the thread for
1576 which the expression is being evaluated. */
1577 printf ("DW_OP_PGI_omp_thread_num");
1581 if (op
>= DW_OP_lo_user
1582 && op
<= DW_OP_hi_user
)
1583 printf (_("(User defined location op 0x%x)"), op
);
1585 printf (_("(Unknown location op 0x%x)"), op
);
1586 /* No way to tell where the next op is, so just bail. */
1587 return need_frame_base
;
1590 /* Separate the ops. */
1595 return need_frame_base
;
1598 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1599 This is used for DWARF package files. */
1601 static struct cu_tu_set
*
1602 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1604 struct cu_tu_set
*p
;
1606 unsigned int dw_sect
;
1612 dw_sect
= DW_SECT_TYPES
;
1618 dw_sect
= DW_SECT_INFO
;
1622 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1630 /* Add INC to HIGH_BITS:LOW_BITS. */
1632 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1634 dwarf_vma tmp
= * low_bits
;
1638 /* FIXME: There is probably a better way of handling this:
1640 We need to cope with dwarf_vma being a 32-bit or 64-bit
1641 type. Plus regardless of its size LOW_BITS is meant to
1642 only hold 32-bits, so if there is overflow or wrap around
1643 we must propagate into HIGH_BITS. */
1644 if (tmp
< * low_bits
)
1648 else if (sizeof (tmp
) > 8
1659 fetch_alt_indirect_string (dwarf_vma offset
)
1663 if (! do_follow_links
)
1666 if (first_separate_info
== NULL
)
1667 return _("<no links available>");
1669 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1671 struct dwarf_section
* section
;
1674 if (! load_debug_section (separate_debug_str
, i
->handle
))
1677 section
= &debug_displays
[separate_debug_str
].section
;
1679 if (section
->start
== NULL
)
1682 if (offset
>= section
->size
)
1685 ret
= (const char *) (section
->start
+ offset
);
1686 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1687 NUL byte. Since our caller is expecting to receive a well formed C
1688 string we test for the lack of a terminating byte here. */
1689 if (strnlen ((const char *) ret
, section
->size
- offset
)
1690 == section
->size
- offset
)
1691 return _("<no NUL byte at end of alt .debug_str section>");
1696 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1697 dwarf_vmatoa ("x", offset
));
1698 return _("<offset is too big>");
1702 get_AT_name (unsigned long attribute
)
1707 return "DW_AT value: 0";
1709 /* One value is shared by the MIPS and HP extensions: */
1710 if (attribute
== DW_AT_MIPS_fde
)
1711 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1713 name
= get_DW_AT_name (attribute
);
1717 static char buffer
[100];
1719 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1728 add_dwo_info (const char * field
, dwo_type type
)
1730 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1732 dwinfo
->type
= type
;
1733 dwinfo
->value
= field
;
1734 dwinfo
->next
= first_dwo_info
;
1735 first_dwo_info
= dwinfo
;
1739 add_dwo_name (const char * name
)
1741 add_dwo_info (name
, DWO_NAME
);
1745 add_dwo_dir (const char * dir
)
1747 add_dwo_info (dir
, DWO_DIR
);
1751 add_dwo_id (const char * id
)
1753 add_dwo_info (id
, DWO_ID
);
1757 free_dwo_info (void)
1762 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1764 next
= dwinfo
->next
;
1767 first_dwo_info
= NULL
;
1770 /* Ensure that START + UVALUE is less than END.
1771 Return an adjusted UVALUE if necessary to ensure this relationship. */
1773 static inline dwarf_vma
1774 check_uvalue (const unsigned char * start
,
1776 const unsigned char * end
)
1778 dwarf_vma max_uvalue
= end
- start
;
1780 /* See PR 17512: file: 008-103549-0.001:0.1.
1781 and PR 24829 for examples of where these tests are triggered. */
1782 if (uvalue
> max_uvalue
)
1784 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1785 uvalue
= max_uvalue
;
1791 static unsigned char *
1792 skip_attr_bytes (unsigned long form
,
1793 unsigned char * data
,
1794 unsigned const char * end
,
1795 dwarf_vma pointer_size
,
1796 dwarf_vma offset_size
,
1798 dwarf_vma
* value_return
)
1800 dwarf_signed_vma svalue
;
1801 dwarf_vma uvalue
= 0;
1807 case DW_FORM_ref_addr
:
1808 if (dwarf_version
== 2)
1809 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1810 else if (dwarf_version
== 3 || dwarf_version
== 4)
1811 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1817 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1821 case DW_FORM_line_strp
:
1822 case DW_FORM_sec_offset
:
1823 case DW_FORM_GNU_ref_alt
:
1824 case DW_FORM_GNU_strp_alt
:
1825 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1828 case DW_FORM_flag_present
:
1835 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1840 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1845 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1849 READ_SLEB (svalue
, data
, end
);
1853 case DW_FORM_ref_udata
:
1855 case DW_FORM_GNU_str_index
:
1856 case DW_FORM_GNU_addr_index
:
1857 READ_ULEB (uvalue
, data
, end
);
1865 case DW_FORM_data16
:
1869 case DW_FORM_string
:
1870 data
+= strnlen ((char *) data
, end
- data
) + 1;
1874 case DW_FORM_exprloc
:
1875 READ_ULEB (uvalue
, data
, end
);
1878 case DW_FORM_block1
:
1879 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1883 case DW_FORM_block2
:
1884 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1888 case DW_FORM_block4
:
1889 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1893 case DW_FORM_ref_sig8
:
1897 case DW_FORM_indirect
:
1898 /* FIXME: Handle this form. */
1903 * value_return
= uvalue
;
1905 data
= (unsigned char *) end
;
1909 /* Return IS_SIGNED set to TRUE if the type at
1910 DATA can be determined to be a signed type. */
1913 get_type_signedness (unsigned char * start
,
1914 unsigned char * data
,
1915 unsigned const char * end
,
1916 dwarf_vma pointer_size
,
1917 dwarf_vma offset_size
,
1919 bfd_boolean
* is_signed
,
1920 bfd_boolean is_nested
)
1922 unsigned long abbrev_number
;
1923 abbrev_entry
* entry
;
1926 * is_signed
= FALSE
;
1928 READ_ULEB (abbrev_number
, data
, end
);
1930 for (entry
= first_abbrev
;
1931 entry
!= NULL
&& entry
->entry
!= abbrev_number
;
1932 entry
= entry
->next
)
1936 /* FIXME: Issue a warning ? */
1939 for (attr
= entry
->first_attr
;
1940 attr
!= NULL
&& attr
->attribute
;
1943 dwarf_vma uvalue
= 0;
1945 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
1946 offset_size
, dwarf_version
, & uvalue
);
1950 switch (attr
->attribute
)
1952 #if 0 /* FIXME: It would be nice to print the name of the type,
1953 but this would mean updating a lot of binutils tests. */
1955 if (attr
->form
== DW_FORM_strp
)
1956 printf ("%s", fetch_indirect_string (uvalue
));
1963 /* FIXME: Warn - or is this expected ?
1964 NB/ We need to avoid infinite recursion. */
1967 if (uvalue
>= (size_t) (end
- start
))
1969 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
1970 offset_size
, dwarf_version
, is_signed
, TRUE
);
1973 case DW_AT_encoding
:
1974 /* Determine signness. */
1977 case DW_ATE_address
:
1978 /* FIXME - some architectures have signed addresses. */
1979 case DW_ATE_boolean
:
1980 case DW_ATE_unsigned
:
1981 case DW_ATE_unsigned_char
:
1982 case DW_ATE_unsigned_fixed
:
1983 * is_signed
= FALSE
;
1987 case DW_ATE_complex_float
:
1990 case DW_ATE_signed_char
:
1991 case DW_ATE_imaginary_float
:
1992 case DW_ATE_decimal_float
:
1993 case DW_ATE_signed_fixed
:
2003 read_and_print_leb128 (unsigned char * data
,
2004 unsigned int * bytes_read
,
2005 unsigned const char * end
,
2006 bfd_boolean is_signed
)
2009 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2011 report_leb_status (status
, __FILE__
, __LINE__
);
2013 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2017 display_discr_list (unsigned long form
,
2019 unsigned char * data
,
2020 unsigned const char * end
,
2025 printf ("[default]");
2032 case DW_FORM_block1
:
2033 case DW_FORM_block2
:
2034 case DW_FORM_block4
:
2035 /* Move data pointer back to the start of the byte array. */
2039 printf ("<corrupt>\n");
2040 warn (_("corrupt discr_list - not using a block form\n"));
2046 printf ("<corrupt>\n");
2047 warn (_("corrupt discr_list - block not long enough\n"));
2051 bfd_boolean is_signed
=
2052 (level
> 0 && level
<= MAX_CU_NESTING
)
2053 ? level_type_signed
[level
- 1] : FALSE
;
2058 unsigned char discriminant
;
2059 unsigned int bytes_read
;
2061 SAFE_BYTE_GET (discriminant
, data
, 1, end
);
2065 assert (uvalue
> 0);
2066 switch (discriminant
)
2070 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2071 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2072 uvalue
-= bytes_read
;
2078 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2079 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2080 uvalue
-= bytes_read
;
2084 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2085 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2086 uvalue
-= bytes_read
;
2091 printf ("<corrupt>\n");
2092 warn (_("corrupt discr_list - unrecognised discriminant byte %#x\n"),
2102 printf (")(signed)");
2104 printf (")(unsigned)");
2107 static unsigned char *
2108 read_and_display_attr_value (unsigned long attribute
,
2110 dwarf_signed_vma implicit_const
,
2111 unsigned char * start
,
2112 unsigned char * data
,
2113 unsigned char * end
,
2114 dwarf_vma cu_offset
,
2115 dwarf_vma pointer_size
,
2116 dwarf_vma offset_size
,
2118 debug_info
* debug_info_p
,
2120 struct dwarf_section
* section
,
2121 struct cu_tu_set
* this_set
,
2125 dwarf_signed_vma svalue
;
2126 dwarf_vma uvalue
= 0;
2127 unsigned char * block_start
= NULL
;
2128 unsigned char * orig_data
= data
;
2130 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2132 warn (_("Corrupt attribute\n"));
2141 case DW_FORM_ref_addr
:
2142 if (dwarf_version
== 2)
2143 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2144 else if (dwarf_version
== 3 || dwarf_version
== 4)
2145 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2147 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
2152 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2156 case DW_FORM_line_strp
:
2157 case DW_FORM_sec_offset
:
2158 case DW_FORM_GNU_ref_alt
:
2159 case DW_FORM_GNU_strp_alt
:
2160 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2163 case DW_FORM_flag_present
:
2170 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2175 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2180 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2184 READ_SLEB (svalue
, data
, end
);
2188 case DW_FORM_GNU_str_index
:
2189 case DW_FORM_ref_udata
:
2191 case DW_FORM_GNU_addr_index
:
2192 READ_ULEB (uvalue
, data
, end
);
2195 case DW_FORM_indirect
:
2196 READ_ULEB (form
, data
, end
);
2198 printf ("%c%s", delimiter
, get_FORM_name (form
));
2199 if (form
== DW_FORM_implicit_const
)
2200 READ_SLEB (implicit_const
, data
, end
);
2201 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2203 cu_offset
, pointer_size
,
2204 offset_size
, dwarf_version
,
2205 debug_info_p
, do_loc
,
2206 section
, this_set
, delimiter
, level
);
2211 case DW_FORM_ref_addr
:
2213 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2216 case DW_FORM_GNU_ref_alt
:
2218 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
2219 /* FIXME: Follow the reference... */
2225 case DW_FORM_ref_udata
:
2227 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2232 case DW_FORM_sec_offset
:
2234 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2237 case DW_FORM_flag_present
:
2244 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2247 case DW_FORM_implicit_const
:
2249 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2256 dwarf_vma high_bits
;
2260 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2262 if (form
== DW_FORM_ref8
)
2263 add64 (& high_bits
, & utmp
, cu_offset
);
2264 printf ("%c0x%s", delimiter
,
2265 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
2268 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2269 && num_debug_info_entries
== 0)
2271 if (sizeof (uvalue
) == 8)
2272 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
2274 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
2280 case DW_FORM_data16
:
2283 dwarf_vma left_high_bits
, left_low_bits
;
2284 dwarf_vma right_high_bits
, right_low_bits
;
2286 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
2287 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
2288 if (byte_get
== byte_get_little_endian
)
2291 left_high_bits
^= right_high_bits
;
2292 right_high_bits
^= left_high_bits
;
2293 left_high_bits
^= right_high_bits
;
2294 left_low_bits
^= right_low_bits
;
2295 right_low_bits
^= left_low_bits
;
2296 left_low_bits
^= right_low_bits
;
2298 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
2299 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
2300 left_high_bits
, left_low_bits
, right_high_bits
,
2306 case DW_FORM_string
:
2308 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2309 data
+= strnlen ((char *) data
, end
- data
) + 1;
2313 case DW_FORM_exprloc
:
2314 READ_ULEB (uvalue
, data
, end
);
2317 if (block_start
>= end
)
2319 warn (_("Block ends prematurely\n"));
2324 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2327 data
= block_start
+ uvalue
;
2329 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2332 case DW_FORM_block1
:
2333 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2336 case DW_FORM_block2
:
2337 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2340 case DW_FORM_block4
:
2341 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2346 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2347 dwarf_vmatoa ("x", uvalue
),
2348 fetch_indirect_string (uvalue
));
2351 case DW_FORM_line_strp
:
2353 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2354 dwarf_vmatoa ("x", uvalue
),
2355 fetch_indirect_line_string (uvalue
));
2358 case DW_FORM_GNU_str_index
:
2361 const char * suffix
= strrchr (section
->name
, '.');
2362 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
2364 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2365 dwarf_vmatoa ("x", uvalue
),
2366 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2370 case DW_FORM_GNU_strp_alt
:
2373 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2374 dwarf_vmatoa ("x", uvalue
),
2375 fetch_alt_indirect_string (uvalue
));
2379 case DW_FORM_indirect
:
2380 /* Handled above. */
2383 case DW_FORM_ref_sig8
:
2386 dwarf_vma high_bits
;
2389 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2390 printf ("%csignature: 0x%s", delimiter
,
2391 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2396 case DW_FORM_GNU_addr_index
:
2398 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2399 dwarf_vmatoa ("x", uvalue
),
2400 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2404 warn (_("Unrecognized form: %lu\n"), form
);
2408 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2409 && num_debug_info_entries
== 0
2410 && debug_info_p
!= NULL
)
2414 case DW_AT_frame_base
:
2415 have_frame_base
= 1;
2417 case DW_AT_location
:
2418 case DW_AT_GNU_locviews
:
2419 case DW_AT_string_length
:
2420 case DW_AT_return_addr
:
2421 case DW_AT_data_member_location
:
2422 case DW_AT_vtable_elem_location
:
2424 case DW_AT_static_link
:
2425 case DW_AT_use_location
:
2426 case DW_AT_call_value
:
2427 case DW_AT_GNU_call_site_value
:
2428 case DW_AT_call_data_value
:
2429 case DW_AT_GNU_call_site_data_value
:
2430 case DW_AT_call_target
:
2431 case DW_AT_GNU_call_site_target
:
2432 case DW_AT_call_target_clobbered
:
2433 case DW_AT_GNU_call_site_target_clobbered
:
2434 if ((dwarf_version
< 4
2435 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2436 || form
== DW_FORM_sec_offset
)
2438 /* Process location list. */
2439 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2440 unsigned int num
= debug_info_p
->num_loc_offsets
;
2442 if (lmax
== 0 || num
>= lmax
)
2445 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2446 xcrealloc (debug_info_p
->loc_offsets
,
2447 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2448 debug_info_p
->loc_views
= (dwarf_vma
*)
2449 xcrealloc (debug_info_p
->loc_views
,
2450 lmax
, sizeof (*debug_info_p
->loc_views
));
2451 debug_info_p
->have_frame_base
= (int *)
2452 xcrealloc (debug_info_p
->have_frame_base
,
2453 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2454 debug_info_p
->max_loc_offsets
= lmax
;
2456 if (this_set
!= NULL
)
2457 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2458 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2459 if (attribute
!= DW_AT_GNU_locviews
)
2461 /* Corrupt DWARF info can produce more offsets than views.
2462 See PR 23062 for an example. */
2463 if (debug_info_p
->num_loc_offsets
2464 > debug_info_p
->num_loc_views
)
2465 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2468 debug_info_p
->loc_offsets
[num
] = uvalue
;
2469 debug_info_p
->num_loc_offsets
++;
2474 assert (debug_info_p
->num_loc_views
<= num
);
2475 num
= debug_info_p
->num_loc_views
;
2476 if (num
> debug_info_p
->num_loc_offsets
)
2477 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2480 debug_info_p
->loc_views
[num
] = uvalue
;
2481 debug_info_p
->num_loc_views
++;
2488 if (need_base_address
)
2489 debug_info_p
->base_address
= uvalue
;
2492 case DW_AT_GNU_addr_base
:
2493 debug_info_p
->addr_base
= uvalue
;
2496 case DW_AT_GNU_ranges_base
:
2497 debug_info_p
->ranges_base
= uvalue
;
2501 if ((dwarf_version
< 4
2502 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2503 || form
== DW_FORM_sec_offset
)
2505 /* Process range list. */
2506 unsigned int lmax
= debug_info_p
->max_range_lists
;
2507 unsigned int num
= debug_info_p
->num_range_lists
;
2509 if (lmax
== 0 || num
>= lmax
)
2512 debug_info_p
->range_lists
= (dwarf_vma
*)
2513 xcrealloc (debug_info_p
->range_lists
,
2514 lmax
, sizeof (*debug_info_p
->range_lists
));
2515 debug_info_p
->max_range_lists
= lmax
;
2517 debug_info_p
->range_lists
[num
] = uvalue
;
2518 debug_info_p
->num_range_lists
++;
2522 case DW_AT_GNU_dwo_name
:
2523 case DW_AT_dwo_name
:
2528 add_dwo_name ((const char *) fetch_indirect_string (uvalue
));
2530 case DW_FORM_GNU_str_index
:
2531 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2533 case DW_FORM_string
:
2534 add_dwo_name ((const char *) orig_data
);
2537 warn (_("Unsupported form (%s) for attribute %s\n"),
2538 get_FORM_name (form
), get_AT_name (attribute
));
2543 case DW_AT_comp_dir
:
2544 /* FIXME: Also extract a build-id in a CU/TU. */
2549 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
));
2551 case DW_FORM_line_strp
:
2552 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
));
2554 case DW_FORM_GNU_str_index
:
2555 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2557 case DW_FORM_string
:
2558 add_dwo_dir ((const char *) orig_data
);
2561 warn (_("Unsupported form (%s) for attribute %s\n"),
2562 get_FORM_name (form
), get_AT_name (attribute
));
2567 case DW_AT_GNU_dwo_id
:
2572 /* FIXME: Record the length of the ID as well ? */
2573 add_dwo_id ((const char *) (data
- 8));
2576 warn (_("Unsupported form (%s) for attribute %s\n"),
2577 get_FORM_name (form
), get_AT_name (attribute
));
2587 if (do_loc
|| attribute
== 0)
2590 /* For some attributes we can display further information. */
2594 if (level
>= 0 && level
< MAX_CU_NESTING
2595 && uvalue
< (size_t) (end
- start
))
2597 bfd_boolean is_signed
= FALSE
;
2599 get_type_signedness (start
, start
+ uvalue
, end
, pointer_size
,
2600 offset_size
, dwarf_version
, & is_signed
, FALSE
);
2601 level_type_signed
[level
] = is_signed
;
2609 case DW_INL_not_inlined
:
2610 printf (_("(not inlined)"));
2612 case DW_INL_inlined
:
2613 printf (_("(inlined)"));
2615 case DW_INL_declared_not_inlined
:
2616 printf (_("(declared as inline but ignored)"));
2618 case DW_INL_declared_inlined
:
2619 printf (_("(declared as inline and inlined)"));
2622 printf (_(" (Unknown inline attribute value: %s)"),
2623 dwarf_vmatoa ("x", uvalue
));
2628 case DW_AT_language
:
2632 /* Ordered by the numeric value of these constants. */
2633 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2634 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2635 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2636 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2637 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2638 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2639 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2640 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2641 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2642 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2643 /* DWARF 2.1 values. */
2644 case DW_LANG_Java
: printf ("(Java)"); break;
2645 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2646 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2647 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2648 /* DWARF 3 values. */
2649 case DW_LANG_PLI
: printf ("(PLI)"); break;
2650 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2651 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2652 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2653 case DW_LANG_D
: printf ("(D)"); break;
2654 /* DWARF 4 values. */
2655 case DW_LANG_Python
: printf ("(Python)"); break;
2656 /* DWARF 5 values. */
2657 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
2658 case DW_LANG_Go
: printf ("(Go)"); break;
2659 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
2660 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
2661 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
2662 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2663 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
2664 case DW_LANG_Rust
: printf ("(Rust)"); break;
2665 case DW_LANG_C11
: printf ("(C11)"); break;
2666 case DW_LANG_Swift
: printf ("(Swift)"); break;
2667 case DW_LANG_Julia
: printf ("(Julia)"); break;
2668 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
2669 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2670 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2671 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2672 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
2673 /* MIPS extension. */
2674 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2675 /* UPC extension. */
2676 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2678 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2679 printf (_("(implementation defined: %s)"),
2680 dwarf_vmatoa ("x", uvalue
));
2682 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2687 case DW_AT_encoding
:
2691 case DW_ATE_void
: printf ("(void)"); break;
2692 case DW_ATE_address
: printf ("(machine address)"); break;
2693 case DW_ATE_boolean
: printf ("(boolean)"); break;
2694 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2695 case DW_ATE_float
: printf ("(float)"); break;
2696 case DW_ATE_signed
: printf ("(signed)"); break;
2697 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2698 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2699 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2700 /* DWARF 2.1 values: */
2701 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2702 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2703 /* DWARF 3 values: */
2704 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2705 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2706 case DW_ATE_edited
: printf ("(edited)"); break;
2707 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2708 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2709 /* DWARF 4 values: */
2710 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2711 /* DWARF 5 values: */
2712 case DW_ATE_UCS
: printf ("(UCS)"); break;
2713 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2715 /* HP extensions: */
2716 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2717 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2718 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2719 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2720 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2721 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2722 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2725 if (uvalue
>= DW_ATE_lo_user
2726 && uvalue
<= DW_ATE_hi_user
)
2727 printf (_("(user defined type)"));
2729 printf (_("(unknown type)"));
2734 case DW_AT_accessibility
:
2738 case DW_ACCESS_public
: printf ("(public)"); break;
2739 case DW_ACCESS_protected
: printf ("(protected)"); break;
2740 case DW_ACCESS_private
: printf ("(private)"); break;
2742 printf (_("(unknown accessibility)"));
2747 case DW_AT_visibility
:
2751 case DW_VIS_local
: printf ("(local)"); break;
2752 case DW_VIS_exported
: printf ("(exported)"); break;
2753 case DW_VIS_qualified
: printf ("(qualified)"); break;
2754 default: printf (_("(unknown visibility)")); break;
2758 case DW_AT_endianity
:
2762 case DW_END_default
: printf ("(default)"); break;
2763 case DW_END_big
: printf ("(big)"); break;
2764 case DW_END_little
: printf ("(little)"); break;
2766 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2767 printf (_("(user specified)"));
2769 printf (_("(unknown endianity)"));
2774 case DW_AT_virtuality
:
2778 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2779 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2780 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2781 default: printf (_("(unknown virtuality)")); break;
2785 case DW_AT_identifier_case
:
2789 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2790 case DW_ID_up_case
: printf ("(up_case)"); break;
2791 case DW_ID_down_case
: printf ("(down_case)"); break;
2792 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2793 default: printf (_("(unknown case)")); break;
2797 case DW_AT_calling_convention
:
2801 case DW_CC_normal
: printf ("(normal)"); break;
2802 case DW_CC_program
: printf ("(program)"); break;
2803 case DW_CC_nocall
: printf ("(nocall)"); break;
2804 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2805 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2806 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2807 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2809 if (uvalue
>= DW_CC_lo_user
2810 && uvalue
<= DW_CC_hi_user
)
2811 printf (_("(user defined)"));
2813 printf (_("(unknown convention)"));
2817 case DW_AT_ordering
:
2822 case -1: printf (_("(undefined)")); break;
2823 case 0: printf ("(row major)"); break;
2824 case 1: printf ("(column major)"); break;
2828 case DW_AT_decimal_sign
:
2832 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2833 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2834 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2835 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2836 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2837 default: printf (_("(unrecognised)")); break;
2841 case DW_AT_defaulted
:
2845 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2846 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2847 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2848 default: printf (_("(unrecognised)")); break;
2852 case DW_AT_discr_list
:
2854 display_discr_list (form
, uvalue
, data
, end
, level
);
2857 case DW_AT_frame_base
:
2858 have_frame_base
= 1;
2860 case DW_AT_location
:
2861 case DW_AT_string_length
:
2862 case DW_AT_return_addr
:
2863 case DW_AT_data_member_location
:
2864 case DW_AT_vtable_elem_location
:
2866 case DW_AT_static_link
:
2867 case DW_AT_use_location
:
2868 case DW_AT_call_value
:
2869 case DW_AT_GNU_call_site_value
:
2870 case DW_AT_call_data_value
:
2871 case DW_AT_GNU_call_site_data_value
:
2872 case DW_AT_call_target
:
2873 case DW_AT_GNU_call_site_target
:
2874 case DW_AT_call_target_clobbered
:
2875 case DW_AT_GNU_call_site_target_clobbered
:
2876 if ((dwarf_version
< 4
2877 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2878 || form
== DW_FORM_sec_offset
)
2879 printf (_(" (location list)"));
2881 case DW_AT_allocated
:
2882 case DW_AT_associated
:
2883 case DW_AT_data_location
:
2885 case DW_AT_upper_bound
:
2886 case DW_AT_lower_bound
:
2889 int need_frame_base
;
2892 need_frame_base
= decode_location_expression (block_start
,
2897 cu_offset
, section
);
2899 if (need_frame_base
&& !have_frame_base
)
2900 printf (_(" [without DW_AT_frame_base]"));
2904 case DW_AT_data_bit_offset
:
2905 case DW_AT_byte_size
:
2906 case DW_AT_bit_size
:
2907 case DW_AT_string_length_byte_size
:
2908 case DW_AT_string_length_bit_size
:
2909 case DW_AT_bit_stride
:
2910 if (form
== DW_FORM_exprloc
)
2913 (void) decode_location_expression (block_start
, pointer_size
,
2914 offset_size
, dwarf_version
,
2915 uvalue
, cu_offset
, section
);
2922 if (form
== DW_FORM_ref_sig8
2923 || form
== DW_FORM_GNU_ref_alt
)
2926 if (form
== DW_FORM_ref1
2927 || form
== DW_FORM_ref2
2928 || form
== DW_FORM_ref4
2929 || form
== DW_FORM_ref_udata
)
2930 uvalue
+= cu_offset
;
2932 if (uvalue
>= section
->size
)
2933 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2934 dwarf_vmatoa ("x", uvalue
),
2935 (unsigned long) (orig_data
- section
->start
));
2938 unsigned long abbrev_number
;
2939 abbrev_entry
*entry
;
2940 unsigned char *p
= section
->start
+ uvalue
;
2942 READ_ULEB (abbrev_number
, p
, end
);
2944 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2945 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2946 use different abbrev table, and we don't track .debug_info chunks
2948 if (form
!= DW_FORM_ref_addr
)
2950 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2951 if (entry
->entry
== abbrev_number
)
2954 printf (" (%s)", get_TAG_name (entry
->tag
));
2968 static unsigned char *
2969 read_and_display_attr (unsigned long attribute
,
2971 dwarf_signed_vma implicit_const
,
2972 unsigned char * start
,
2973 unsigned char * data
,
2974 unsigned char * end
,
2975 dwarf_vma cu_offset
,
2976 dwarf_vma pointer_size
,
2977 dwarf_vma offset_size
,
2979 debug_info
* debug_info_p
,
2981 struct dwarf_section
* section
,
2982 struct cu_tu_set
* this_set
,
2986 printf (" %-18s:", get_AT_name (attribute
));
2987 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
2989 cu_offset
, pointer_size
, offset_size
,
2990 dwarf_version
, debug_info_p
,
2991 do_loc
, section
, this_set
, ' ', level
);
2997 /* Like load_debug_section, but if the ordinary call fails, and we are
2998 following debug links, then attempt to load the requested section
2999 from one of the separate debug info files. */
3002 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3005 if (load_debug_section (sec_enum
, handle
))
3007 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3009 /* See if we can associate a filename with this section. */
3012 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3013 if (i
->handle
== handle
)
3015 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3023 if (do_follow_links
)
3027 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3029 if (load_debug_section (sec_enum
, i
->handle
))
3031 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3033 /* FIXME: We should check to see if any of the remaining debug info
3034 files also contain this section, and, umm, do something about it. */
3044 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
3048 if (do_follow_links
&& section
->filename
)
3049 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3050 section
->name
, section
->filename
);
3052 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3056 if (do_follow_links
&& section
->filename
)
3057 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3058 section
->name
, section
->filename
);
3060 printf (_("Contents of the %s section:\n\n"), section
->name
);
3064 /* Process the contents of a .debug_info section.
3065 If do_loc is TRUE then we are scanning for location lists and dwo tags
3066 and we do not want to display anything to the user.
3067 If do_types is TRUE, we are processing a .debug_types section instead of
3068 a .debug_info section.
3069 The information displayed is restricted by the values in DWARF_START_DIE
3070 and DWARF_CUTOFF_LEVEL.
3071 Returns TRUE upon success. Otherwise an error or warning message is
3072 printed and FALSE is returned. */
3075 process_debug_info (struct dwarf_section
* section
,
3077 enum dwarf_section_display_enum abbrev_sec
,
3079 bfd_boolean do_types
)
3081 unsigned char *start
= section
->start
;
3082 unsigned char *end
= start
+ section
->size
;
3083 unsigned char *section_begin
;
3085 unsigned int num_units
= 0;
3087 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3088 && num_debug_info_entries
== 0
3093 /* First scan the section to get the number of comp units. */
3094 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3097 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3098 will be the length. For a 64-bit DWARF section, it'll be
3099 the escape code 0xffffffff followed by an 8 byte length. */
3100 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
3102 if (length
== 0xffffffff)
3104 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
3105 section_begin
+= length
+ 12;
3107 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3109 warn (_("Reserved length value (0x%s) found in section %s\n"),
3110 dwarf_vmatoa ("x", length
), section
->name
);
3114 section_begin
+= length
+ 4;
3116 /* Negative values are illegal, they may even cause infinite
3117 looping. This can happen if we can't accurately apply
3118 relocations to an object file, or if the file is corrupt. */
3119 if ((signed long) length
<= 0 || section_begin
< start
)
3121 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3122 dwarf_vmatoa ("x", length
), section
->name
);
3129 error (_("No comp units in %s section ?\n"), section
->name
);
3133 /* Then allocate an array to hold the information. */
3134 debug_information
= (debug_info
*) cmalloc (num_units
,
3135 sizeof (* debug_information
));
3136 if (debug_information
== NULL
)
3138 error (_("Not enough memory for a debug info array of %u entries\n"),
3140 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3144 /* PR 17531: file: 92ca3797.
3145 We cannot rely upon the debug_information array being initialised
3146 before it is used. A corrupt file could easily contain references
3147 to a unit for which information has not been made available. So
3148 we ensure that the array is zeroed here. */
3149 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3151 alloc_num_debug_info_entries
= num_units
;
3156 load_debug_section_with_follow (str
, file
);
3157 load_debug_section_with_follow (line_str
, file
);
3158 load_debug_section_with_follow (str_dwo
, file
);
3159 load_debug_section_with_follow (str_index
, file
);
3160 load_debug_section_with_follow (str_index_dwo
, file
);
3161 load_debug_section_with_follow (debug_addr
, file
);
3164 load_debug_section_with_follow (abbrev_sec
, file
);
3165 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3167 warn (_("Unable to locate %s section!\n"),
3168 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3172 if (!do_loc
&& dwarf_start_die
== 0)
3173 introduce (section
, FALSE
);
3175 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
3177 DWARF2_Internal_CompUnit compunit
;
3178 unsigned char *hdrptr
;
3179 unsigned char *tags
;
3180 int level
, last_level
, saved_level
;
3181 dwarf_vma cu_offset
;
3182 unsigned long sec_off
;
3183 unsigned int offset_size
;
3184 unsigned int initial_length_size
;
3185 dwarf_vma signature_high
= 0;
3186 dwarf_vma signature_low
= 0;
3187 dwarf_vma type_offset
= 0;
3188 struct cu_tu_set
*this_set
;
3189 dwarf_vma abbrev_base
;
3194 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3196 if (compunit
.cu_length
== 0xffffffff)
3198 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3200 initial_length_size
= 12;
3205 initial_length_size
= 4;
3208 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3210 cu_offset
= start
- section_begin
;
3212 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3214 if (compunit
.cu_version
< 5)
3216 compunit
.cu_unit_type
= DW_UT_compile
;
3217 /* Initialize it due to a false compiler warning. */
3218 compunit
.cu_pointer_size
= -1;
3222 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3223 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3225 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3228 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3230 if (this_set
== NULL
)
3233 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3237 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3238 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3241 if (compunit
.cu_version
< 5)
3242 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3244 /* PR 17512: file: 001-108546-0.001:0.1. */
3245 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3247 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3248 compunit
.cu_pointer_size
, offset_size
);
3249 compunit
.cu_pointer_size
= offset_size
;
3254 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
3256 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
3259 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
3260 + initial_length_size
))
3262 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3263 + initial_length_size
;
3267 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3268 && num_debug_info_entries
== 0
3271 debug_information
[unit
].cu_offset
= cu_offset
;
3272 debug_information
[unit
].pointer_size
3273 = compunit
.cu_pointer_size
;
3274 debug_information
[unit
].offset_size
= offset_size
;
3275 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3276 debug_information
[unit
].base_address
= 0;
3277 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3278 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3279 debug_information
[unit
].loc_offsets
= NULL
;
3280 debug_information
[unit
].have_frame_base
= NULL
;
3281 debug_information
[unit
].max_loc_offsets
= 0;
3282 debug_information
[unit
].num_loc_offsets
= 0;
3283 debug_information
[unit
].range_lists
= NULL
;
3284 debug_information
[unit
].max_range_lists
= 0;
3285 debug_information
[unit
].num_range_lists
= 0;
3288 if (!do_loc
&& dwarf_start_die
== 0)
3290 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3291 dwarf_vmatoa ("x", cu_offset
));
3292 printf (_(" Length: 0x%s (%s)\n"),
3293 dwarf_vmatoa ("x", compunit
.cu_length
),
3294 offset_size
== 8 ? "64-bit" : "32-bit");
3295 printf (_(" Version: %d\n"), compunit
.cu_version
);
3296 printf (_(" Abbrev Offset: 0x%s\n"),
3297 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3298 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3303 printf (_(" Signature: 0x%s\n"),
3304 dwarf_vmatoa64 (signature_high
, signature_low
,
3305 buf
, sizeof (buf
)));
3306 printf (_(" Type Offset: 0x%s\n"),
3307 dwarf_vmatoa ("x", type_offset
));
3309 if (this_set
!= NULL
)
3311 dwarf_vma
*offsets
= this_set
->section_offsets
;
3312 size_t *sizes
= this_set
->section_sizes
;
3314 printf (_(" Section contributions:\n"));
3315 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3316 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3317 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3318 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3319 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3320 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3321 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3322 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3323 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3324 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3325 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3326 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3330 sec_off
= cu_offset
+ initial_length_size
;
3331 if (sec_off
+ compunit
.cu_length
< sec_off
3332 || sec_off
+ compunit
.cu_length
> section
->size
)
3334 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3336 (unsigned long) cu_offset
,
3337 dwarf_vmatoa ("x", compunit
.cu_length
));
3343 start
+= compunit
.cu_length
+ initial_length_size
;
3345 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3347 warn (_("CU at offset %s contains corrupt or "
3348 "unsupported version number: %d.\n"),
3349 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3353 if (compunit
.cu_unit_type
!= DW_UT_compile
3354 && compunit
.cu_unit_type
!= DW_UT_type
)
3356 warn (_("CU at offset %s contains corrupt or "
3357 "unsupported unit type: %d.\n"),
3358 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3364 /* Process the abbrevs used by this compilation unit. */
3365 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3366 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3367 (unsigned long) compunit
.cu_abbrev_offset
,
3368 (unsigned long) abbrev_size
);
3369 /* PR 17531: file:4bcd9ce9. */
3370 else if ((abbrev_base
+ abbrev_size
)
3371 > debug_displays
[abbrev_sec
].section
.size
)
3372 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3373 (unsigned long) abbrev_base
+ abbrev_size
,
3374 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3376 process_abbrev_section
3377 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3378 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3379 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3380 + abbrev_base
+ abbrev_size
));
3385 while (tags
< start
)
3387 unsigned long abbrev_number
;
3388 unsigned long die_offset
;
3389 abbrev_entry
*entry
;
3391 int do_printing
= 1;
3393 die_offset
= tags
- section_begin
;
3395 READ_ULEB (abbrev_number
, tags
, start
);
3397 /* A null DIE marks the end of a list of siblings or it may also be
3398 a section padding. */
3399 if (abbrev_number
== 0)
3401 /* Check if it can be a section padding for the last CU. */
3402 if (level
== 0 && start
== end
)
3406 for (chk
= tags
; chk
< start
; chk
++)
3413 if (!do_loc
&& die_offset
>= dwarf_start_die
3414 && (dwarf_cutoff_level
== -1
3415 || level
< dwarf_cutoff_level
))
3416 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3422 static unsigned num_bogus_warns
= 0;
3424 if (num_bogus_warns
< 3)
3426 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3427 die_offset
, section
->name
);
3429 if (num_bogus_warns
== 3)
3430 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3433 if (dwarf_start_die
!= 0 && level
< saved_level
)
3440 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3444 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3445 saved_level
= level
;
3446 do_printing
= (dwarf_cutoff_level
== -1
3447 || level
< dwarf_cutoff_level
);
3449 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3450 level
, die_offset
, abbrev_number
);
3451 else if (dwarf_cutoff_level
== -1
3452 || last_level
< dwarf_cutoff_level
)
3453 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3458 /* Scan through the abbreviation list until we reach the
3460 for (entry
= first_abbrev
;
3461 entry
&& entry
->entry
!= abbrev_number
;
3462 entry
= entry
->next
)
3467 if (!do_loc
&& do_printing
)
3472 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3473 die_offset
, abbrev_number
);
3477 if (!do_loc
&& do_printing
)
3478 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3483 need_base_address
= 0;
3485 case DW_TAG_compile_unit
:
3486 need_base_address
= 1;
3487 need_dwo_info
= do_loc
;
3489 case DW_TAG_entry_point
:
3490 case DW_TAG_subprogram
:
3491 need_base_address
= 0;
3492 /* Assuming that there is no DW_AT_frame_base. */
3493 have_frame_base
= 0;
3497 debug_info
*debug_info_p
=
3498 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3499 ? debug_information
+ unit
: NULL
;
3501 assert (!debug_info_p
3502 || (debug_info_p
->num_loc_offsets
3503 == debug_info_p
->num_loc_views
));
3505 for (attr
= entry
->first_attr
;
3506 attr
&& attr
->attribute
;
3509 if (! do_loc
&& do_printing
)
3510 /* Show the offset from where the tag was extracted. */
3511 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3512 tags
= read_and_display_attr (attr
->attribute
,
3514 attr
->implicit_const
,
3519 compunit
.cu_pointer_size
,
3521 compunit
.cu_version
,
3523 do_loc
|| ! do_printing
,
3529 /* If a locview attribute appears before a location one,
3530 make sure we don't associate it with an earlier
3533 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3536 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3537 debug_info_p
->num_loc_views
++;
3538 assert (debug_info_p
->num_loc_views
3539 == debug_info_p
->num_loc_offsets
);
3546 warn(_("DIE has locviews without loclist\n"));
3547 debug_info_p
->num_loc_views
--;
3554 if (entry
->children
)
3559 /* Set num_debug_info_entries here so that it can be used to check if
3560 we need to process .debug_loc and .debug_ranges sections. */
3561 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3562 && num_debug_info_entries
== 0
3565 if (num_units
> alloc_num_debug_info_entries
)
3566 num_debug_info_entries
= alloc_num_debug_info_entries
;
3568 num_debug_info_entries
= num_units
;
3577 /* Locate and scan the .debug_info section in the file and record the pointer
3578 sizes and offsets for the compilation units in it. Usually an executable
3579 will have just one pointer size, but this is not guaranteed, and so we try
3580 not to make any assumptions. Returns zero upon failure, or the number of
3581 compilation units upon success. */
3584 load_debug_info (void * file
)
3586 /* If we have already tried and failed to load the .debug_info
3587 section then do not bother to repeat the task. */
3588 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3591 /* If we already have the information there is nothing else to do. */
3592 if (num_debug_info_entries
> 0)
3593 return num_debug_info_entries
;
3595 /* If this is a DWARF package file, load the CU and TU indexes. */
3596 (void) load_cu_tu_indexes (file
);
3598 if (load_debug_section_with_follow (info
, file
)
3599 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3600 return num_debug_info_entries
;
3602 if (load_debug_section_with_follow (info_dwo
, file
)
3603 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3604 abbrev_dwo
, TRUE
, FALSE
))
3605 return num_debug_info_entries
;
3607 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3611 /* Read a DWARF .debug_line section header starting at DATA.
3612 Upon success returns an updated DATA pointer and the LINFO
3613 structure and the END_OF_SEQUENCE pointer will be filled in.
3614 Otherwise returns NULL. */
3616 static unsigned char *
3617 read_debug_line_header (struct dwarf_section
* section
,
3618 unsigned char * data
,
3619 unsigned char * end
,
3620 DWARF2_Internal_LineInfo
* linfo
,
3621 unsigned char ** end_of_sequence
)
3623 unsigned char *hdrptr
;
3624 unsigned int initial_length_size
;
3626 /* Extract information from the Line Number Program Header.
3627 (section 6.2.4 in the Dwarf3 doc). */
3630 /* Get and check the length of the block. */
3631 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3633 if (linfo
->li_length
== 0xffffffff)
3635 /* This section is 64-bit DWARF 3. */
3636 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3637 linfo
->li_offset_size
= 8;
3638 initial_length_size
= 12;
3642 linfo
->li_offset_size
= 4;
3643 initial_length_size
= 4;
3646 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3648 /* If the length field has a relocation against it, then we should
3649 not complain if it is inaccurate (and probably negative). This
3650 happens in object files when the .debug_line section is actually
3651 comprised of several different .debug_line.* sections, (some of
3652 which may be removed by linker garbage collection), and a relocation
3653 is used to compute the correct length once that is done. */
3654 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3656 linfo
->li_length
= (end
- data
) - initial_length_size
;
3660 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3661 (long) linfo
->li_length
);
3666 /* Get and check the version number. */
3667 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3669 if (linfo
->li_version
!= 2
3670 && linfo
->li_version
!= 3
3671 && linfo
->li_version
!= 4
3672 && linfo
->li_version
!= 5)
3674 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3675 "is currently supported.\n"));
3679 if (linfo
->li_version
>= 5)
3681 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
3683 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
3684 if (linfo
->li_segment_size
!= 0)
3686 warn (_("The %s section contains "
3687 "unsupported segment selector size: %d.\n"),
3688 section
->name
, linfo
->li_segment_size
);
3693 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3694 linfo
->li_offset_size
, end
);
3695 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3697 if (linfo
->li_version
>= 4)
3699 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3701 if (linfo
->li_max_ops_per_insn
== 0)
3703 warn (_("Invalid maximum operations per insn.\n"));
3708 linfo
->li_max_ops_per_insn
= 1;
3710 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3711 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3712 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3713 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3715 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3716 /* PR 17512: file:002-117414-0.004. */
3717 if (* end_of_sequence
> end
)
3719 warn (_("Line length %s extends beyond end of section\n"),
3720 dwarf_vmatoa ("u", linfo
->li_length
));
3721 * end_of_sequence
= end
;
3728 static unsigned char *
3729 display_formatted_table (unsigned char * data
,
3730 unsigned char * start
,
3731 unsigned char * end
,
3732 const DWARF2_Internal_LineInfo
* linfo
,
3733 struct dwarf_section
* section
,
3736 unsigned char *format_start
, format_count
, *format
, formati
;
3737 dwarf_vma data_count
, datai
;
3738 unsigned int namepass
, last_entry
= 0;
3739 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
3741 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3742 format_start
= data
;
3743 for (formati
= 0; formati
< format_count
; formati
++)
3745 SKIP_ULEB (data
, end
);
3746 SKIP_ULEB (data
, end
);
3749 warn (_("%s: Corrupt format description entry\n"), table_name
);
3754 READ_ULEB (data_count
, data
, end
);
3757 warn (_("%s: Corrupt entry count\n"), table_name
);
3761 if (data_count
== 0)
3763 printf (_("\n The %s is empty.\n"), table_name
);
3766 else if (format_count
== 0)
3768 warn (_("%s: format count is zero, but the table is not empty\n"),
3773 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
3774 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
3777 printf (_(" Entry"));
3778 /* Delay displaying name as the last entry for better screen layout. */
3779 for (namepass
= 0; namepass
< 2; namepass
++)
3781 format
= format_start
;
3782 for (formati
= 0; formati
< format_count
; formati
++)
3784 dwarf_vma content_type
;
3786 READ_ULEB (content_type
, format
, end
);
3787 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3788 switch (content_type
)
3791 printf (_("\tName"));
3793 case DW_LNCT_directory_index
:
3794 printf (_("\tDir"));
3796 case DW_LNCT_timestamp
:
3797 printf (_("\tTime"));
3800 printf (_("\tSize"));
3803 printf (_("\tMD5\t\t\t"));
3806 printf (_("\t(Unknown format content type %s)"),
3807 dwarf_vmatoa ("u", content_type
));
3809 SKIP_ULEB (format
, end
);
3814 for (datai
= 0; datai
< data_count
; datai
++)
3816 unsigned char *datapass
= data
;
3818 printf (" %d", last_entry
++);
3819 /* Delay displaying name as the last entry for better screen layout. */
3820 for (namepass
= 0; namepass
< 2; namepass
++)
3822 format
= format_start
;
3824 for (formati
= 0; formati
< format_count
; formati
++)
3826 dwarf_vma content_type
, form
;
3828 READ_ULEB (content_type
, format
, end
);
3829 READ_ULEB (form
, format
, end
);
3830 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
3831 0, 0, linfo
->li_offset_size
,
3832 linfo
->li_version
, NULL
,
3833 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3834 section
, NULL
, '\t', -1);
3838 if (data
== end
&& (datai
< data_count
- 1))
3840 warn (_("\n%s: Corrupt entries list\n"), table_name
);
3849 display_debug_lines_raw (struct dwarf_section
* section
,
3850 unsigned char * data
,
3851 unsigned char * end
,
3854 unsigned char *start
= section
->start
;
3855 int verbose_view
= 0;
3857 introduce (section
, TRUE
);
3861 static DWARF2_Internal_LineInfo saved_linfo
;
3862 DWARF2_Internal_LineInfo linfo
;
3863 unsigned char *standard_opcodes
;
3864 unsigned char *end_of_sequence
;
3867 if (const_strneq (section
->name
, ".debug_line.")
3868 /* Note: the following does not apply to .debug_line.dwo sections.
3869 These are full debug_line sections. */
3870 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3872 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3873 section containing just the Line Number Statements. They are
3874 created by the assembler and intended to be used alongside gcc's
3875 -ffunction-sections command line option. When the linker's
3876 garbage collection decides to discard a .text.<foo> section it
3877 can then also discard the line number information in .debug_line.<foo>.
3879 Since the section is a fragment it does not have the details
3880 needed to fill out a LineInfo structure, so instead we use the
3881 details from the last full debug_line section that we processed. */
3882 end_of_sequence
= end
;
3883 standard_opcodes
= NULL
;
3884 linfo
= saved_linfo
;
3885 /* PR 17531: file: 0522b371. */
3886 if (linfo
.li_line_range
== 0)
3888 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3891 reset_state_machine (linfo
.li_default_is_stmt
);
3895 unsigned char * hdrptr
;
3897 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3898 & end_of_sequence
)) == NULL
)
3901 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3902 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3903 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3904 if (linfo
.li_version
>= 5)
3906 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
3907 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
3909 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3910 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3911 if (linfo
.li_version
>= 4)
3912 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3913 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3914 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3915 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3916 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3918 /* PR 17512: file: 1665-6428-0.004. */
3919 if (linfo
.li_line_range
== 0)
3921 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3922 linfo
.li_line_range
= 1;
3925 reset_state_machine (linfo
.li_default_is_stmt
);
3927 /* Display the contents of the Opcodes table. */
3928 standard_opcodes
= hdrptr
;
3930 /* PR 17512: file: 002-417945-0.004. */
3931 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3933 warn (_("Line Base extends beyond end of section\n"));
3937 printf (_("\n Opcodes:\n"));
3939 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3940 printf (ngettext (" Opcode %d has %d arg\n",
3941 " Opcode %d has %d args\n",
3942 standard_opcodes
[i
- 1]),
3943 i
, standard_opcodes
[i
- 1]);
3945 /* Display the contents of the Directory table. */
3946 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3948 if (linfo
.li_version
>= 5)
3950 load_debug_section_with_follow (line_str
, file
);
3952 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3954 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3960 printf (_("\n The Directory Table is empty.\n"));
3963 unsigned int last_dir_entry
= 0;
3965 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3966 (long)(data
- start
));
3968 while (data
< end
&& *data
!= 0)
3970 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
3972 data
+= strnlen ((char *) data
, end
- data
) + 1;
3975 /* PR 17512: file: 002-132094-0.004. */
3976 if (data
>= end
- 1)
3980 /* Skip the NUL at the end of the table. */
3983 /* Display the contents of the File Name table. */
3985 printf (_("\n The File Name Table is empty.\n"));
3988 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3989 (long)(data
- start
));
3990 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3992 while (data
< end
&& *data
!= 0)
3994 unsigned char *name
;
3997 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
3999 data
+= strnlen ((char *) data
, end
- data
) + 1;
4001 READ_ULEB (val
, data
, end
);
4002 printf ("%s\t", dwarf_vmatoa ("u", val
));
4003 READ_ULEB (val
, data
, end
);
4004 printf ("%s\t", dwarf_vmatoa ("u", val
));
4005 READ_ULEB (val
, data
, end
);
4006 printf ("%s\t", dwarf_vmatoa ("u", val
));
4007 printf ("%.*s\n", (int)(end
- name
), name
);
4011 warn (_("Corrupt file name table entry\n"));
4017 /* Skip the NUL at the end of the table. */
4022 saved_linfo
= linfo
;
4025 /* Now display the statements. */
4026 if (data
>= end_of_sequence
)
4027 printf (_(" No Line Number Statements.\n"));
4030 printf (_(" Line Number Statements:\n"));
4032 while (data
< end_of_sequence
)
4034 unsigned char op_code
;
4035 dwarf_signed_vma adv
;
4038 printf (" [0x%08lx]", (long)(data
- start
));
4042 if (op_code
>= linfo
.li_opcode_base
)
4044 op_code
-= linfo
.li_opcode_base
;
4045 uladv
= (op_code
/ linfo
.li_line_range
);
4046 if (linfo
.li_max_ops_per_insn
== 1)
4048 uladv
*= linfo
.li_min_insn_length
;
4049 state_machine_regs
.address
+= uladv
;
4051 state_machine_regs
.view
= 0;
4052 printf (_(" Special opcode %d: "
4053 "advance Address by %s to 0x%s%s"),
4054 op_code
, dwarf_vmatoa ("u", uladv
),
4055 dwarf_vmatoa ("x", state_machine_regs
.address
),
4056 verbose_view
&& uladv
4057 ? _(" (reset view)") : "");
4062 = ((state_machine_regs
.op_index
+ uladv
)
4063 / linfo
.li_max_ops_per_insn
)
4064 * linfo
.li_min_insn_length
;
4066 state_machine_regs
.address
+= addrdelta
;
4067 state_machine_regs
.op_index
4068 = (state_machine_regs
.op_index
+ uladv
)
4069 % linfo
.li_max_ops_per_insn
;
4071 state_machine_regs
.view
= 0;
4072 printf (_(" Special opcode %d: "
4073 "advance Address by %s to 0x%s[%d]%s"),
4074 op_code
, dwarf_vmatoa ("u", uladv
),
4075 dwarf_vmatoa ("x", state_machine_regs
.address
),
4076 state_machine_regs
.op_index
,
4077 verbose_view
&& addrdelta
4078 ? _(" (reset view)") : "");
4080 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4081 state_machine_regs
.line
+= adv
;
4082 printf (_(" and Line by %s to %d"),
4083 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4084 if (verbose_view
|| state_machine_regs
.view
)
4085 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4088 state_machine_regs
.view
++;
4093 case DW_LNS_extended_op
:
4094 data
+= process_extended_line_op (data
,
4095 linfo
.li_default_is_stmt
,
4100 printf (_(" Copy"));
4101 if (verbose_view
|| state_machine_regs
.view
)
4102 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4105 state_machine_regs
.view
++;
4108 case DW_LNS_advance_pc
:
4109 READ_ULEB (uladv
, data
, end
);
4110 if (linfo
.li_max_ops_per_insn
== 1)
4112 uladv
*= linfo
.li_min_insn_length
;
4113 state_machine_regs
.address
+= uladv
;
4115 state_machine_regs
.view
= 0;
4116 printf (_(" Advance PC by %s to 0x%s%s\n"),
4117 dwarf_vmatoa ("u", uladv
),
4118 dwarf_vmatoa ("x", state_machine_regs
.address
),
4119 verbose_view
&& uladv
4120 ? _(" (reset view)") : "");
4125 = ((state_machine_regs
.op_index
+ uladv
)
4126 / linfo
.li_max_ops_per_insn
)
4127 * linfo
.li_min_insn_length
;
4128 state_machine_regs
.address
4130 state_machine_regs
.op_index
4131 = (state_machine_regs
.op_index
+ uladv
)
4132 % linfo
.li_max_ops_per_insn
;
4134 state_machine_regs
.view
= 0;
4135 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4136 dwarf_vmatoa ("u", uladv
),
4137 dwarf_vmatoa ("x", state_machine_regs
.address
),
4138 state_machine_regs
.op_index
,
4139 verbose_view
&& addrdelta
4140 ? _(" (reset view)") : "");
4144 case DW_LNS_advance_line
:
4145 READ_SLEB (adv
, data
, end
);
4146 state_machine_regs
.line
+= adv
;
4147 printf (_(" Advance Line by %s to %d\n"),
4148 dwarf_vmatoa ("d", adv
),
4149 state_machine_regs
.line
);
4152 case DW_LNS_set_file
:
4153 READ_ULEB (uladv
, data
, end
);
4154 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4155 dwarf_vmatoa ("u", uladv
));
4156 state_machine_regs
.file
= uladv
;
4159 case DW_LNS_set_column
:
4160 READ_ULEB (uladv
, data
, end
);
4161 printf (_(" Set column to %s\n"),
4162 dwarf_vmatoa ("u", uladv
));
4163 state_machine_regs
.column
= uladv
;
4166 case DW_LNS_negate_stmt
:
4167 adv
= state_machine_regs
.is_stmt
;
4169 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4170 state_machine_regs
.is_stmt
= adv
;
4173 case DW_LNS_set_basic_block
:
4174 printf (_(" Set basic block\n"));
4175 state_machine_regs
.basic_block
= 1;
4178 case DW_LNS_const_add_pc
:
4179 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4180 if (linfo
.li_max_ops_per_insn
)
4182 uladv
*= linfo
.li_min_insn_length
;
4183 state_machine_regs
.address
+= uladv
;
4185 state_machine_regs
.view
= 0;
4186 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4187 dwarf_vmatoa ("u", uladv
),
4188 dwarf_vmatoa ("x", state_machine_regs
.address
),
4189 verbose_view
&& uladv
4190 ? _(" (reset view)") : "");
4195 = ((state_machine_regs
.op_index
+ uladv
)
4196 / linfo
.li_max_ops_per_insn
)
4197 * linfo
.li_min_insn_length
;
4198 state_machine_regs
.address
4200 state_machine_regs
.op_index
4201 = (state_machine_regs
.op_index
+ uladv
)
4202 % linfo
.li_max_ops_per_insn
;
4204 state_machine_regs
.view
= 0;
4205 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4206 dwarf_vmatoa ("u", uladv
),
4207 dwarf_vmatoa ("x", state_machine_regs
.address
),
4208 state_machine_regs
.op_index
,
4209 verbose_view
&& addrdelta
4210 ? _(" (reset view)") : "");
4214 case DW_LNS_fixed_advance_pc
:
4215 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4216 state_machine_regs
.address
+= uladv
;
4217 state_machine_regs
.op_index
= 0;
4218 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4219 dwarf_vmatoa ("u", uladv
),
4220 dwarf_vmatoa ("x", state_machine_regs
.address
));
4221 /* Do NOT reset view. */
4224 case DW_LNS_set_prologue_end
:
4225 printf (_(" Set prologue_end to true\n"));
4228 case DW_LNS_set_epilogue_begin
:
4229 printf (_(" Set epilogue_begin to true\n"));
4232 case DW_LNS_set_isa
:
4233 READ_ULEB (uladv
, data
, end
);
4234 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4238 printf (_(" Unknown opcode %d with operands: "), op_code
);
4240 if (standard_opcodes
!= NULL
)
4241 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4243 READ_ULEB (uladv
, data
, end
);
4244 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4245 i
== 1 ? "" : ", ");
4260 unsigned char *name
;
4261 unsigned int directory_index
;
4262 unsigned int modification_date
;
4263 unsigned int length
;
4266 /* Output a decoded representation of the .debug_line section. */
4269 display_debug_lines_decoded (struct dwarf_section
* section
,
4270 unsigned char * start
,
4271 unsigned char * data
,
4272 unsigned char * end
,
4275 static DWARF2_Internal_LineInfo saved_linfo
;
4277 introduce (section
, FALSE
);
4281 /* This loop amounts to one iteration per compilation unit. */
4282 DWARF2_Internal_LineInfo linfo
;
4283 unsigned char *standard_opcodes
;
4284 unsigned char *end_of_sequence
;
4286 File_Entry
*file_table
= NULL
;
4287 unsigned int n_files
= 0;
4288 unsigned char **directory_table
= NULL
;
4289 dwarf_vma n_directories
= 0;
4291 if (const_strneq (section
->name
, ".debug_line.")
4292 /* Note: the following does not apply to .debug_line.dwo sections.
4293 These are full debug_line sections. */
4294 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4296 /* See comment in display_debug_lines_raw(). */
4297 end_of_sequence
= end
;
4298 standard_opcodes
= NULL
;
4299 linfo
= saved_linfo
;
4300 /* PR 17531: file: 0522b371. */
4301 if (linfo
.li_line_range
== 0)
4303 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4306 reset_state_machine (linfo
.li_default_is_stmt
);
4310 unsigned char *hdrptr
;
4312 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4313 & end_of_sequence
)) == NULL
)
4316 /* PR 17531: file: 0522b371. */
4317 if (linfo
.li_line_range
== 0)
4319 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4320 linfo
.li_line_range
= 1;
4322 reset_state_machine (linfo
.li_default_is_stmt
);
4324 /* Save a pointer to the contents of the Opcodes table. */
4325 standard_opcodes
= hdrptr
;
4327 /* Traverse the Directory table just to count entries. */
4328 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4332 warn (_("opcode base of %d extends beyond end of section\n"),
4333 linfo
.li_opcode_base
);
4337 if (linfo
.li_version
>= 5)
4339 unsigned char *format_start
, format_count
, *format
;
4340 dwarf_vma formati
, entryi
;
4342 load_debug_section_with_follow (line_str
, fileptr
);
4344 /* Skip directories format. */
4345 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4346 format_start
= data
;
4347 for (formati
= 0; formati
< format_count
; formati
++)
4349 SKIP_ULEB (data
, end
);
4350 SKIP_ULEB (data
, end
);
4353 READ_ULEB (n_directories
, data
, end
);
4356 warn (_("Corrupt directories list\n"));
4360 directory_table
= (unsigned char **)
4361 xmalloc (n_directories
* sizeof (unsigned char *));
4363 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4365 unsigned char **pathp
= &directory_table
[entryi
];
4367 format
= format_start
;
4368 for (formati
= 0; formati
< format_count
; formati
++)
4370 dwarf_vma content_type
, form
;
4373 READ_ULEB (content_type
, format
, end
);
4374 READ_ULEB (form
, format
, end
);
4377 warn (_("Corrupt directories list\n"));
4380 switch (content_type
)
4385 case DW_FORM_string
:
4388 case DW_FORM_line_strp
:
4389 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4391 /* Remove const by the cast. */
4392 *pathp
= (unsigned char *)
4393 fetch_indirect_line_string (uvalue
);
4398 data
= read_and_display_attr_value (0, form
, 0, start
,
4400 linfo
.li_offset_size
,
4407 warn (_("Corrupt directories list\n"));
4412 /* Skip files format. */
4413 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4414 format_start
= data
;
4415 for (formati
= 0; formati
< format_count
; formati
++)
4417 SKIP_ULEB (data
, end
);
4418 SKIP_ULEB (data
, end
);
4421 READ_ULEB (n_files
, data
, end
);
4424 warn (_("Corrupt file name list\n"));
4428 file_table
= (File_Entry
*) xcalloc (1, n_files
4429 * sizeof (File_Entry
));
4431 for (entryi
= 0; entryi
< n_files
; entryi
++)
4433 File_Entry
*file
= &file_table
[entryi
];
4435 format
= format_start
;
4436 for (formati
= 0; formati
< format_count
; formati
++)
4438 dwarf_vma content_type
, form
;
4442 READ_ULEB (content_type
, format
, end
);
4443 READ_ULEB (form
, format
, end
);
4446 warn (_("Corrupt file name list\n"));
4449 switch (content_type
)
4454 case DW_FORM_string
:
4457 case DW_FORM_line_strp
:
4458 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4460 /* Remove const by the cast. */
4461 file
->name
= (unsigned char *)
4462 fetch_indirect_line_string (uvalue
);
4466 case DW_LNCT_directory_index
:
4470 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4474 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4479 READ_ULEB (file
->directory_index
, tmp
, end
);
4484 data
= read_and_display_attr_value (0, form
, 0, start
,
4486 linfo
.li_offset_size
,
4493 warn (_("Corrupt file name list\n"));
4502 unsigned char *ptr_directory_table
= data
;
4504 while (data
< end
&& *data
!= 0)
4506 data
+= strnlen ((char *) data
, end
- data
) + 1;
4513 warn (_("directory table ends unexpectedly\n"));
4518 /* Go through the directory table again to save the directories. */
4519 directory_table
= (unsigned char **)
4520 xmalloc (n_directories
* sizeof (unsigned char *));
4523 while (*ptr_directory_table
!= 0)
4525 directory_table
[i
] = ptr_directory_table
;
4526 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4527 ptr_directory_table
- end
) + 1;
4531 /* Skip the NUL at the end of the table. */
4534 /* Traverse the File Name table just to count the entries. */
4535 if (data
< end
&& *data
!= 0)
4537 unsigned char *ptr_file_name_table
= data
;
4539 while (data
< end
&& *data
!= 0)
4541 /* Skip Name, directory index, last modification
4542 time and length of file. */
4543 data
+= strnlen ((char *) data
, end
- data
) + 1;
4544 SKIP_ULEB (data
, end
);
4545 SKIP_ULEB (data
, end
);
4546 SKIP_ULEB (data
, end
);
4552 warn (_("file table ends unexpectedly\n"));
4557 /* Go through the file table again to save the strings. */
4558 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4561 while (*ptr_file_name_table
!= 0)
4563 file_table
[i
].name
= ptr_file_name_table
;
4564 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4565 end
- ptr_file_name_table
) + 1;
4567 /* We are not interested in directory, time or size. */
4568 READ_ULEB (file_table
[i
].directory_index
,
4569 ptr_file_name_table
, end
);
4570 READ_ULEB (file_table
[i
].modification_date
,
4571 ptr_file_name_table
, end
);
4572 READ_ULEB (file_table
[i
].length
,
4573 ptr_file_name_table
, end
);
4579 /* Skip the NUL at the end of the table. */
4583 /* Print the Compilation Unit's name and a header. */
4584 if (file_table
== NULL
)
4586 else if (directory_table
== NULL
)
4587 printf (_("CU: %s:\n"), file_table
[0].name
);
4590 unsigned int ix
= file_table
[0].directory_index
;
4591 const char *directory
;
4596 else if (n_directories
== 0)
4597 directory
= _("<unknown>");
4598 else if (ix
> n_directories
)
4600 warn (_("directory index %u > number of directories %s\n"),
4601 ix
, dwarf_vmatoa ("u", n_directories
));
4602 directory
= _("<corrupt>");
4605 directory
= (char *) directory_table
[ix
- 1];
4607 if (do_wide
|| strlen (directory
) < 76)
4608 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4610 printf ("%s:\n", file_table
[0].name
);
4613 printf (_("File name Line number Starting address View Stmt\n"));
4614 saved_linfo
= linfo
;
4617 /* This loop iterates through the Dwarf Line Number Program. */
4618 while (data
< end_of_sequence
)
4620 unsigned char op_code
;
4623 unsigned long int uladv
;
4624 int is_special_opcode
= 0;
4629 if (op_code
>= linfo
.li_opcode_base
)
4631 op_code
-= linfo
.li_opcode_base
;
4632 uladv
= (op_code
/ linfo
.li_line_range
);
4633 if (linfo
.li_max_ops_per_insn
== 1)
4635 uladv
*= linfo
.li_min_insn_length
;
4636 state_machine_regs
.address
+= uladv
;
4638 state_machine_regs
.view
= 0;
4643 = ((state_machine_regs
.op_index
+ uladv
)
4644 / linfo
.li_max_ops_per_insn
)
4645 * linfo
.li_min_insn_length
;
4646 state_machine_regs
.address
4648 state_machine_regs
.op_index
4649 = (state_machine_regs
.op_index
+ uladv
)
4650 % linfo
.li_max_ops_per_insn
;
4652 state_machine_regs
.view
= 0;
4655 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4656 state_machine_regs
.line
+= adv
;
4657 is_special_opcode
= 1;
4658 /* Increment view after printing this row. */
4663 case DW_LNS_extended_op
:
4665 unsigned int ext_op_code_len
;
4666 unsigned char ext_op_code
;
4667 unsigned char *op_code_end
;
4668 unsigned char *op_code_data
= data
;
4670 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
4671 op_code_end
= op_code_data
+ ext_op_code_len
;
4672 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
4674 warn (_("Badly formed extended line op encountered!\n"));
4677 ext_op_code
= *op_code_data
++;
4681 switch (ext_op_code
)
4683 case DW_LNE_end_sequence
:
4684 /* Reset stuff after printing this row. */
4686 case DW_LNE_set_address
:
4687 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4689 op_code_end
- op_code_data
,
4691 state_machine_regs
.op_index
= 0;
4692 state_machine_regs
.view
= 0;
4694 case DW_LNE_define_file
:
4695 file_table
= (File_Entry
*) xrealloc
4696 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4698 ++state_machine_regs
.last_file_entry
;
4699 /* Source file name. */
4700 file_table
[n_files
].name
= op_code_data
;
4701 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4702 /* Directory index. */
4703 READ_ULEB (file_table
[n_files
].directory_index
,
4704 op_code_data
, op_code_end
);
4705 /* Last modification time. */
4706 READ_ULEB (file_table
[n_files
].modification_date
,
4707 op_code_data
, op_code_end
);
4709 READ_ULEB (file_table
[n_files
].length
,
4710 op_code_data
, op_code_end
);
4714 case DW_LNE_set_discriminator
:
4715 case DW_LNE_HP_set_sequence
:
4716 /* Simply ignored. */
4720 printf (_("UNKNOWN (%u): length %ld\n"),
4721 ext_op_code
, (long int) (op_code_data
- data
));
4728 /* Increment view after printing this row. */
4731 case DW_LNS_advance_pc
:
4732 READ_ULEB (uladv
, data
, end
);
4733 if (linfo
.li_max_ops_per_insn
== 1)
4735 uladv
*= linfo
.li_min_insn_length
;
4736 state_machine_regs
.address
+= uladv
;
4738 state_machine_regs
.view
= 0;
4743 = ((state_machine_regs
.op_index
+ uladv
)
4744 / linfo
.li_max_ops_per_insn
)
4745 * linfo
.li_min_insn_length
;
4746 state_machine_regs
.address
4748 state_machine_regs
.op_index
4749 = (state_machine_regs
.op_index
+ uladv
)
4750 % linfo
.li_max_ops_per_insn
;
4752 state_machine_regs
.view
= 0;
4756 case DW_LNS_advance_line
:
4757 READ_SLEB (adv
, data
, end
);
4758 state_machine_regs
.line
+= adv
;
4761 case DW_LNS_set_file
:
4762 READ_ULEB (uladv
, data
, end
);
4763 state_machine_regs
.file
= uladv
;
4766 unsigned file
= state_machine_regs
.file
- 1;
4769 if (file_table
== NULL
|| n_files
== 0)
4770 printf (_("\n [Use file table entry %d]\n"), file
);
4772 else if (file
>= n_files
)
4774 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4775 printf (_("\n <over large file table index %u>"), file
);
4777 else if ((dir
= file_table
[file
].directory_index
) == 0)
4778 /* If directory index is 0, that means current directory. */
4779 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4780 else if (directory_table
== NULL
|| n_directories
== 0)
4781 printf (_("\n [Use file %s in directory table entry %d]\n"),
4782 file_table
[file
].name
, dir
);
4784 else if (dir
> n_directories
)
4786 warn (_("directory index %u > number of directories %s\n"),
4787 dir
, dwarf_vmatoa ("u", n_directories
));
4788 printf (_("\n <over large directory table entry %u>\n"), dir
);
4791 printf ("\n%s/%s:\n",
4792 /* The directory index starts counting at 1. */
4793 directory_table
[dir
- 1], file_table
[file
].name
);
4797 case DW_LNS_set_column
:
4798 READ_ULEB (uladv
, data
, end
);
4799 state_machine_regs
.column
= uladv
;
4802 case DW_LNS_negate_stmt
:
4803 adv
= state_machine_regs
.is_stmt
;
4805 state_machine_regs
.is_stmt
= adv
;
4808 case DW_LNS_set_basic_block
:
4809 state_machine_regs
.basic_block
= 1;
4812 case DW_LNS_const_add_pc
:
4813 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4814 if (linfo
.li_max_ops_per_insn
== 1)
4816 uladv
*= linfo
.li_min_insn_length
;
4817 state_machine_regs
.address
+= uladv
;
4819 state_machine_regs
.view
= 0;
4824 = ((state_machine_regs
.op_index
+ uladv
)
4825 / linfo
.li_max_ops_per_insn
)
4826 * linfo
.li_min_insn_length
;
4827 state_machine_regs
.address
4829 state_machine_regs
.op_index
4830 = (state_machine_regs
.op_index
+ uladv
)
4831 % linfo
.li_max_ops_per_insn
;
4833 state_machine_regs
.view
= 0;
4837 case DW_LNS_fixed_advance_pc
:
4838 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4839 state_machine_regs
.address
+= uladv
;
4840 state_machine_regs
.op_index
= 0;
4841 /* Do NOT reset view. */
4844 case DW_LNS_set_prologue_end
:
4847 case DW_LNS_set_epilogue_begin
:
4850 case DW_LNS_set_isa
:
4851 READ_ULEB (uladv
, data
, end
);
4852 printf (_(" Set ISA to %lu\n"), uladv
);
4856 printf (_(" Unknown opcode %d with operands: "), op_code
);
4858 if (standard_opcodes
!= NULL
)
4859 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4863 READ_ULEB (val
, data
, end
);
4864 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
4865 i
== 1 ? "" : ", ");
4871 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4872 to the DWARF address/line matrix. */
4873 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4874 || (xop
== DW_LNS_copy
))
4876 const unsigned int MAX_FILENAME_LENGTH
= 35;
4878 char *newFileName
= NULL
;
4879 size_t fileNameLength
;
4883 unsigned indx
= state_machine_regs
.file
- 1;
4885 if (indx
>= n_files
)
4887 warn (_("corrupt file index %u encountered\n"), indx
);
4888 fileName
= _("<corrupt>");
4891 fileName
= (char *) file_table
[indx
].name
;
4894 fileName
= _("<unknown>");
4896 fileNameLength
= strlen (fileName
);
4898 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4900 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4901 /* Truncate file name */
4902 strncpy (newFileName
,
4903 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4904 MAX_FILENAME_LENGTH
+ 1);
4905 /* FIXME: This is to pacify gcc-10 which can warn that the
4906 strncpy above might leave a non-NUL terminated string
4907 in newFileName. It won't, but gcc's analysis doesn't
4908 quite go far enough to discover this. */
4909 newFileName
[MAX_FILENAME_LENGTH
] = 0;
4913 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4914 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4917 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4919 if (linfo
.li_max_ops_per_insn
== 1)
4920 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4921 newFileName
, state_machine_regs
.line
,
4922 state_machine_regs
.address
);
4924 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4925 newFileName
, state_machine_regs
.line
,
4926 state_machine_regs
.address
,
4927 state_machine_regs
.op_index
);
4931 if (linfo
.li_max_ops_per_insn
== 1)
4932 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
4933 newFileName
, state_machine_regs
.line
,
4934 state_machine_regs
.address
);
4936 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4937 newFileName
, state_machine_regs
.line
,
4938 state_machine_regs
.address
,
4939 state_machine_regs
.op_index
);
4942 if (state_machine_regs
.view
)
4943 printf (" %6u", state_machine_regs
.view
);
4947 if (state_machine_regs
.is_stmt
)
4951 state_machine_regs
.view
++;
4953 if (xop
== -DW_LNE_end_sequence
)
4955 reset_state_machine (linfo
.li_default_is_stmt
);
4970 if (directory_table
)
4972 free (directory_table
);
4973 directory_table
= NULL
;
4984 display_debug_lines (struct dwarf_section
*section
, void *file
)
4986 unsigned char *data
= section
->start
;
4987 unsigned char *end
= data
+ section
->size
;
4989 int retValDecoded
= 1;
4991 if (do_debug_lines
== 0)
4992 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
4994 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
4995 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
4997 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
4998 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5000 if (!retValRaw
|| !retValDecoded
)
5007 find_debug_info_for_offset (unsigned long offset
)
5011 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5014 for (i
= 0; i
< num_debug_info_entries
; i
++)
5015 if (debug_information
[i
].cu_offset
== offset
)
5016 return debug_information
+ i
;
5022 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5024 /* See gdb/gdb-index.h. */
5025 static const char * const kinds
[] =
5037 return _ (kinds
[kind
]);
5041 display_debug_pubnames_worker (struct dwarf_section
*section
,
5042 void *file ATTRIBUTE_UNUSED
,
5045 DWARF2_Internal_PubNames names
;
5046 unsigned char *start
= section
->start
;
5047 unsigned char *end
= start
+ section
->size
;
5049 /* It does not matter if this load fails,
5050 we test for that later on. */
5051 load_debug_info (file
);
5053 introduce (section
, FALSE
);
5057 unsigned char *data
;
5058 unsigned long sec_off
;
5059 unsigned int offset_size
, initial_length_size
;
5061 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5062 if (names
.pn_length
== 0xffffffff)
5064 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5066 initial_length_size
= 12;
5071 initial_length_size
= 4;
5074 sec_off
= start
- section
->start
;
5075 if (sec_off
+ names
.pn_length
< sec_off
5076 || sec_off
+ names
.pn_length
> section
->size
)
5078 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5080 sec_off
- initial_length_size
,
5081 dwarf_vmatoa ("x", names
.pn_length
));
5086 start
+= names
.pn_length
;
5088 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5089 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5091 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5092 && num_debug_info_entries
> 0
5093 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5094 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5095 (unsigned long) names
.pn_offset
, section
->name
);
5097 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5099 printf (_(" Length: %ld\n"),
5100 (long) names
.pn_length
);
5101 printf (_(" Version: %d\n"),
5103 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5104 (unsigned long) names
.pn_offset
);
5105 printf (_(" Size of area in .debug_info section: %ld\n"),
5106 (long) names
.pn_size
);
5108 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5110 static int warned
= 0;
5114 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5122 printf (_("\n Offset Kind Name\n"));
5124 printf (_("\n Offset\tName\n"));
5128 bfd_size_type maxprint
;
5131 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5136 data
+= offset_size
;
5139 maxprint
= (end
- data
) - 1;
5143 unsigned int kind_data
;
5144 gdb_index_symbol_kind kind
;
5145 const char *kind_name
;
5148 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5151 /* GCC computes the kind as the upper byte in the CU index
5152 word, and then right shifts it by the CU index size.
5153 Left shift KIND to where the gdb-index.h accessor macros
5155 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5156 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5157 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5158 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5159 printf (" %-6lx %s,%-10s %.*s\n",
5160 (unsigned long) offset
, is_static
? _("s") : _("g"),
5161 kind_name
, (int) maxprint
, data
);
5164 printf (" %-6lx\t%.*s\n",
5165 (unsigned long) offset
, (int) maxprint
, data
);
5167 data
+= strnlen ((char *) data
, maxprint
) + 1;
5178 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5180 return display_debug_pubnames_worker (section
, file
, 0);
5184 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5186 return display_debug_pubnames_worker (section
, file
, 1);
5190 display_debug_macinfo (struct dwarf_section
*section
,
5191 void *file ATTRIBUTE_UNUSED
)
5193 unsigned char *start
= section
->start
;
5194 unsigned char *end
= start
+ section
->size
;
5195 unsigned char *curr
= start
;
5196 enum dwarf_macinfo_record_type op
;
5198 introduce (section
, FALSE
);
5202 unsigned int lineno
;
5203 const unsigned char *string
;
5205 op
= (enum dwarf_macinfo_record_type
) *curr
;
5210 case DW_MACINFO_start_file
:
5212 unsigned int filenum
;
5214 READ_ULEB (lineno
, curr
, end
);
5215 READ_ULEB (filenum
, curr
, end
);
5216 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5221 case DW_MACINFO_end_file
:
5222 printf (_(" DW_MACINFO_end_file\n"));
5225 case DW_MACINFO_define
:
5226 READ_ULEB (lineno
, curr
, end
);
5228 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5229 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5233 case DW_MACINFO_undef
:
5234 READ_ULEB (lineno
, curr
, end
);
5236 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5237 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5241 case DW_MACINFO_vendor_ext
:
5243 unsigned int constant
;
5245 READ_ULEB (constant
, curr
, end
);
5247 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5248 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5258 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5259 filename and dirname corresponding to file name table entry with index
5260 FILEIDX. Return NULL on failure. */
5262 static unsigned char *
5263 get_line_filename_and_dirname (dwarf_vma line_offset
,
5265 unsigned char **dir_name
)
5267 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5268 unsigned char *hdrptr
, *dirtable
, *file_name
;
5269 unsigned int offset_size
, initial_length_size
;
5270 unsigned int version
, opcode_base
;
5271 dwarf_vma length
, diridx
;
5272 const unsigned char * end
;
5275 if (section
->start
== NULL
5276 || line_offset
>= section
->size
5280 hdrptr
= section
->start
+ line_offset
;
5281 end
= section
->start
+ section
->size
;
5283 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5284 if (length
== 0xffffffff)
5286 /* This section is 64-bit DWARF 3. */
5287 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5289 initial_length_size
= 12;
5294 initial_length_size
= 4;
5296 if (length
+ initial_length_size
< length
5297 || length
+ initial_length_size
> section
->size
)
5300 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5301 if (version
!= 2 && version
!= 3 && version
!= 4)
5303 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5305 hdrptr
++; /* Skip max_ops_per_insn. */
5306 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5308 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5309 if (opcode_base
== 0)
5312 hdrptr
+= opcode_base
- 1;
5317 /* Skip over dirname table. */
5318 while (*hdrptr
!= '\0')
5320 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5324 hdrptr
++; /* Skip the NUL at the end of the table. */
5326 /* Now skip over preceding filename table entries. */
5327 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5329 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5330 SKIP_ULEB (hdrptr
, end
);
5331 SKIP_ULEB (hdrptr
, end
);
5332 SKIP_ULEB (hdrptr
, end
);
5334 if (hdrptr
>= end
|| *hdrptr
== '\0')
5338 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5341 READ_ULEB (diridx
, hdrptr
, end
);
5344 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5345 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5346 if (dirtable
>= end
|| *dirtable
== '\0')
5348 *dir_name
= dirtable
;
5353 display_debug_macro (struct dwarf_section
*section
,
5356 unsigned char *start
= section
->start
;
5357 unsigned char *end
= start
+ section
->size
;
5358 unsigned char *curr
= start
;
5359 unsigned char *extended_op_buf
[256];
5361 load_debug_section_with_follow (str
, file
);
5362 load_debug_section_with_follow (line
, file
);
5364 introduce (section
, FALSE
);
5368 unsigned int lineno
, version
, flags
;
5369 unsigned int offset_size
= 4;
5370 const unsigned char *string
;
5371 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5372 unsigned char **extended_ops
= NULL
;
5374 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5375 if (version
!= 4 && version
!= 5)
5377 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5382 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5385 printf (_(" Offset: 0x%lx\n"),
5386 (unsigned long) sec_offset
);
5387 printf (_(" Version: %d\n"), version
);
5388 printf (_(" Offset size: %d\n"), offset_size
);
5391 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5392 printf (_(" Offset into .debug_line: 0x%lx\n"),
5393 (unsigned long) line_offset
);
5397 unsigned int i
, count
, op
;
5400 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5402 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5403 extended_ops
= extended_op_buf
;
5406 printf (_(" Extension opcode arguments:\n"));
5407 for (i
= 0; i
< count
; i
++)
5409 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5410 extended_ops
[op
] = curr
;
5411 READ_ULEB (nargs
, curr
, end
);
5413 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5416 printf (_(" DW_MACRO_%02x arguments: "), op
);
5417 for (n
= 0; n
< nargs
; n
++)
5421 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5422 printf ("%s%s", get_FORM_name (form
),
5423 n
== nargs
- 1 ? "\n" : ", ");
5433 case DW_FORM_block1
:
5434 case DW_FORM_block2
:
5435 case DW_FORM_block4
:
5437 case DW_FORM_string
:
5439 case DW_FORM_sec_offset
:
5442 error (_("Invalid extension opcode form %s\n"),
5443 get_FORM_name (form
));
5459 error (_(".debug_macro section not zero terminated\n"));
5463 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5469 case DW_MACRO_start_file
:
5471 unsigned int filenum
;
5472 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5474 READ_ULEB (lineno
, curr
, end
);
5475 READ_ULEB (filenum
, curr
, end
);
5477 if ((flags
& 2) == 0)
5478 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5481 = get_line_filename_and_dirname (line_offset
, filenum
,
5483 if (file_name
== NULL
)
5484 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5487 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5489 dir_name
!= NULL
? (const char *) dir_name
: "",
5490 dir_name
!= NULL
? "/" : "", file_name
);
5494 case DW_MACRO_end_file
:
5495 printf (_(" DW_MACRO_end_file\n"));
5498 case DW_MACRO_define
:
5499 READ_ULEB (lineno
, curr
, end
);
5501 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5502 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5506 case DW_MACRO_undef
:
5507 READ_ULEB (lineno
, curr
, end
);
5509 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5510 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5514 case DW_MACRO_define_strp
:
5515 READ_ULEB (lineno
, curr
, end
);
5516 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5517 string
= fetch_indirect_string (offset
);
5518 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5522 case DW_MACRO_undef_strp
:
5523 READ_ULEB (lineno
, curr
, end
);
5524 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5525 string
= fetch_indirect_string (offset
);
5526 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5530 case DW_MACRO_import
:
5531 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5532 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5533 (unsigned long) offset
);
5536 case DW_MACRO_define_sup
:
5537 READ_ULEB (lineno
, curr
, end
);
5538 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5539 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5540 lineno
, (unsigned long) offset
);
5543 case DW_MACRO_undef_sup
:
5544 READ_ULEB (lineno
, curr
, end
);
5545 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5546 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5547 lineno
, (unsigned long) offset
);
5550 case DW_MACRO_import_sup
:
5551 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5552 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5553 (unsigned long) offset
);
5557 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5559 error (_(" Unknown macro opcode %02x seen\n"), op
);
5564 /* Skip over unhandled opcodes. */
5566 unsigned char *desc
= extended_ops
[op
];
5567 READ_ULEB (nargs
, desc
, end
);
5570 printf (_(" DW_MACRO_%02x\n"), op
);
5573 printf (_(" DW_MACRO_%02x -"), op
);
5574 for (n
= 0; n
< nargs
; n
++)
5578 /* DW_FORM_implicit_const is not expected here. */
5579 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5581 = read_and_display_attr_value (0, val
, 0,
5582 start
, curr
, end
, 0, 0, offset_size
,
5583 version
, NULL
, 0, NULL
,
5601 display_debug_abbrev (struct dwarf_section
*section
,
5602 void *file ATTRIBUTE_UNUSED
)
5604 abbrev_entry
*entry
;
5605 unsigned char *start
= section
->start
;
5606 unsigned char *end
= start
+ section
->size
;
5608 introduce (section
, FALSE
);
5612 unsigned char *last
;
5617 start
= process_abbrev_section (start
, end
);
5619 if (first_abbrev
== NULL
)
5622 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5624 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5628 printf (" %ld %s [%s]\n",
5630 get_TAG_name (entry
->tag
),
5631 entry
->children
? _("has children") : _("no children"));
5633 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5635 printf (" %-18s %s",
5636 get_AT_name (attr
->attribute
),
5637 get_FORM_name (attr
->form
));
5638 if (attr
->form
== DW_FORM_implicit_const
)
5639 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5651 /* Return true when ADDR is the maximum address, when addresses are
5652 POINTER_SIZE bytes long. */
5655 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5657 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5658 return ((addr
& mask
) == mask
);
5661 /* Display a view pair list starting at *VSTART_PTR and ending at
5662 VLISTEND within SECTION. */
5665 display_view_pair_list (struct dwarf_section
*section
,
5666 unsigned char **vstart_ptr
,
5667 unsigned int debug_info_entry
,
5668 unsigned char *vlistend
)
5670 unsigned char *vstart
= *vstart_ptr
;
5671 unsigned char *section_end
= section
->start
+ section
->size
;
5672 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5674 if (vlistend
< section_end
)
5675 section_end
= vlistend
;
5679 while (vstart
< section_end
)
5681 dwarf_vma off
= vstart
- section
->start
;
5682 dwarf_vma vbegin
, vend
;
5684 READ_ULEB (vbegin
, vstart
, section_end
);
5685 if (vstart
== section_end
)
5688 READ_ULEB (vend
, vstart
, section_end
);
5689 printf (" %8.8lx ", (unsigned long) off
);
5691 print_dwarf_view (vbegin
, pointer_size
, 1);
5692 print_dwarf_view (vend
, pointer_size
, 1);
5693 printf (_("location view pair\n"));
5697 *vstart_ptr
= vstart
;
5700 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5703 display_loc_list (struct dwarf_section
*section
,
5704 unsigned char **start_ptr
,
5705 unsigned int debug_info_entry
,
5707 dwarf_vma base_address
,
5708 unsigned char **vstart_ptr
,
5711 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5712 unsigned char *section_end
= section
->start
+ section
->size
;
5713 unsigned long cu_offset
;
5714 unsigned int pointer_size
;
5715 unsigned int offset_size
;
5720 unsigned short length
;
5721 int need_frame_base
;
5723 if (debug_info_entry
>= num_debug_info_entries
)
5725 warn (_("No debug information available for loc lists of entry: %u\n"),
5730 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5731 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5732 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5733 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5735 if (pointer_size
< 2 || pointer_size
> 8)
5737 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5738 pointer_size
, debug_info_entry
);
5744 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5745 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5747 if (start
+ 2 * pointer_size
> section_end
)
5749 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5750 (unsigned long) offset
);
5754 printf (" %8.8lx ", (unsigned long) off
);
5756 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5757 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5759 if (begin
== 0 && end
== 0)
5761 /* PR 18374: In a object file we can have a location list that
5762 starts with a begin and end of 0 because there are relocations
5763 that need to be applied to the addresses. Actually applying
5764 the relocations now does not help as they will probably resolve
5765 to 0, since the object file has not been fully linked. Real
5766 end of list markers will not have any relocations against them. */
5767 if (! reloc_at (section
, off
)
5768 && ! reloc_at (section
, off
+ pointer_size
))
5770 printf (_("<End of list>\n"));
5775 /* Check base address specifiers. */
5776 if (is_max_address (begin
, pointer_size
)
5777 && !is_max_address (end
, pointer_size
))
5780 print_dwarf_vma (begin
, pointer_size
);
5781 print_dwarf_vma (end
, pointer_size
);
5782 printf (_("(base address)\n"));
5788 off
= offset
+ (vstart
- *start_ptr
);
5790 READ_ULEB (vbegin
, vstart
, section_end
);
5791 print_dwarf_view (vbegin
, pointer_size
, 1);
5793 READ_ULEB (vend
, vstart
, section_end
);
5794 print_dwarf_view (vend
, pointer_size
, 1);
5796 printf (_("views at %8.8lx for:\n %*s "),
5797 (unsigned long) off
, 8, "");
5800 if (start
+ 2 > section_end
)
5802 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5803 (unsigned long) offset
);
5807 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5809 if (start
+ length
> section_end
)
5811 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5812 (unsigned long) offset
);
5816 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5817 print_dwarf_vma (end
+ base_address
, pointer_size
);
5820 need_frame_base
= decode_location_expression (start
,
5825 cu_offset
, section
);
5828 if (need_frame_base
&& !has_frame_base
)
5829 printf (_(" [without DW_AT_frame_base]"));
5831 if (begin
== end
&& vbegin
== vend
)
5832 fputs (_(" (start == end)"), stdout
);
5833 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5834 fputs (_(" (start > end)"), stdout
);
5842 *vstart_ptr
= vstart
;
5845 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5848 display_loclists_list (struct dwarf_section
*section
,
5849 unsigned char **start_ptr
,
5850 unsigned int debug_info_entry
,
5852 dwarf_vma base_address
,
5853 unsigned char **vstart_ptr
,
5856 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5857 unsigned char *section_end
= section
->start
+ section
->size
;
5858 unsigned long cu_offset
;
5859 unsigned int pointer_size
;
5860 unsigned int offset_size
;
5863 /* Initialize it due to a false compiler warning. */
5864 dwarf_vma begin
= -1, vbegin
= -1;
5865 dwarf_vma end
= -1, vend
= -1;
5867 int need_frame_base
;
5869 if (debug_info_entry
>= num_debug_info_entries
)
5871 warn (_("No debug information available for "
5872 "loclists lists of entry: %u\n"),
5877 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5878 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5879 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5880 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5882 if (pointer_size
< 2 || pointer_size
> 8)
5884 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5885 pointer_size
, debug_info_entry
);
5891 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5892 enum dwarf_location_list_entry_type llet
;
5894 if (start
+ 1 > section_end
)
5896 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5897 (unsigned long) offset
);
5901 printf (" %8.8lx ", (unsigned long) off
);
5903 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5905 if (vstart
&& llet
== DW_LLE_offset_pair
)
5907 off
= offset
+ (vstart
- *start_ptr
);
5909 READ_ULEB (vbegin
, vstart
, section_end
);
5910 print_dwarf_view (vbegin
, pointer_size
, 1);
5912 READ_ULEB (vend
, vstart
, section_end
);
5913 print_dwarf_view (vend
, pointer_size
, 1);
5915 printf (_("views at %8.8lx for:\n %*s "),
5916 (unsigned long) off
, 8, "");
5921 case DW_LLE_end_of_list
:
5922 printf (_("<End of list>\n"));
5924 case DW_LLE_offset_pair
:
5925 READ_ULEB (begin
, start
, section_end
);
5926 READ_ULEB (end
, start
, section_end
);
5928 case DW_LLE_base_address
:
5929 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
5931 print_dwarf_vma (base_address
, pointer_size
);
5932 printf (_("(base address)\n"));
5934 #ifdef DW_LLE_view_pair
5935 case DW_LLE_view_pair
:
5937 printf (_("View pair entry in loclist with locviews attribute\n"));
5938 READ_ULEB (vbegin
, start
, section_end
);
5939 print_dwarf_view (vbegin
, pointer_size
, 1);
5941 READ_ULEB (vend
, start
, section_end
);
5942 print_dwarf_view (vend
, pointer_size
, 1);
5944 printf (_("views for:\n"));
5948 error (_("Invalid location list entry type %d\n"), llet
);
5951 if (llet
== DW_LLE_end_of_list
)
5953 if (llet
!= DW_LLE_offset_pair
)
5956 if (start
+ 2 > section_end
)
5958 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5959 (unsigned long) offset
);
5963 READ_ULEB (length
, start
, section_end
);
5965 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5966 print_dwarf_vma (end
+ base_address
, pointer_size
);
5969 need_frame_base
= decode_location_expression (start
,
5974 cu_offset
, section
);
5977 if (need_frame_base
&& !has_frame_base
)
5978 printf (_(" [without DW_AT_frame_base]"));
5980 if (begin
== end
&& vbegin
== vend
)
5981 fputs (_(" (start == end)"), stdout
);
5982 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5983 fputs (_(" (start > end)"), stdout
);
5991 if (vbegin
!= vm1
|| vend
!= vm1
)
5992 printf (_("Trailing view pair not used in a range"));
5995 *vstart_ptr
= vstart
;
5998 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
5999 right-adjusted in a field of length LEN, and followed by a space. */
6002 print_addr_index (unsigned int idx
, unsigned int len
)
6004 static char buf
[15];
6005 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6006 printf ("%*s ", len
, buf
);
6009 /* Display a location list from a .dwo section. It uses address indexes rather
6010 than embedded addresses. This code closely follows display_loc_list, but the
6011 two are sufficiently different that combining things is very ugly. */
6014 display_loc_list_dwo (struct dwarf_section
*section
,
6015 unsigned char **start_ptr
,
6016 unsigned int debug_info_entry
,
6018 unsigned char **vstart_ptr
,
6021 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6022 unsigned char *section_end
= section
->start
+ section
->size
;
6023 unsigned long cu_offset
;
6024 unsigned int pointer_size
;
6025 unsigned int offset_size
;
6028 unsigned short length
;
6029 int need_frame_base
;
6032 if (debug_info_entry
>= num_debug_info_entries
)
6034 warn (_("No debug information for loc lists of entry: %u\n"),
6039 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6040 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6041 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6042 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6044 if (pointer_size
< 2 || pointer_size
> 8)
6046 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6047 pointer_size
, debug_info_entry
);
6053 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6055 if (start
>= section_end
)
6057 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6058 (unsigned long) offset
);
6062 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6075 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6077 READ_ULEB (view
, vstart
, section_end
);
6078 print_dwarf_view (view
, 8, 1);
6080 READ_ULEB (view
, vstart
, section_end
);
6081 print_dwarf_view (view
, 8, 1);
6083 printf (_("views at %8.8lx for:\n %*s "),
6084 (unsigned long) off
, 8, "");
6092 case 0: /* A terminating entry. */
6094 *vstart_ptr
= vstart
;
6095 printf (_("<End of list>\n"));
6097 case 1: /* A base-address entry. */
6098 READ_ULEB (idx
, start
, section_end
);
6099 print_addr_index (idx
, 8);
6100 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6101 printf (_("(base address selection entry)\n"));
6103 case 2: /* A start/end entry. */
6104 READ_ULEB (idx
, start
, section_end
);
6105 print_addr_index (idx
, 8);
6106 READ_ULEB (idx
, start
, section_end
);
6107 print_addr_index (idx
, 8);
6109 case 3: /* A start/length entry. */
6110 READ_ULEB (idx
, start
, section_end
);
6111 print_addr_index (idx
, 8);
6112 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6113 printf ("%08x ", idx
);
6115 case 4: /* An offset pair entry. */
6116 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6117 printf ("%08x ", idx
);
6118 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6119 printf ("%08x ", idx
);
6122 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6124 *vstart_ptr
= vstart
;
6128 if (start
+ 2 > section_end
)
6130 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6131 (unsigned long) offset
);
6135 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6136 if (start
+ length
> section_end
)
6138 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6139 (unsigned long) offset
);
6144 need_frame_base
= decode_location_expression (start
,
6149 cu_offset
, section
);
6152 if (need_frame_base
&& !has_frame_base
)
6153 printf (_(" [without DW_AT_frame_base]"));
6161 *vstart_ptr
= vstart
;
6164 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6167 static dwarf_vma
*loc_offsets
, *loc_views
;
6170 loc_offsets_compar (const void *ap
, const void *bp
)
6172 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6173 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6175 int ret
= (a
> b
) - (b
> a
);
6179 a
= loc_views
[*(const unsigned int *) ap
];
6180 b
= loc_views
[*(const unsigned int *) bp
];
6182 ret
= (a
> b
) - (b
> a
);
6188 display_debug_loc (struct dwarf_section
*section
, void *file
)
6190 unsigned char *start
= section
->start
, *vstart
= NULL
;
6191 unsigned long bytes
;
6192 unsigned char *section_begin
= start
;
6193 unsigned int num_loc_list
= 0;
6194 unsigned long last_offset
= 0;
6195 unsigned long last_view
= 0;
6196 unsigned int first
= 0;
6199 int seen_first_offset
= 0;
6200 int locs_sorted
= 1;
6201 unsigned char *next
= start
, *vnext
= vstart
;
6202 unsigned int *array
= NULL
;
6203 const char *suffix
= strrchr (section
->name
, '.');
6204 bfd_boolean is_dwo
= FALSE
;
6205 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6206 dwarf_vma expected_start
= 0;
6208 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6211 bytes
= section
->size
;
6215 printf (_("\nThe %s section is empty.\n"), section
->name
);
6221 unsigned char *hdrptr
= section_begin
;
6222 dwarf_vma ll_length
;
6223 unsigned short ll_version
;
6224 unsigned char *end
= section_begin
+ section
->size
;
6225 unsigned char address_size
, segment_selector_size
;
6226 uint32_t offset_entry_count
;
6228 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6229 if (ll_length
== 0xffffffff)
6230 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6232 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6233 if (ll_version
!= 5)
6235 warn (_("The %s section contains corrupt or "
6236 "unsupported version number: %d.\n"),
6237 section
->name
, ll_version
);
6241 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6243 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6244 if (segment_selector_size
!= 0)
6246 warn (_("The %s section contains "
6247 "unsupported segment selector size: %d.\n"),
6248 section
->name
, segment_selector_size
);
6252 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6253 if (offset_entry_count
!= 0)
6255 warn (_("The %s section contains "
6256 "unsupported offset entry count: %d.\n"),
6257 section
->name
, offset_entry_count
);
6261 expected_start
= hdrptr
- section_begin
;
6264 if (load_debug_info (file
) == 0)
6266 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6271 /* Check the order of location list in .debug_info section. If
6272 offsets of location lists are in the ascending order, we can
6273 use `debug_information' directly. */
6274 for (i
= 0; i
< num_debug_info_entries
; i
++)
6278 num
= debug_information
[i
].num_loc_offsets
;
6279 if (num
> num_loc_list
)
6282 /* Check if we can use `debug_information' directly. */
6283 if (locs_sorted
&& num
!= 0)
6285 if (!seen_first_offset
)
6287 /* This is the first location list. */
6288 last_offset
= debug_information
[i
].loc_offsets
[0];
6289 last_view
= debug_information
[i
].loc_views
[0];
6291 seen_first_offset
= 1;
6297 for (; j
< num
; j
++)
6300 debug_information
[i
].loc_offsets
[j
]
6301 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6302 && last_view
> debug_information
[i
].loc_views
[j
]))
6307 last_offset
= debug_information
[i
].loc_offsets
[j
];
6308 last_view
= debug_information
[i
].loc_views
[j
];
6313 if (!seen_first_offset
)
6314 error (_("No location lists in .debug_info section!\n"));
6316 if (debug_information
[first
].num_loc_offsets
> 0
6317 && debug_information
[first
].loc_offsets
[0] != expected_start
6318 && debug_information
[first
].loc_views
[0] != expected_start
)
6319 warn (_("Location lists in %s section start at 0x%s\n"),
6321 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6324 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6326 introduce (section
, FALSE
);
6328 if (reloc_at (section
, 0))
6329 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6331 printf (_(" Offset Begin End Expression\n"));
6333 seen_first_offset
= 0;
6334 for (i
= first
; i
< num_debug_info_entries
; i
++)
6336 dwarf_vma offset
, voffset
;
6337 dwarf_vma base_address
;
6343 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6345 loc_offsets
= debug_information
[i
].loc_offsets
;
6346 loc_views
= debug_information
[i
].loc_views
;
6347 qsort (array
, debug_information
[i
].num_loc_offsets
,
6348 sizeof (*array
), loc_offsets_compar
);
6351 int adjacent_view_loclists
= 1;
6352 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6354 j
= locs_sorted
? k
: array
[k
];
6356 && (debug_information
[i
].loc_offsets
[locs_sorted
6357 ? k
- 1 : array
[k
- 1]]
6358 == debug_information
[i
].loc_offsets
[j
])
6359 && (debug_information
[i
].loc_views
[locs_sorted
6360 ? k
- 1 : array
[k
- 1]]
6361 == debug_information
[i
].loc_views
[j
]))
6363 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6364 offset
= debug_information
[i
].loc_offsets
[j
];
6365 next
= section_begin
+ offset
;
6366 voffset
= debug_information
[i
].loc_views
[j
];
6368 vnext
= section_begin
+ voffset
;
6371 base_address
= debug_information
[i
].base_address
;
6373 if (vnext
&& vnext
< next
)
6376 display_view_pair_list (section
, &vstart
, i
, next
);
6381 if (!seen_first_offset
|| !adjacent_view_loclists
)
6382 seen_first_offset
= 1;
6386 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6387 (unsigned long) (start
- section_begin
),
6388 (unsigned long) offset
);
6389 else if (start
> next
)
6390 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6391 (unsigned long) (start
- section_begin
),
6392 (unsigned long) offset
);
6397 if (offset
>= bytes
)
6399 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6400 (unsigned long) offset
);
6404 if (vnext
&& voffset
>= bytes
)
6406 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6407 (unsigned long) voffset
);
6414 display_loc_list_dwo (section
, &start
, i
, offset
,
6415 &vstart
, has_frame_base
);
6417 display_loc_list (section
, &start
, i
, offset
, base_address
,
6418 &vstart
, has_frame_base
);
6423 warn (_("DWO is not yet supported.\n"));
6425 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6426 &vstart
, has_frame_base
);
6429 /* FIXME: this arrangement is quite simplistic. Nothing
6430 requires locview lists to be adjacent to corresponding
6431 loclists, and a single loclist could be augmented by
6432 different locview lists, and vice-versa, unlikely as it
6433 is that it would make sense to do so. Hopefully we'll
6434 have view pair support built into loclists before we ever
6435 need to address all these possibilities. */
6436 if (adjacent_view_loclists
&& vnext
6437 && vnext
!= start
&& vstart
!= next
)
6439 adjacent_view_loclists
= 0;
6440 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6443 if (vnext
&& vnext
== start
)
6444 display_view_pair_list (section
, &start
, i
, vstart
);
6448 if (start
< section
->start
+ section
->size
)
6449 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6450 "There are %ld unused bytes at the end of section %s\n",
6451 (long) (section
->start
+ section
->size
- start
)),
6452 (long) (section
->start
+ section
->size
- start
), section
->name
);
6459 display_debug_str (struct dwarf_section
*section
,
6460 void *file ATTRIBUTE_UNUSED
)
6462 unsigned char *start
= section
->start
;
6463 unsigned long bytes
= section
->size
;
6464 dwarf_vma addr
= section
->address
;
6468 printf (_("\nThe %s section is empty.\n"), section
->name
);
6472 introduce (section
, FALSE
);
6480 lbytes
= (bytes
> 16 ? 16 : bytes
);
6482 printf (" 0x%8.8lx ", (unsigned long) addr
);
6484 for (j
= 0; j
< 16; j
++)
6487 printf ("%2.2x", start
[j
]);
6495 for (j
= 0; j
< lbytes
; j
++)
6498 if (k
>= ' ' && k
< 0x80)
6517 display_debug_info (struct dwarf_section
*section
, void *file
)
6519 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6523 display_debug_types (struct dwarf_section
*section
, void *file
)
6525 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6529 display_trace_info (struct dwarf_section
*section
, void *file
)
6531 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6535 display_debug_aranges (struct dwarf_section
*section
,
6536 void *file ATTRIBUTE_UNUSED
)
6538 unsigned char *start
= section
->start
;
6539 unsigned char *end
= start
+ section
->size
;
6541 introduce (section
, FALSE
);
6543 /* It does not matter if this load fails,
6544 we test for that later on. */
6545 load_debug_info (file
);
6549 unsigned char *hdrptr
;
6550 DWARF2_Internal_ARange arange
;
6551 unsigned char *addr_ranges
;
6554 unsigned long sec_off
;
6555 unsigned char address_size
;
6557 unsigned int offset_size
;
6558 unsigned int initial_length_size
;
6562 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6563 if (arange
.ar_length
== 0xffffffff)
6565 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6567 initial_length_size
= 12;
6572 initial_length_size
= 4;
6575 sec_off
= hdrptr
- section
->start
;
6576 if (sec_off
+ arange
.ar_length
< sec_off
6577 || sec_off
+ arange
.ar_length
> section
->size
)
6579 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6581 sec_off
- initial_length_size
,
6582 dwarf_vmatoa ("x", arange
.ar_length
));
6586 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6587 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6589 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6590 && num_debug_info_entries
> 0
6591 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6592 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6593 (unsigned long) arange
.ar_info_offset
, section
->name
);
6595 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6596 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6598 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6600 /* PR 19872: A version number of 0 probably means that there is
6601 padding at the end of the .debug_aranges section. Gold puts
6602 it there when performing an incremental link, for example.
6603 So do not generate a warning in this case. */
6604 if (arange
.ar_version
)
6605 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6609 printf (_(" Length: %ld\n"),
6610 (long) arange
.ar_length
);
6611 printf (_(" Version: %d\n"), arange
.ar_version
);
6612 printf (_(" Offset into .debug_info: 0x%lx\n"),
6613 (unsigned long) arange
.ar_info_offset
);
6614 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6615 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6617 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6619 /* PR 17512: file: 001-108546-0.001:0.1. */
6620 if (address_size
== 0 || address_size
> 8)
6622 error (_("Invalid address size in %s section!\n"),
6627 /* The DWARF spec does not require that the address size be a power
6628 of two, but we do. This will have to change if we ever encounter
6629 an uneven architecture. */
6630 if ((address_size
& (address_size
- 1)) != 0)
6632 warn (_("Pointer size + Segment size is not a power of two.\n"));
6636 if (address_size
> 4)
6637 printf (_("\n Address Length\n"));
6639 printf (_("\n Address Length\n"));
6641 addr_ranges
= hdrptr
;
6643 /* Must pad to an alignment boundary that is twice the address size. */
6644 excess
= (hdrptr
- start
) % (2 * address_size
);
6646 addr_ranges
+= (2 * address_size
) - excess
;
6648 start
+= arange
.ar_length
+ initial_length_size
;
6650 while (addr_ranges
+ 2 * address_size
<= start
)
6652 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6653 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6656 print_dwarf_vma (address
, address_size
);
6657 print_dwarf_vma (length
, address_size
);
6667 /* Comparison function for qsort. */
6669 comp_addr_base (const void * v0
, const void * v1
)
6671 debug_info
*info0
= *(debug_info
**) v0
;
6672 debug_info
*info1
= *(debug_info
**) v1
;
6673 return info0
->addr_base
- info1
->addr_base
;
6676 /* Display the debug_addr section. */
6678 display_debug_addr (struct dwarf_section
*section
,
6681 debug_info
**debug_addr_info
;
6682 unsigned char *entry
;
6687 if (section
->size
== 0)
6689 printf (_("\nThe %s section is empty.\n"), section
->name
);
6693 if (load_debug_info (file
) == 0)
6695 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6700 introduce (section
, FALSE
);
6702 /* PR 17531: file: cf38d01b.
6703 We use xcalloc because a corrupt file may not have initialised all of the
6704 fields in the debug_info structure, which means that the sort below might
6705 try to move uninitialised data. */
6706 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6707 sizeof (debug_info
*));
6710 for (i
= 0; i
< num_debug_info_entries
; i
++)
6711 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6713 /* PR 17531: file: cf38d01b. */
6714 if (debug_information
[i
].addr_base
>= section
->size
)
6715 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6716 (unsigned long) debug_information
[i
].addr_base
, i
);
6718 debug_addr_info
[count
++] = debug_information
+ i
;
6721 /* Add a sentinel to make iteration convenient. */
6722 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6723 debug_addr_info
[count
]->addr_base
= section
->size
;
6724 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6726 for (i
= 0; i
< count
; i
++)
6729 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6731 printf (_(" For compilation unit at offset 0x%s:\n"),
6732 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6734 printf (_("\tIndex\tAddress\n"));
6735 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6736 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6740 dwarf_vma base
= byte_get (entry
, address_size
);
6741 printf (_("\t%d:\t"), idx
);
6742 print_dwarf_vma (base
, address_size
);
6744 entry
+= address_size
;
6750 free (debug_addr_info
);
6754 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6757 display_debug_str_offsets (struct dwarf_section
*section
,
6758 void *file ATTRIBUTE_UNUSED
)
6760 if (section
->size
== 0)
6762 printf (_("\nThe %s section is empty.\n"), section
->name
);
6765 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6766 what the offset size is for this section. */
6770 /* Each debug_information[x].range_lists[y] gets this representation for
6771 sorting purposes. */
6775 /* The debug_information[x].range_lists[y] value. */
6776 dwarf_vma ranges_offset
;
6778 /* Original debug_information to find parameters of the data. */
6779 debug_info
*debug_info_p
;
6782 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6785 range_entry_compar (const void *ap
, const void *bp
)
6787 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6788 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6789 const dwarf_vma a
= a_re
->ranges_offset
;
6790 const dwarf_vma b
= b_re
->ranges_offset
;
6792 return (a
> b
) - (b
> a
);
6796 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6797 unsigned int pointer_size
, unsigned long offset
,
6798 unsigned long base_address
)
6800 while (start
< finish
)
6805 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6806 if (start
>= finish
)
6808 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6811 printf (" %8.8lx ", offset
);
6813 if (begin
== 0 && end
== 0)
6815 printf (_("<End of list>\n"));
6819 /* Check base address specifiers. */
6820 if (is_max_address (begin
, pointer_size
)
6821 && !is_max_address (end
, pointer_size
))
6824 print_dwarf_vma (begin
, pointer_size
);
6825 print_dwarf_vma (end
, pointer_size
);
6826 printf ("(base address)\n");
6830 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6831 print_dwarf_vma (end
+ base_address
, pointer_size
);
6834 fputs (_("(start == end)"), stdout
);
6835 else if (begin
> end
)
6836 fputs (_("(start > end)"), stdout
);
6843 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
6844 unsigned int pointer_size
, unsigned long offset
,
6845 unsigned long base_address
)
6847 unsigned char *next
= start
;
6851 unsigned long off
= offset
+ (start
- next
);
6852 enum dwarf_range_list_entry rlet
;
6853 /* Initialize it due to a false compiler warning. */
6854 dwarf_vma begin
= -1, length
, end
= -1;
6856 if (start
+ 1 > finish
)
6858 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6863 printf (" %8.8lx ", off
);
6865 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
6869 case DW_RLE_end_of_list
:
6870 printf (_("<End of list>\n"));
6872 case DW_RLE_base_address
:
6873 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
6874 print_dwarf_vma (base_address
, pointer_size
);
6875 printf (_("(base address)\n"));
6877 case DW_RLE_start_length
:
6878 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6879 READ_ULEB (length
, start
, finish
);
6880 end
= begin
+ length
;
6882 case DW_RLE_offset_pair
:
6883 READ_ULEB (begin
, start
, finish
);
6884 READ_ULEB (end
, start
, finish
);
6886 case DW_RLE_start_end
:
6887 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6888 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6891 error (_("Invalid range list entry type %d\n"), rlet
);
6892 rlet
= DW_RLE_end_of_list
;
6895 if (rlet
== DW_RLE_end_of_list
)
6897 if (rlet
== DW_RLE_base_address
)
6900 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6901 print_dwarf_vma (end
+ base_address
, pointer_size
);
6904 fputs (_("(start == end)"), stdout
);
6905 else if (begin
> end
)
6906 fputs (_("(start > end)"), stdout
);
6913 display_debug_ranges (struct dwarf_section
*section
,
6914 void *file ATTRIBUTE_UNUSED
)
6916 unsigned char *start
= section
->start
;
6917 unsigned char *last_start
= start
;
6918 unsigned long bytes
= section
->size
;
6919 unsigned char *section_begin
= start
;
6920 unsigned char *finish
= start
+ bytes
;
6921 unsigned int num_range_list
, i
;
6922 struct range_entry
*range_entries
, *range_entry_fill
;
6923 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
6924 /* Initialize it due to a false compiler warning. */
6925 unsigned char address_size
= 0;
6926 dwarf_vma last_offset
= 0;
6930 printf (_("\nThe %s section is empty.\n"), section
->name
);
6936 dwarf_vma initial_length
;
6937 unsigned int initial_length_size
;
6938 unsigned char segment_selector_size
;
6939 unsigned int offset_size
, offset_entry_count
;
6940 unsigned short version
;
6942 /* Get and check the length of the block. */
6943 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
6945 if (initial_length
== 0xffffffff)
6947 /* This section is 64-bit DWARF 3. */
6948 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
6950 initial_length_size
= 12;
6955 initial_length_size
= 4;
6958 if (initial_length
+ initial_length_size
> section
->size
)
6960 /* If the length field has a relocation against it, then we should
6961 not complain if it is inaccurate (and probably negative).
6962 It is copied from .debug_line handling code. */
6963 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
6965 initial_length
= (finish
- start
) - initial_length_size
;
6969 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6970 (long) initial_length
);
6975 /* Get and check the version number. */
6976 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
6980 warn (_("Only DWARF version 5 debug_rnglists info "
6981 "is currently supported.\n"));
6985 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
6987 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
6988 if (segment_selector_size
!= 0)
6990 warn (_("The %s section contains "
6991 "unsupported segment selector size: %d.\n"),
6992 section
->name
, segment_selector_size
);
6996 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
6997 if (offset_entry_count
!= 0)
6999 warn (_("The %s section contains "
7000 "unsupported offset entry count: %u.\n"),
7001 section
->name
, offset_entry_count
);
7006 if (load_debug_info (file
) == 0)
7008 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7014 for (i
= 0; i
< num_debug_info_entries
; i
++)
7015 num_range_list
+= debug_information
[i
].num_range_lists
;
7017 if (num_range_list
== 0)
7019 /* This can happen when the file was compiled with -gsplit-debug
7020 which removes references to range lists from the primary .o file. */
7021 printf (_("No range lists in .debug_info section.\n"));
7025 range_entries
= (struct range_entry
*)
7026 xmalloc (sizeof (*range_entries
) * num_range_list
);
7027 range_entry_fill
= range_entries
;
7029 for (i
= 0; i
< num_debug_info_entries
; i
++)
7031 debug_info
*debug_info_p
= &debug_information
[i
];
7034 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7036 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7037 range_entry_fill
->debug_info_p
= debug_info_p
;
7042 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7043 range_entry_compar
);
7045 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7046 warn (_("Range lists in %s section start at 0x%lx\n"),
7047 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7049 introduce (section
, FALSE
);
7051 printf (_(" Offset Begin End\n"));
7053 for (i
= 0; i
< num_range_list
; i
++)
7055 struct range_entry
*range_entry
= &range_entries
[i
];
7056 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7057 unsigned int pointer_size
;
7059 unsigned char *next
;
7060 dwarf_vma base_address
;
7062 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7063 offset
= range_entry
->ranges_offset
;
7064 next
= section_begin
+ offset
;
7065 base_address
= debug_info_p
->base_address
;
7067 /* PR 17512: file: 001-101485-0.001:0.1. */
7068 if (pointer_size
< 2 || pointer_size
> 8)
7070 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7071 pointer_size
, (unsigned long) offset
);
7075 if (next
< section_begin
|| next
>= finish
)
7077 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7078 (unsigned long) offset
, i
);
7082 /* If multiple DWARF entities reference the same range then we will
7083 have multiple entries in the `range_entries' list for the same
7084 offset. Thanks to the sort above these will all be consecutive in
7085 the `range_entries' list, so we can easily ignore duplicates
7087 if (i
> 0 && last_offset
== offset
)
7089 last_offset
= offset
;
7091 if (dwarf_check
!= 0 && i
> 0)
7094 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7095 (unsigned long) (start
- section_begin
),
7096 (unsigned long) (next
- section_begin
), section
->name
);
7097 else if (start
> next
)
7099 if (next
== last_start
)
7101 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7102 (unsigned long) (start
- section_begin
),
7103 (unsigned long) (next
- section_begin
), section
->name
);
7110 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7111 (start
, finish
, pointer_size
, offset
, base_address
);
7115 free (range_entries
);
7120 typedef struct Frame_Chunk
7122 struct Frame_Chunk
*next
;
7123 unsigned char *chunk_start
;
7125 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7126 short int *col_type
;
7129 unsigned int code_factor
;
7133 unsigned int cfa_reg
;
7134 dwarf_vma cfa_offset
;
7136 unsigned char fde_encoding
;
7137 unsigned char cfa_exp
;
7138 unsigned char ptr_size
;
7139 unsigned char segment_size
;
7143 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7144 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7145 static const char *const *dwarf_regnames
;
7146 static unsigned int dwarf_regnames_count
;
7149 /* A marker for a col_type that means this column was never referenced
7150 in the frame info. */
7151 #define DW_CFA_unreferenced (-1)
7153 /* Return 0 if no more space is needed, 1 if more space is needed,
7154 -1 for invalid reg. */
7157 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7159 unsigned int prev
= fc
->ncols
;
7161 if (reg
< (unsigned int) fc
->ncols
)
7164 if (dwarf_regnames_count
> 0
7165 && reg
> dwarf_regnames_count
)
7168 fc
->ncols
= reg
+ 1;
7169 /* PR 17512: file: 10450-2643-0.004.
7170 If reg == -1 then this can happen... */
7174 /* PR 17512: file: 2844a11d. */
7175 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7177 error (_("Unfeasibly large register number: %u\n"), reg
);
7179 /* FIXME: 1024 is an arbitrary limit. Increase it if
7180 we ever encounter a valid binary that exceeds it. */
7184 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7185 sizeof (short int));
7186 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7187 /* PR 17512: file:002-10025-0.005. */
7188 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7190 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7196 while (prev
< fc
->ncols
)
7198 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7199 fc
->col_offset
[prev
] = 0;
7205 static const char *const dwarf_regnames_i386
[] =
7207 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7208 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7209 "eip", "eflags", NULL
, /* 8 - 10 */
7210 "st0", "st1", "st2", "st3", /* 11 - 14 */
7211 "st4", "st5", "st6", "st7", /* 15 - 18 */
7212 NULL
, NULL
, /* 19 - 20 */
7213 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7214 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7215 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7216 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7217 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7218 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7219 "tr", "ldtr", /* 48 - 49 */
7220 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7221 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7222 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7223 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7224 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7225 NULL
, NULL
, NULL
, /* 90 - 92 */
7226 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7229 static const char *const dwarf_regnames_iamcu
[] =
7231 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7232 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7233 "eip", "eflags", NULL
, /* 8 - 10 */
7234 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7235 NULL
, NULL
, /* 19 - 20 */
7236 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7237 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7238 NULL
, NULL
, NULL
, /* 37 - 39 */
7239 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7240 "tr", "ldtr", /* 48 - 49 */
7241 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7242 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7243 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7244 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7245 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7246 NULL
, NULL
, NULL
, /* 90 - 92 */
7247 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7251 init_dwarf_regnames_i386 (void)
7253 dwarf_regnames
= dwarf_regnames_i386
;
7254 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7255 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7259 init_dwarf_regnames_iamcu (void)
7261 dwarf_regnames
= dwarf_regnames_iamcu
;
7262 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7263 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7266 static const char *const dwarf_regnames_x86_64
[] =
7268 "rax", "rdx", "rcx", "rbx",
7269 "rsi", "rdi", "rbp", "rsp",
7270 "r8", "r9", "r10", "r11",
7271 "r12", "r13", "r14", "r15",
7273 "xmm0", "xmm1", "xmm2", "xmm3",
7274 "xmm4", "xmm5", "xmm6", "xmm7",
7275 "xmm8", "xmm9", "xmm10", "xmm11",
7276 "xmm12", "xmm13", "xmm14", "xmm15",
7277 "st0", "st1", "st2", "st3",
7278 "st4", "st5", "st6", "st7",
7279 "mm0", "mm1", "mm2", "mm3",
7280 "mm4", "mm5", "mm6", "mm7",
7282 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7283 "fs.base", "gs.base", NULL
, NULL
,
7285 "mxcsr", "fcw", "fsw",
7286 "xmm16", "xmm17", "xmm18", "xmm19",
7287 "xmm20", "xmm21", "xmm22", "xmm23",
7288 "xmm24", "xmm25", "xmm26", "xmm27",
7289 "xmm28", "xmm29", "xmm30", "xmm31",
7290 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7291 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7292 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7293 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7294 NULL
, NULL
, NULL
, /* 115 - 117 */
7295 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7299 init_dwarf_regnames_x86_64 (void)
7301 dwarf_regnames
= dwarf_regnames_x86_64
;
7302 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7303 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7306 static const char *const dwarf_regnames_aarch64
[] =
7308 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7309 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7310 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7311 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7312 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7313 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7314 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7315 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7316 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7317 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7318 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7319 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7320 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7321 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7322 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7323 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7327 init_dwarf_regnames_aarch64 (void)
7329 dwarf_regnames
= dwarf_regnames_aarch64
;
7330 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7331 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7334 static const char *const dwarf_regnames_s390
[] =
7336 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7337 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7338 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7339 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7340 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7341 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7342 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7343 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7344 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7347 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7348 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7352 init_dwarf_regnames_s390 (void)
7354 dwarf_regnames
= dwarf_regnames_s390
;
7355 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7356 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7359 static const char *const dwarf_regnames_riscv
[] =
7361 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7362 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7363 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7364 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7365 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7366 "fs0", "fs1", /* 40 - 41 */
7367 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7368 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7369 "fs10", "fs11", /* 58 - 59 */
7370 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7373 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
7374 the large number of CSRs. */
7377 regname_internal_riscv (unsigned int regno
)
7379 const char *name
= NULL
;
7381 /* Lookup in the table first, this covers GPR and FPR. */
7382 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
7383 name
= dwarf_regnames_riscv
[regno
];
7384 else if (regno
>= 4096 && regno
<= 8191)
7386 /* This might be a CSR, these live in a sparse number space from 4096
7387 to 8191 These numbers are defined in the RISC-V ELF ABI
7391 #define DECLARE_CSR(NAME,VALUE,CLASS) case VALUE + 4096: name = #NAME; break;
7392 #include "opcode/riscv-opc.h"
7397 static char csr_name
[10];
7398 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
7409 init_dwarf_regnames_riscv (void)
7411 dwarf_regnames
= NULL
;
7412 dwarf_regnames_count
= 8192;
7413 dwarf_regnames_lookup_func
= regname_internal_riscv
;
7417 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
7419 dwarf_regnames_lookup_func
= NULL
;
7424 init_dwarf_regnames_i386 ();
7428 init_dwarf_regnames_iamcu ();
7434 init_dwarf_regnames_x86_64 ();
7438 init_dwarf_regnames_aarch64 ();
7442 init_dwarf_regnames_s390 ();
7446 init_dwarf_regnames_riscv ();
7454 /* Initialize the DWARF register name lookup state based on the
7455 architecture and specific machine type of a BFD. */
7458 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
7461 dwarf_regnames_lookup_func
= NULL
;
7468 case bfd_mach_x86_64
:
7469 case bfd_mach_x86_64_intel_syntax
:
7470 case bfd_mach_x86_64_nacl
:
7471 case bfd_mach_x64_32
:
7472 case bfd_mach_x64_32_intel_syntax
:
7473 case bfd_mach_x64_32_nacl
:
7474 init_dwarf_regnames_x86_64 ();
7478 init_dwarf_regnames_i386 ();
7483 case bfd_arch_iamcu
:
7484 init_dwarf_regnames_iamcu ();
7487 case bfd_arch_aarch64
:
7488 init_dwarf_regnames_aarch64();
7492 init_dwarf_regnames_s390 ();
7495 case bfd_arch_riscv
:
7496 init_dwarf_regnames_riscv ();
7505 regname_internal_by_table_only (unsigned int regno
)
7507 if (dwarf_regnames
!= NULL
7508 && regno
< dwarf_regnames_count
7509 && dwarf_regnames
[regno
] != NULL
)
7510 return dwarf_regnames
[regno
];
7516 regname (unsigned int regno
, int name_only_p
)
7518 static char reg
[64];
7520 const char *name
= NULL
;
7522 if (dwarf_regnames_lookup_func
!= NULL
)
7523 name
= dwarf_regnames_lookup_func (regno
);
7529 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
7532 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7537 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7542 if (*max_regs
!= fc
->ncols
)
7543 *max_regs
= fc
->ncols
;
7545 if (*need_col_headers
)
7547 static const char *sloc
= " LOC";
7549 *need_col_headers
= 0;
7551 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7553 for (r
= 0; r
< *max_regs
; r
++)
7554 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7559 printf ("%-5s ", regname (r
, 1));
7565 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7567 strcpy (tmp
, "exp");
7569 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7570 printf ("%-8s ", tmp
);
7572 for (r
= 0; r
< fc
->ncols
; r
++)
7574 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7576 switch (fc
->col_type
[r
])
7578 case DW_CFA_undefined
:
7581 case DW_CFA_same_value
:
7585 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7587 case DW_CFA_val_offset
:
7588 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7590 case DW_CFA_register
:
7591 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7593 case DW_CFA_expression
:
7594 strcpy (tmp
, "exp");
7596 case DW_CFA_val_expression
:
7597 strcpy (tmp
, "vexp");
7600 strcpy (tmp
, "n/a");
7603 printf ("%-5s ", tmp
);
7609 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7611 static unsigned char *
7612 read_cie (unsigned char *start
, unsigned char *end
,
7613 Frame_Chunk
**p_cie
, int *p_version
,
7614 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7618 unsigned char *augmentation_data
= NULL
;
7619 bfd_size_type augmentation_data_len
= 0;
7622 /* PR 17512: file: 001-228113-0.004. */
7626 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7627 memset (fc
, 0, sizeof (Frame_Chunk
));
7629 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7630 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7634 fc
->augmentation
= (char *) start
;
7635 /* PR 17512: file: 001-228113-0.004.
7636 Skip past augmentation name, but avoid running off the end of the data. */
7638 if (* start
++ == '\0')
7642 warn (_("No terminator for augmentation name\n"));
7646 if (strcmp (fc
->augmentation
, "eh") == 0)
7647 start
+= eh_addr_size
;
7651 GET (fc
->ptr_size
, 1);
7652 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7654 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7658 GET (fc
->segment_size
, 1);
7659 /* PR 17512: file: e99d2804. */
7660 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7662 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7666 eh_addr_size
= fc
->ptr_size
;
7670 fc
->ptr_size
= eh_addr_size
;
7671 fc
->segment_size
= 0;
7674 READ_ULEB (fc
->code_factor
, start
, end
);
7675 READ_SLEB (fc
->data_factor
, start
, end
);
7683 READ_ULEB (fc
->ra
, start
, end
);
7686 if (fc
->augmentation
[0] == 'z')
7688 READ_ULEB (augmentation_data_len
, start
, end
);
7689 augmentation_data
= start
;
7690 /* PR 17512: file: 11042-2589-0.004. */
7691 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7693 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7694 dwarf_vmatoa ("x", augmentation_data_len
),
7695 (unsigned long) (end
- start
));
7698 start
+= augmentation_data_len
;
7701 if (augmentation_data_len
)
7705 unsigned char *qend
;
7707 p
= (unsigned char *) fc
->augmentation
+ 1;
7708 q
= augmentation_data
;
7709 qend
= q
+ augmentation_data_len
;
7711 while (p
< end
&& q
< qend
)
7716 q
+= 1 + size_of_encoded_value (*q
);
7718 fc
->fde_encoding
= *q
++;
7727 /* Note - it is OK if this loop terminates with q < qend.
7728 Padding may have been inserted to align the end of the CIE. */
7733 *p_version
= version
;
7736 *p_aug_len
= augmentation_data_len
;
7737 *p_aug
= augmentation_data
;
7742 free (fc
->col_offset
);
7743 free (fc
->col_type
);
7748 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7749 If do_wide is not enabled, then formats the output to fit into 80 columns.
7750 PRINTED contains the number of characters already written to the current
7754 display_data (bfd_size_type printed
,
7755 const unsigned char * data
,
7756 const bfd_size_type len
)
7758 if (do_wide
|| len
< ((80 - printed
) / 3))
7759 for (printed
= 0; printed
< len
; ++printed
)
7760 printf (" %02x", data
[printed
]);
7763 for (printed
= 0; printed
< len
; ++printed
)
7765 if (printed
% (80 / 3) == 0)
7767 printf (" %02x", data
[printed
]);
7772 /* Prints out the contents on the augmentation data array.
7773 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7776 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7780 i
= printf (_(" Augmentation data: "));
7781 display_data (i
, data
, len
);
7785 display_debug_frames (struct dwarf_section
*section
,
7786 void *file ATTRIBUTE_UNUSED
)
7788 unsigned char *start
= section
->start
;
7789 unsigned char *end
= start
+ section
->size
;
7790 unsigned char *section_start
= start
;
7791 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7792 Frame_Chunk
*remembered_state
= NULL
;
7794 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7795 unsigned int max_regs
= 0;
7796 const char *bad_reg
= _("bad register: ");
7797 unsigned int saved_eh_addr_size
= eh_addr_size
;
7799 introduce (section
, FALSE
);
7803 unsigned char *saved_start
;
7804 unsigned char *block_end
;
7809 int need_col_headers
= 1;
7810 unsigned char *augmentation_data
= NULL
;
7811 bfd_size_type augmentation_data_len
= 0;
7812 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7813 unsigned int offset_size
;
7814 unsigned int initial_length_size
;
7815 bfd_boolean all_nops
;
7816 static Frame_Chunk fde_fc
;
7818 saved_start
= start
;
7820 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7824 printf ("\n%08lx ZERO terminator\n\n",
7825 (unsigned long)(saved_start
- section_start
));
7826 /* Skip any zero terminators that directly follow.
7827 A corrupt section size could have loaded a whole
7828 slew of zero filled memory bytes. eg
7829 PR 17512: file: 070-19381-0.004. */
7830 while (start
< end
&& * start
== 0)
7835 if (length
== 0xffffffff)
7837 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7839 initial_length_size
= 12;
7844 initial_length_size
= 4;
7847 block_end
= saved_start
+ length
+ initial_length_size
;
7848 if (block_end
> end
|| block_end
< start
)
7850 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7851 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7852 (unsigned long) (saved_start
- section_start
));
7856 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7858 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7859 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7864 start
= read_cie (start
, end
, &cie
, &version
,
7865 &augmentation_data_len
, &augmentation_data
);
7866 /* PR 17512: file: 027-135133-0.005. */
7873 fc
->chunk_start
= saved_start
;
7874 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7877 if (frame_need_space (fc
, mreg
) < 0)
7879 if (fc
->fde_encoding
)
7880 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7882 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7883 print_dwarf_vma (length
, fc
->ptr_size
);
7884 print_dwarf_vma (cie_id
, offset_size
);
7886 if (do_debug_frames_interp
)
7888 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7889 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7894 printf (" Version: %d\n", version
);
7895 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7898 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7899 printf (" Segment Size: %u\n", fc
->segment_size
);
7901 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7902 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7903 printf (" Return address column: %d\n", fc
->ra
);
7905 if (augmentation_data_len
)
7906 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7913 unsigned char *look_for
;
7914 unsigned long segment_selector
;
7918 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7919 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7922 look_for
= section_start
+ cie_id
;
7924 if (look_for
<= saved_start
)
7926 for (cie
= chunks
; cie
; cie
= cie
->next
)
7927 if (cie
->chunk_start
== look_for
)
7932 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7933 if (cie
->chunk_start
== look_for
)
7937 unsigned int off_size
;
7938 unsigned char *cie_scan
;
7940 cie_scan
= look_for
;
7942 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7943 if (length
== 0xffffffff)
7945 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7952 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7955 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7956 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7961 read_cie (cie_scan
, end
, &cie
, &version
,
7962 &augmentation_data_len
, &augmentation_data
);
7963 /* PR 17512: file: 3450-2098-0.004. */
7966 warn (_("Failed to read CIE information\n"));
7969 cie
->next
= forward_refs
;
7971 cie
->chunk_start
= look_for
;
7972 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7975 if (frame_need_space (cie
, mreg
) < 0)
7977 warn (_("Invalid max register\n"));
7980 if (cie
->fde_encoding
)
7982 = size_of_encoded_value (cie
->fde_encoding
);
7989 memset (fc
, 0, sizeof (Frame_Chunk
));
7993 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7994 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7995 (unsigned long) (saved_start
- section_start
));
7997 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7998 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7999 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8001 warn (_("Invalid max register\n"));
8005 fc
->augmentation
= "";
8006 fc
->fde_encoding
= 0;
8007 fc
->ptr_size
= eh_addr_size
;
8008 fc
->segment_size
= 0;
8012 fc
->ncols
= cie
->ncols
;
8013 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8014 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8015 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8016 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8017 fc
->augmentation
= cie
->augmentation
;
8018 fc
->ptr_size
= cie
->ptr_size
;
8019 eh_addr_size
= cie
->ptr_size
;
8020 fc
->segment_size
= cie
->segment_size
;
8021 fc
->code_factor
= cie
->code_factor
;
8022 fc
->data_factor
= cie
->data_factor
;
8023 fc
->cfa_reg
= cie
->cfa_reg
;
8024 fc
->cfa_offset
= cie
->cfa_offset
;
8026 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8028 warn (_("Invalid max register\n"));
8031 fc
->fde_encoding
= cie
->fde_encoding
;
8034 if (fc
->fde_encoding
)
8035 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8037 segment_selector
= 0;
8038 if (fc
->segment_size
)
8040 if (fc
->segment_size
> sizeof (segment_selector
))
8042 /* PR 17512: file: 9e196b3e. */
8043 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8044 fc
->segment_size
= 4;
8046 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8049 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8051 /* FIXME: It appears that sometimes the final pc_range value is
8052 encoded in less than encoded_ptr_size bytes. See the x86_64
8053 run of the "objcopy on compressed debug sections" test for an
8055 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8057 if (cie
->augmentation
[0] == 'z')
8059 READ_ULEB (augmentation_data_len
, start
, end
);
8060 augmentation_data
= start
;
8061 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8062 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8064 warn (_("Augmentation data too long: 0x%s, "
8065 "expected at most %#lx\n"),
8066 dwarf_vmatoa ("x", augmentation_data_len
),
8067 (unsigned long) (end
- start
));
8069 augmentation_data
= NULL
;
8070 augmentation_data_len
= 0;
8072 start
+= augmentation_data_len
;
8075 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8076 (unsigned long)(saved_start
- section_start
),
8077 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8078 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8079 (unsigned long)(cie
->chunk_start
- section_start
));
8081 if (fc
->segment_size
)
8082 printf ("%04lx:", segment_selector
);
8085 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8086 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8088 if (! do_debug_frames_interp
&& augmentation_data_len
)
8090 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8095 /* At this point, fc is the current chunk, cie (if any) is set, and
8096 we're about to interpret instructions for the chunk. */
8097 /* ??? At present we need to do this always, since this sizes the
8098 fc->col_type and fc->col_offset arrays, which we write into always.
8099 We should probably split the interpreted and non-interpreted bits
8100 into two different routines, since there's so much that doesn't
8101 really overlap between them. */
8102 if (1 || do_debug_frames_interp
)
8104 /* Start by making a pass over the chunk, allocating storage
8105 and taking note of what registers are used. */
8106 unsigned char *tmp
= start
;
8108 while (start
< block_end
)
8110 unsigned int reg
, op
, opa
;
8112 unsigned char * new_start
;
8119 /* Warning: if you add any more cases to this switch, be
8120 sure to add them to the corresponding switch below. */
8123 case DW_CFA_advance_loc
:
8126 SKIP_ULEB (start
, end
);
8127 if (frame_need_space (fc
, opa
) >= 0)
8128 fc
->col_type
[opa
] = DW_CFA_undefined
;
8130 case DW_CFA_restore
:
8131 if (frame_need_space (fc
, opa
) >= 0)
8132 fc
->col_type
[opa
] = DW_CFA_undefined
;
8134 case DW_CFA_set_loc
:
8135 start
+= encoded_ptr_size
;
8137 case DW_CFA_advance_loc1
:
8140 case DW_CFA_advance_loc2
:
8143 case DW_CFA_advance_loc4
:
8146 case DW_CFA_offset_extended
:
8147 case DW_CFA_val_offset
:
8148 READ_ULEB (reg
, start
, end
);
8149 SKIP_ULEB (start
, end
);
8150 if (frame_need_space (fc
, reg
) >= 0)
8151 fc
->col_type
[reg
] = DW_CFA_undefined
;
8153 case DW_CFA_restore_extended
:
8154 READ_ULEB (reg
, start
, end
);
8155 if (frame_need_space (fc
, reg
) >= 0)
8156 fc
->col_type
[reg
] = DW_CFA_undefined
;
8158 case DW_CFA_undefined
:
8159 READ_ULEB (reg
, start
, end
);
8160 if (frame_need_space (fc
, reg
) >= 0)
8161 fc
->col_type
[reg
] = DW_CFA_undefined
;
8163 case DW_CFA_same_value
:
8164 READ_ULEB (reg
, start
, end
);
8165 if (frame_need_space (fc
, reg
) >= 0)
8166 fc
->col_type
[reg
] = DW_CFA_undefined
;
8168 case DW_CFA_register
:
8169 READ_ULEB (reg
, start
, end
);
8170 SKIP_ULEB (start
, end
);
8171 if (frame_need_space (fc
, reg
) >= 0)
8172 fc
->col_type
[reg
] = DW_CFA_undefined
;
8174 case DW_CFA_def_cfa
:
8175 SKIP_ULEB (start
, end
);
8176 SKIP_ULEB (start
, end
);
8178 case DW_CFA_def_cfa_register
:
8179 SKIP_ULEB (start
, end
);
8181 case DW_CFA_def_cfa_offset
:
8182 SKIP_ULEB (start
, end
);
8184 case DW_CFA_def_cfa_expression
:
8185 READ_ULEB (temp
, start
, end
);
8186 new_start
= start
+ temp
;
8187 if (new_start
< start
)
8189 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8195 case DW_CFA_expression
:
8196 case DW_CFA_val_expression
:
8197 READ_ULEB (reg
, start
, end
);
8198 READ_ULEB (temp
, start
, end
);
8199 new_start
= start
+ temp
;
8200 if (new_start
< start
)
8202 /* PR 17512: file:306-192417-0.005. */
8203 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8208 if (frame_need_space (fc
, reg
) >= 0)
8209 fc
->col_type
[reg
] = DW_CFA_undefined
;
8211 case DW_CFA_offset_extended_sf
:
8212 case DW_CFA_val_offset_sf
:
8213 READ_ULEB (reg
, start
, end
);
8214 SKIP_SLEB (start
, end
);
8215 if (frame_need_space (fc
, reg
) >= 0)
8216 fc
->col_type
[reg
] = DW_CFA_undefined
;
8218 case DW_CFA_def_cfa_sf
:
8219 SKIP_ULEB (start
, end
);
8220 SKIP_SLEB (start
, end
);
8222 case DW_CFA_def_cfa_offset_sf
:
8223 SKIP_SLEB (start
, end
);
8225 case DW_CFA_MIPS_advance_loc8
:
8228 case DW_CFA_GNU_args_size
:
8229 SKIP_ULEB (start
, end
);
8231 case DW_CFA_GNU_negative_offset_extended
:
8232 READ_ULEB (reg
, start
, end
);
8233 SKIP_ULEB (start
, end
);
8234 if (frame_need_space (fc
, reg
) >= 0)
8235 fc
->col_type
[reg
] = DW_CFA_undefined
;
8246 /* Now we know what registers are used, make a second pass over
8247 the chunk, this time actually printing out the info. */
8249 while (start
< block_end
)
8251 unsigned char * tmp
;
8253 unsigned long ul
, roffs
;
8254 /* Note: It is tempting to use an unsigned long for 'reg' but there
8255 are various functions, notably frame_space_needed() that assume that
8256 reg is an unsigned int. */
8261 const char *reg_prefix
= "";
8268 /* Make a note if something other than DW_CFA_nop happens. */
8269 if (op
!= DW_CFA_nop
)
8272 /* Warning: if you add any more cases to this switch, be
8273 sure to add them to the corresponding switch above. */
8276 case DW_CFA_advance_loc
:
8277 if (do_debug_frames_interp
)
8278 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8280 printf (" DW_CFA_advance_loc: %d to %s\n",
8281 opa
* fc
->code_factor
,
8282 dwarf_vmatoa_1 (NULL
,
8283 fc
->pc_begin
+ opa
* fc
->code_factor
,
8285 fc
->pc_begin
+= opa
* fc
->code_factor
;
8289 READ_ULEB (roffs
, start
, end
);
8290 if (opa
>= (unsigned int) fc
->ncols
)
8291 reg_prefix
= bad_reg
;
8292 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8293 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8294 reg_prefix
, regname (opa
, 0),
8295 roffs
* fc
->data_factor
);
8296 if (*reg_prefix
== '\0')
8298 fc
->col_type
[opa
] = DW_CFA_offset
;
8299 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8303 case DW_CFA_restore
:
8304 if (opa
>= (unsigned int) fc
->ncols
)
8305 reg_prefix
= bad_reg
;
8306 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8307 printf (" DW_CFA_restore: %s%s\n",
8308 reg_prefix
, regname (opa
, 0));
8309 if (*reg_prefix
!= '\0')
8312 if (opa
>= (unsigned int) cie
->ncols
8313 || (do_debug_frames_interp
8314 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8316 fc
->col_type
[opa
] = DW_CFA_undefined
;
8317 fc
->col_offset
[opa
] = 0;
8321 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8322 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8326 case DW_CFA_set_loc
:
8327 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8328 if (do_debug_frames_interp
)
8329 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8331 printf (" DW_CFA_set_loc: %s\n",
8332 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8336 case DW_CFA_advance_loc1
:
8337 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8338 if (do_debug_frames_interp
)
8339 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8341 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8342 (unsigned long) (ofs
* fc
->code_factor
),
8343 dwarf_vmatoa_1 (NULL
,
8344 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8346 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8349 case DW_CFA_advance_loc2
:
8350 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8351 if (do_debug_frames_interp
)
8352 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8354 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8355 (unsigned long) (ofs
* fc
->code_factor
),
8356 dwarf_vmatoa_1 (NULL
,
8357 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8359 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8362 case DW_CFA_advance_loc4
:
8363 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8364 if (do_debug_frames_interp
)
8365 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8367 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8368 (unsigned long) (ofs
* fc
->code_factor
),
8369 dwarf_vmatoa_1 (NULL
,
8370 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8372 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8375 case DW_CFA_offset_extended
:
8376 READ_ULEB (reg
, start
, end
);
8377 READ_ULEB (roffs
, start
, end
);
8378 if (reg
>= (unsigned int) fc
->ncols
)
8379 reg_prefix
= bad_reg
;
8380 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8381 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8382 reg_prefix
, regname (reg
, 0),
8383 roffs
* fc
->data_factor
);
8384 if (*reg_prefix
== '\0')
8386 fc
->col_type
[reg
] = DW_CFA_offset
;
8387 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8391 case DW_CFA_val_offset
:
8392 READ_ULEB (reg
, start
, end
);
8393 READ_ULEB (roffs
, start
, end
);
8394 if (reg
>= (unsigned int) fc
->ncols
)
8395 reg_prefix
= bad_reg
;
8396 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8397 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8398 reg_prefix
, regname (reg
, 0),
8399 roffs
* fc
->data_factor
);
8400 if (*reg_prefix
== '\0')
8402 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8403 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8407 case DW_CFA_restore_extended
:
8408 READ_ULEB (reg
, start
, end
);
8409 if (reg
>= (unsigned int) fc
->ncols
)
8410 reg_prefix
= bad_reg
;
8411 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8412 printf (" DW_CFA_restore_extended: %s%s\n",
8413 reg_prefix
, regname (reg
, 0));
8414 if (*reg_prefix
!= '\0')
8417 if (reg
>= (unsigned int) cie
->ncols
)
8419 fc
->col_type
[reg
] = DW_CFA_undefined
;
8420 fc
->col_offset
[reg
] = 0;
8424 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8425 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8429 case DW_CFA_undefined
:
8430 READ_ULEB (reg
, start
, end
);
8431 if (reg
>= (unsigned int) fc
->ncols
)
8432 reg_prefix
= bad_reg
;
8433 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8434 printf (" DW_CFA_undefined: %s%s\n",
8435 reg_prefix
, regname (reg
, 0));
8436 if (*reg_prefix
== '\0')
8438 fc
->col_type
[reg
] = DW_CFA_undefined
;
8439 fc
->col_offset
[reg
] = 0;
8443 case DW_CFA_same_value
:
8444 READ_ULEB (reg
, start
, end
);
8445 if (reg
>= (unsigned int) fc
->ncols
)
8446 reg_prefix
= bad_reg
;
8447 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8448 printf (" DW_CFA_same_value: %s%s\n",
8449 reg_prefix
, regname (reg
, 0));
8450 if (*reg_prefix
== '\0')
8452 fc
->col_type
[reg
] = DW_CFA_same_value
;
8453 fc
->col_offset
[reg
] = 0;
8457 case DW_CFA_register
:
8458 READ_ULEB (reg
, start
, end
);
8459 READ_ULEB (roffs
, start
, end
);
8460 if (reg
>= (unsigned int) fc
->ncols
)
8461 reg_prefix
= bad_reg
;
8462 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8464 printf (" DW_CFA_register: %s%s in ",
8465 reg_prefix
, regname (reg
, 0));
8466 puts (regname (roffs
, 0));
8468 if (*reg_prefix
== '\0')
8470 fc
->col_type
[reg
] = DW_CFA_register
;
8471 fc
->col_offset
[reg
] = roffs
;
8475 case DW_CFA_remember_state
:
8476 if (! do_debug_frames_interp
)
8477 printf (" DW_CFA_remember_state\n");
8478 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8479 rs
->cfa_offset
= fc
->cfa_offset
;
8480 rs
->cfa_reg
= fc
->cfa_reg
;
8482 rs
->cfa_exp
= fc
->cfa_exp
;
8483 rs
->ncols
= fc
->ncols
;
8484 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8485 sizeof (* rs
->col_type
));
8486 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8487 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8488 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8489 rs
->next
= remembered_state
;
8490 remembered_state
= rs
;
8493 case DW_CFA_restore_state
:
8494 if (! do_debug_frames_interp
)
8495 printf (" DW_CFA_restore_state\n");
8496 rs
= remembered_state
;
8499 remembered_state
= rs
->next
;
8500 fc
->cfa_offset
= rs
->cfa_offset
;
8501 fc
->cfa_reg
= rs
->cfa_reg
;
8503 fc
->cfa_exp
= rs
->cfa_exp
;
8504 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8506 warn (_("Invalid column number in saved frame state\n"));
8510 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8511 memcpy (fc
->col_offset
, rs
->col_offset
,
8512 rs
->ncols
* sizeof (* rs
->col_offset
));
8513 free (rs
->col_type
);
8514 free (rs
->col_offset
);
8517 else if (do_debug_frames_interp
)
8518 printf ("Mismatched DW_CFA_restore_state\n");
8521 case DW_CFA_def_cfa
:
8522 READ_ULEB (fc
->cfa_reg
, start
, end
);
8523 READ_ULEB (fc
->cfa_offset
, start
, end
);
8525 if (! do_debug_frames_interp
)
8526 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8527 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8530 case DW_CFA_def_cfa_register
:
8531 READ_ULEB (fc
->cfa_reg
, start
, end
);
8533 if (! do_debug_frames_interp
)
8534 printf (" DW_CFA_def_cfa_register: %s\n",
8535 regname (fc
->cfa_reg
, 0));
8538 case DW_CFA_def_cfa_offset
:
8539 READ_ULEB (fc
->cfa_offset
, start
, end
);
8540 if (! do_debug_frames_interp
)
8541 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8545 if (! do_debug_frames_interp
)
8546 printf (" DW_CFA_nop\n");
8549 case DW_CFA_def_cfa_expression
:
8550 READ_ULEB (ul
, start
, end
);
8551 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8553 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8556 if (! do_debug_frames_interp
)
8558 printf (" DW_CFA_def_cfa_expression (");
8559 decode_location_expression (start
, eh_addr_size
, 0, -1,
8567 case DW_CFA_expression
:
8568 READ_ULEB (reg
, start
, end
);
8569 READ_ULEB (ul
, start
, end
);
8570 if (reg
>= (unsigned int) fc
->ncols
)
8571 reg_prefix
= bad_reg
;
8572 /* PR 17512: file: 069-133014-0.006. */
8573 /* PR 17512: file: 98c02eb4. */
8575 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8577 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8580 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8582 printf (" DW_CFA_expression: %s%s (",
8583 reg_prefix
, regname (reg
, 0));
8584 decode_location_expression (start
, eh_addr_size
, 0, -1,
8588 if (*reg_prefix
== '\0')
8589 fc
->col_type
[reg
] = DW_CFA_expression
;
8593 case DW_CFA_val_expression
:
8594 READ_ULEB (reg
, start
, end
);
8595 READ_ULEB (ul
, start
, end
);
8596 if (reg
>= (unsigned int) fc
->ncols
)
8597 reg_prefix
= bad_reg
;
8599 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8601 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8604 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8606 printf (" DW_CFA_val_expression: %s%s (",
8607 reg_prefix
, regname (reg
, 0));
8608 decode_location_expression (start
, eh_addr_size
, 0, -1,
8612 if (*reg_prefix
== '\0')
8613 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8617 case DW_CFA_offset_extended_sf
:
8618 READ_ULEB (reg
, start
, end
);
8619 READ_SLEB (l
, start
, end
);
8620 if (frame_need_space (fc
, reg
) < 0)
8621 reg_prefix
= bad_reg
;
8622 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8623 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8624 reg_prefix
, regname (reg
, 0),
8625 (long)(l
* fc
->data_factor
));
8626 if (*reg_prefix
== '\0')
8628 fc
->col_type
[reg
] = DW_CFA_offset
;
8629 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8633 case DW_CFA_val_offset_sf
:
8634 READ_ULEB (reg
, start
, end
);
8635 READ_SLEB (l
, start
, end
);
8636 if (frame_need_space (fc
, reg
) < 0)
8637 reg_prefix
= bad_reg
;
8638 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8639 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8640 reg_prefix
, regname (reg
, 0),
8641 (long)(l
* fc
->data_factor
));
8642 if (*reg_prefix
== '\0')
8644 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8645 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8649 case DW_CFA_def_cfa_sf
:
8650 READ_ULEB (fc
->cfa_reg
, start
, end
);
8651 READ_ULEB (fc
->cfa_offset
, start
, end
);
8652 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8654 if (! do_debug_frames_interp
)
8655 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8656 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8659 case DW_CFA_def_cfa_offset_sf
:
8660 READ_ULEB (fc
->cfa_offset
, start
, end
);
8661 fc
->cfa_offset
*= fc
->data_factor
;
8662 if (! do_debug_frames_interp
)
8663 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8666 case DW_CFA_MIPS_advance_loc8
:
8667 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8668 if (do_debug_frames_interp
)
8669 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8671 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8672 (unsigned long) (ofs
* fc
->code_factor
),
8673 dwarf_vmatoa_1 (NULL
,
8674 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8676 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8679 case DW_CFA_GNU_window_save
:
8680 if (! do_debug_frames_interp
)
8681 printf (" DW_CFA_GNU_window_save\n");
8684 case DW_CFA_GNU_args_size
:
8685 READ_ULEB (ul
, start
, end
);
8686 if (! do_debug_frames_interp
)
8687 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8690 case DW_CFA_GNU_negative_offset_extended
:
8691 READ_ULEB (reg
, start
, end
);
8692 READ_SLEB (l
, start
, end
);
8694 if (frame_need_space (fc
, reg
) < 0)
8695 reg_prefix
= bad_reg
;
8696 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8697 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8698 reg_prefix
, regname (reg
, 0),
8699 (long)(l
* fc
->data_factor
));
8700 if (*reg_prefix
== '\0')
8702 fc
->col_type
[reg
] = DW_CFA_offset
;
8703 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8708 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8709 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8711 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8716 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8717 if (do_debug_frames_interp
&& ! all_nops
)
8718 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8720 if (fde_fc
.col_type
!= NULL
)
8722 free (fde_fc
.col_type
);
8723 fde_fc
.col_type
= NULL
;
8725 if (fde_fc
.col_offset
!= NULL
)
8727 free (fde_fc
.col_offset
);
8728 fde_fc
.col_offset
= NULL
;
8732 eh_addr_size
= saved_eh_addr_size
;
8737 while (remembered_state
!= NULL
)
8739 rs
= remembered_state
;
8740 remembered_state
= rs
->next
;
8741 free (rs
->col_type
);
8742 free (rs
->col_offset
);
8743 rs
->next
= NULL
; /* Paranoia. */
8747 while (chunks
!= NULL
)
8751 free (rs
->col_type
);
8752 free (rs
->col_offset
);
8753 rs
->next
= NULL
; /* Paranoia. */
8757 while (forward_refs
!= NULL
)
8760 forward_refs
= rs
->next
;
8761 free (rs
->col_type
);
8762 free (rs
->col_offset
);
8763 rs
->next
= NULL
; /* Paranoia. */
8773 display_debug_names (struct dwarf_section
*section
, void *file
)
8775 unsigned char *hdrptr
= section
->start
;
8776 dwarf_vma unit_length
;
8777 unsigned char *unit_start
;
8778 const unsigned char *const section_end
= section
->start
+ section
->size
;
8779 unsigned char *unit_end
;
8781 introduce (section
, FALSE
);
8783 load_debug_section_with_follow (str
, file
);
8785 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8787 unsigned int offset_size
;
8788 uint16_t dwarf_version
, padding
;
8789 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8790 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8791 uint32_t augmentation_string_size
;
8793 unsigned long sec_off
;
8794 bfd_boolean augmentation_printable
;
8795 const char *augmentation_string
;
8797 unit_start
= hdrptr
;
8799 /* Get and check the length of the block. */
8800 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8802 if (unit_length
== 0xffffffff)
8804 /* This section is 64-bit DWARF. */
8805 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8810 unit_end
= hdrptr
+ unit_length
;
8812 sec_off
= hdrptr
- section
->start
;
8813 if (sec_off
+ unit_length
< sec_off
8814 || sec_off
+ unit_length
> section
->size
)
8816 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8818 (unsigned long) (unit_start
- section
->start
),
8819 dwarf_vmatoa ("x", unit_length
));
8823 /* Get and check the version number. */
8824 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8825 printf (_("Version %ld\n"), (long) dwarf_version
);
8827 /* Prior versions did not exist, and future versions may not be
8828 backwards compatible. */
8829 if (dwarf_version
!= 5)
8831 warn (_("Only DWARF version 5 .debug_names "
8832 "is currently supported.\n"));
8836 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8838 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8841 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8842 if (comp_unit_count
== 0)
8843 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8845 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8846 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8847 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8848 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8849 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8851 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8852 if (augmentation_string_size
% 4 != 0)
8854 warn (_("Augmentation string length %u must be rounded up "
8855 "to a multiple of 4 in .debug_names.\n"),
8856 augmentation_string_size
);
8857 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8860 printf (_("Augmentation string:"));
8862 augmentation_printable
= TRUE
;
8863 augmentation_string
= (const char *) hdrptr
;
8865 for (i
= 0; i
< augmentation_string_size
; i
++)
8869 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8870 printf (" %02x", uc
);
8872 if (uc
!= 0 && !ISPRINT (uc
))
8873 augmentation_printable
= FALSE
;
8876 if (augmentation_printable
)
8880 i
< augmentation_string_size
&& augmentation_string
[i
];
8882 putchar (augmentation_string
[i
]);
8887 printf (_("CU table:\n"));
8888 for (i
= 0; i
< comp_unit_count
; i
++)
8892 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8893 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8897 printf (_("TU table:\n"));
8898 for (i
= 0; i
< local_type_unit_count
; i
++)
8902 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8903 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8907 printf (_("Foreign TU table:\n"));
8908 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8912 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8913 printf (_("[%3u] "), i
);
8914 print_dwarf_vma (signature
, 8);
8919 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8920 hdrptr
+= bucket_count
* sizeof (uint32_t);
8921 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8922 hdrptr
+= name_count
* sizeof (uint32_t);
8923 unsigned char *const name_table_string_offsets
= hdrptr
;
8924 hdrptr
+= name_count
* offset_size
;
8925 unsigned char *const name_table_entry_offsets
= hdrptr
;
8926 hdrptr
+= name_count
* offset_size
;
8927 unsigned char *const abbrev_table
= hdrptr
;
8928 hdrptr
+= abbrev_table_size
;
8929 const unsigned char *const abbrev_table_end
= hdrptr
;
8930 unsigned char *const entry_pool
= hdrptr
;
8931 if (hdrptr
> unit_end
)
8933 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8934 "for unit 0x%lx in the debug_names\n"),
8935 (long) (hdrptr
- section
->start
),
8936 (long) (unit_end
- section
->start
),
8937 (long) (unit_start
- section
->start
));
8941 size_t buckets_filled
= 0;
8943 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8945 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8950 printf (ngettext ("Used %zu of %lu bucket.\n",
8951 "Used %zu of %lu buckets.\n",
8953 buckets_filled
, (unsigned long) bucket_count
);
8955 uint32_t hash_prev
= 0;
8956 size_t hash_clash_count
= 0;
8957 size_t longest_clash
= 0;
8958 size_t this_length
= 0;
8960 for (hashi
= 0; hashi
< name_count
; hashi
++)
8962 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8966 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8970 longest_clash
= MAX (longest_clash
, this_length
);
8975 hash_prev
= hash_this
;
8977 printf (_("Out of %lu items there are %zu bucket clashes"
8978 " (longest of %zu entries).\n"),
8979 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
8980 assert (name_count
== buckets_filled
+ hash_clash_count
);
8982 struct abbrev_lookup_entry
8984 dwarf_vma abbrev_tag
;
8985 unsigned char *abbrev_lookup_ptr
;
8987 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
8988 size_t abbrev_lookup_used
= 0;
8989 size_t abbrev_lookup_allocated
= 0;
8991 unsigned char *abbrevptr
= abbrev_table
;
8994 dwarf_vma abbrev_tag
;
8996 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
8997 if (abbrev_tag
== 0)
8999 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9001 abbrev_lookup_allocated
= MAX (0x100,
9002 abbrev_lookup_allocated
* 2);
9003 abbrev_lookup
= xrealloc (abbrev_lookup
,
9004 (abbrev_lookup_allocated
9005 * sizeof (*abbrev_lookup
)));
9007 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9008 struct abbrev_lookup_entry
*entry
;
9009 for (entry
= abbrev_lookup
;
9010 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9012 if (entry
->abbrev_tag
== abbrev_tag
)
9014 warn (_("Duplicate abbreviation tag %lu "
9015 "in unit 0x%lx in the debug_names\n"),
9016 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9019 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9020 entry
->abbrev_tag
= abbrev_tag
;
9021 entry
->abbrev_lookup_ptr
= abbrevptr
;
9023 /* Skip DWARF tag. */
9024 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9027 dwarf_vma xindex
, form
;
9029 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9030 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9031 if (xindex
== 0 && form
== 0)
9036 printf (_("\nSymbol table:\n"));
9038 for (namei
= 0; namei
< name_count
; ++namei
)
9040 uint64_t string_offset
, entry_offset
;
9042 SAFE_BYTE_GET (string_offset
,
9043 name_table_string_offsets
+ namei
* offset_size
,
9044 offset_size
, unit_end
);
9045 SAFE_BYTE_GET (entry_offset
,
9046 name_table_entry_offsets
+ namei
* offset_size
,
9047 offset_size
, unit_end
);
9049 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9050 fetch_indirect_string (string_offset
));
9052 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9054 // We need to scan first whether there is a single or multiple
9055 // entries. TAGNO is -2 for the first entry, it is -1 for the
9056 // initial tag read of the second entry, then it becomes 0 for the
9057 // first entry for real printing etc.
9059 /* Initialize it due to a false compiler warning. */
9060 dwarf_vma second_abbrev_tag
= -1;
9063 dwarf_vma abbrev_tag
;
9064 dwarf_vma dwarf_tag
;
9065 const struct abbrev_lookup_entry
*entry
;
9067 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9070 second_abbrev_tag
= abbrev_tag
;
9072 entryptr
= entry_pool
+ entry_offset
;
9075 if (abbrev_tag
== 0)
9079 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9080 (unsigned long) abbrev_tag
);
9082 for (entry
= abbrev_lookup
;
9083 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9085 if (entry
->abbrev_tag
== abbrev_tag
)
9087 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9089 warn (_("Undefined abbreviation tag %lu "
9090 "in unit 0x%lx in the debug_names\n"),
9092 (long) (unit_start
- section
->start
));
9095 abbrevptr
= entry
->abbrev_lookup_ptr
;
9096 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9098 printf (" %s", get_TAG_name (dwarf_tag
));
9101 dwarf_vma xindex
, form
;
9103 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9104 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9105 if (xindex
== 0 && form
== 0)
9109 printf (" %s", get_IDX_name (xindex
));
9110 entryptr
= read_and_display_attr_value (0, form
, 0,
9111 unit_start
, entryptr
, unit_end
,
9113 dwarf_version
, NULL
,
9120 printf (_(" <no entries>"));
9124 free (abbrev_lookup
);
9131 display_debug_links (struct dwarf_section
* section
,
9132 void * file ATTRIBUTE_UNUSED
)
9134 const unsigned char * filename
;
9135 unsigned int filelen
;
9137 introduce (section
, FALSE
);
9139 /* The .gnu_debuglink section is formatted as:
9140 (c-string) Filename.
9141 (padding) If needed to reach a 4 byte boundary.
9142 (uint32_t) CRC32 value.
9144 The .gun_debugaltlink section is formatted as:
9145 (c-string) Filename.
9146 (binary) Build-ID. */
9148 filename
= section
->start
;
9149 filelen
= strnlen ((const char *) filename
, section
->size
);
9150 if (filelen
== section
->size
)
9152 warn (_("The debuglink filename is corrupt/missing\n"));
9156 printf (_(" Separate debug info file: %s\n"), filename
);
9158 if (const_strneq (section
->name
, ".gnu_debuglink"))
9161 unsigned int crc_offset
;
9163 crc_offset
= filelen
+ 1;
9164 crc_offset
= (crc_offset
+ 3) & ~3;
9165 if (crc_offset
+ 4 > section
->size
)
9167 warn (_("CRC offset missing/truncated\n"));
9171 crc32
= byte_get (filename
+ crc_offset
, 4);
9173 printf (_(" CRC value: %#x\n"), crc32
);
9175 if (crc_offset
+ 4 < section
->size
)
9177 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9178 (long)(section
->size
- (crc_offset
+ 4)));
9182 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9184 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9185 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9186 bfd_size_type printed
;
9188 /* FIXME: Should we support smaller build-id notes ? */
9189 if (build_id_len
< 0x14)
9191 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9195 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9196 display_data (printed
, build_id
, build_id_len
);
9205 display_gdb_index (struct dwarf_section
*section
,
9206 void *file ATTRIBUTE_UNUSED
)
9208 unsigned char *start
= section
->start
;
9210 uint32_t cu_list_offset
, tu_list_offset
;
9211 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9212 unsigned int cu_list_elements
, tu_list_elements
;
9213 unsigned int address_table_size
, symbol_table_slots
;
9214 unsigned char *cu_list
, *tu_list
;
9215 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9218 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9220 introduce (section
, FALSE
);
9222 if (section
->size
< 6 * sizeof (uint32_t))
9224 warn (_("Truncated header in the %s section.\n"), section
->name
);
9228 version
= byte_get_little_endian (start
, 4);
9229 printf (_("Version %ld\n"), (long) version
);
9231 /* Prior versions are obsolete, and future versions may not be
9232 backwards compatible. */
9233 if (version
< 3 || version
> 8)
9235 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9239 warn (_("The address table data in version 3 may be wrong.\n"));
9241 warn (_("Version 4 does not support case insensitive lookups.\n"));
9243 warn (_("Version 5 does not include inlined functions.\n"));
9245 warn (_("Version 6 does not include symbol attributes.\n"));
9246 /* Version 7 indices generated by Gold have bad type unit references,
9247 PR binutils/15021. But we don't know if the index was generated by
9248 Gold or not, so to avoid worrying users with gdb-generated indices
9249 we say nothing for version 7 here. */
9251 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9252 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9253 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9254 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9255 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9257 if (cu_list_offset
> section
->size
9258 || tu_list_offset
> section
->size
9259 || address_table_offset
> section
->size
9260 || symbol_table_offset
> section
->size
9261 || constant_pool_offset
> section
->size
)
9263 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9267 /* PR 17531: file: 418d0a8a. */
9268 if (tu_list_offset
< cu_list_offset
)
9270 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9271 tu_list_offset
, cu_list_offset
);
9275 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9277 if (address_table_offset
< tu_list_offset
)
9279 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9280 address_table_offset
, tu_list_offset
);
9284 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9286 /* PR 17531: file: 18a47d3d. */
9287 if (symbol_table_offset
< address_table_offset
)
9289 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9290 symbol_table_offset
, address_table_offset
);
9294 address_table_size
= symbol_table_offset
- address_table_offset
;
9296 if (constant_pool_offset
< symbol_table_offset
)
9298 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9299 constant_pool_offset
, symbol_table_offset
);
9303 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9305 cu_list
= start
+ cu_list_offset
;
9306 tu_list
= start
+ tu_list_offset
;
9307 address_table
= start
+ address_table_offset
;
9308 symbol_table
= start
+ symbol_table_offset
;
9309 constant_pool
= start
+ constant_pool_offset
;
9311 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9313 warn (_("Address table extends beyond end of section.\n"));
9317 printf (_("\nCU table:\n"));
9318 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9320 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9321 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9323 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9324 (unsigned long) cu_offset
,
9325 (unsigned long) (cu_offset
+ cu_length
- 1));
9328 printf (_("\nTU table:\n"));
9329 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9331 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9332 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9333 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9335 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9336 (unsigned long) tu_offset
,
9337 (unsigned long) type_offset
);
9338 print_dwarf_vma (signature
, 8);
9342 printf (_("\nAddress table:\n"));
9343 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9346 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9347 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9348 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9350 print_dwarf_vma (low
, 8);
9351 print_dwarf_vma (high
, 8);
9352 printf (_("%lu\n"), (unsigned long) cu_index
);
9355 printf (_("\nSymbol table:\n"));
9356 for (i
= 0; i
< symbol_table_slots
; ++i
)
9358 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9359 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9360 uint32_t num_cus
, cu
;
9362 if (name_offset
!= 0
9363 || cu_vector_offset
!= 0)
9366 unsigned char * adr
;
9368 adr
= constant_pool
+ name_offset
;
9369 /* PR 17531: file: 5b7b07ad. */
9370 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9372 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9373 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9377 printf ("[%3u] %.*s:", i
,
9378 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9379 constant_pool
+ name_offset
);
9381 adr
= constant_pool
+ cu_vector_offset
;
9382 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9384 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9385 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9386 cu_vector_offset
, i
);
9390 num_cus
= byte_get_little_endian (adr
, 4);
9392 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9393 if (num_cus
* 4 < num_cus
9394 || adr
>= section
->start
+ section
->size
9395 || adr
< constant_pool
)
9397 printf ("<invalid number of CUs: %d>\n", num_cus
);
9398 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9406 for (j
= 0; j
< num_cus
; ++j
)
9409 gdb_index_symbol_kind kind
;
9411 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9412 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9413 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9414 cu
= GDB_INDEX_CU_VALUE (cu
);
9415 /* Convert to TU number if it's for a type unit. */
9416 if (cu
>= cu_list_elements
/ 2)
9417 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9418 (unsigned long) (cu
- cu_list_elements
/ 2));
9420 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9422 printf (" [%s, %s]",
9423 is_static
? _("static") : _("global"),
9424 get_gdb_index_symbol_kind_name (kind
));
9436 /* Pre-allocate enough space for the CU/TU sets needed. */
9439 prealloc_cu_tu_list (unsigned int nshndx
)
9441 if (shndx_pool
== NULL
)
9443 shndx_pool_size
= nshndx
;
9444 shndx_pool_used
= 0;
9445 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9446 sizeof (unsigned int));
9450 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9451 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9452 sizeof (unsigned int));
9457 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9459 if (shndx_pool_used
>= shndx_pool_size
)
9461 error (_("Internal error: out of space in the shndx pool.\n"));
9464 shndx_pool
[shndx_pool_used
++] = shndx
;
9468 end_cu_tu_entry (void)
9470 if (shndx_pool_used
>= shndx_pool_size
)
9472 error (_("Internal error: out of space in the shndx pool.\n"));
9475 shndx_pool
[shndx_pool_used
++] = 0;
9478 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9481 get_DW_SECT_short_name (unsigned int dw_sect
)
9483 static char buf
[16];
9491 case DW_SECT_ABBREV
:
9497 case DW_SECT_STR_OFFSETS
:
9499 case DW_SECT_MACINFO
:
9507 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9511 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9512 These sections are extensions for Fission.
9513 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9516 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9518 unsigned char *phdr
= section
->start
;
9519 unsigned char *limit
= phdr
+ section
->size
;
9520 unsigned char *phash
;
9521 unsigned char *pindex
;
9522 unsigned char *ppool
;
9523 unsigned int version
;
9524 unsigned int ncols
= 0;
9526 unsigned int nslots
;
9529 dwarf_vma signature_high
;
9530 dwarf_vma signature_low
;
9533 /* PR 17512: file: 002-168123-0.004. */
9536 warn (_("Section %s is empty\n"), section
->name
);
9539 /* PR 17512: file: 002-376-0.004. */
9540 if (section
->size
< 24)
9542 warn (_("Section %s is too small to contain a CU/TU header\n"),
9547 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9549 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9550 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9551 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9554 pindex
= phash
+ (size_t) nslots
* 8;
9555 ppool
= pindex
+ (size_t) nslots
* 4;
9559 introduce (section
, FALSE
);
9561 printf (_(" Version: %u\n"), version
);
9563 printf (_(" Number of columns: %u\n"), ncols
);
9564 printf (_(" Number of used entries: %u\n"), nused
);
9565 printf (_(" Number of slots: %u\n\n"), nslots
);
9568 /* PR 17531: file: 45d69832. */
9569 if ((size_t) nslots
* 8 / 8 != nslots
9570 || phash
< phdr
|| phash
> limit
9571 || pindex
< phash
|| pindex
> limit
9572 || ppool
< pindex
|| ppool
> limit
)
9574 warn (ngettext ("Section %s is too small for %u slot\n",
9575 "Section %s is too small for %u slots\n",
9577 section
->name
, nslots
);
9584 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9585 for (i
= 0; i
< nslots
; i
++)
9587 unsigned char *shndx_list
;
9590 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9591 if (signature_high
!= 0 || signature_low
!= 0)
9593 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9594 shndx_list
= ppool
+ j
* 4;
9595 /* PR 17531: file: 705e010d. */
9596 if (shndx_list
< ppool
)
9598 warn (_("Section index pool located before start of section\n"));
9603 printf (_(" [%3d] Signature: 0x%s Sections: "),
9604 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9605 buf
, sizeof (buf
)));
9608 if (shndx_list
>= limit
)
9610 warn (_("Section %s too small for shndx pool\n"),
9614 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9618 printf (" %d", shndx
);
9620 add_shndx_to_cu_tu_entry (shndx
);
9632 else if (version
== 2)
9635 unsigned int dw_sect
;
9636 unsigned char *ph
= phash
;
9637 unsigned char *pi
= pindex
;
9638 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
9639 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
9640 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
9641 bfd_boolean is_tu_index
;
9642 struct cu_tu_set
*this_set
= NULL
;
9644 unsigned char *prow
;
9646 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9648 /* PR 17531: file: 0dd159bf.
9649 Check for integer overflow (can occur when size_t is 32-bit)
9650 with overlarge ncols or nused values. */
9652 && ((size_t) ncols
* 4 / 4 != ncols
9653 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
9654 || poffsets
< ppool
|| poffsets
> limit
9655 || psizes
< poffsets
|| psizes
> limit
9656 || pend
< psizes
|| pend
> limit
))
9658 warn (_("Section %s too small for offset and size tables\n"),
9665 printf (_(" Offset table\n"));
9666 printf (" slot %-16s ",
9667 is_tu_index
? _("signature") : _("dwo_id"));
9674 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9680 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9687 for (j
= 0; j
< ncols
; j
++)
9689 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9690 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9695 for (i
= 0; i
< nslots
; i
++)
9697 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9699 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9702 /* PR 17531: file: a05f6ab3. */
9705 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9712 size_t num_copy
= sizeof (uint64_t);
9714 /* PR 23064: Beware of buffer overflow. */
9715 if (ph
+ num_copy
< limit
)
9716 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9719 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9724 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9725 /* PR 17531: file: b8ce60a8. */
9726 if (prow
< poffsets
|| prow
> limit
)
9728 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9734 printf (_(" [%3d] 0x%s"),
9735 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9736 buf
, sizeof (buf
)));
9737 for (j
= 0; j
< ncols
; j
++)
9739 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9741 printf (" %8d", val
);
9744 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9746 /* PR 17531: file: 10796eb3. */
9747 if (dw_sect
>= DW_SECT_MAX
)
9748 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9750 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9766 printf (_(" Size table\n"));
9767 printf (" slot %-16s ",
9768 is_tu_index
? _("signature") : _("dwo_id"));
9771 for (j
= 0; j
< ncols
; j
++)
9773 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9775 printf (" %8s", get_DW_SECT_short_name (val
));
9781 for (i
= 0; i
< nslots
; i
++)
9783 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9785 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9788 prow
= psizes
+ (row
- 1) * ncols
* 4;
9791 printf (_(" [%3d] 0x%s"),
9792 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9793 buf
, sizeof (buf
)));
9795 for (j
= 0; j
< ncols
; j
++)
9797 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9799 printf (" %8d", val
);
9802 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9803 if (dw_sect
>= DW_SECT_MAX
)
9804 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9806 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9818 else if (do_display
)
9819 printf (_(" Unsupported version (%d)\n"), version
);
9827 /* Load the CU and TU indexes if present. This will build a list of
9828 section sets that we can use to associate a .debug_info.dwo section
9829 with its associated .debug_abbrev.dwo section in a .dwp file. */
9832 load_cu_tu_indexes (void *file
)
9834 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
9836 /* If we have already loaded (or tried to load) the CU and TU indexes
9837 then do not bother to repeat the task. */
9838 if (cu_tu_indexes_read
== -1)
9840 cu_tu_indexes_read
= TRUE
;
9842 if (load_debug_section_with_follow (dwp_cu_index
, file
))
9843 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
9844 cu_tu_indexes_read
= FALSE
;
9846 if (load_debug_section_with_follow (dwp_tu_index
, file
))
9847 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
9848 cu_tu_indexes_read
= FALSE
;
9851 return (bfd_boolean
) cu_tu_indexes_read
;
9854 /* Find the set of sections that includes section SHNDX. */
9857 find_cu_tu_set (void *file
, unsigned int shndx
)
9861 if (! load_cu_tu_indexes (file
))
9864 /* Find SHNDX in the shndx pool. */
9865 for (i
= 0; i
< shndx_pool_used
; i
++)
9866 if (shndx_pool
[i
] == shndx
)
9869 if (i
>= shndx_pool_used
)
9872 /* Now backup to find the first entry in the set. */
9873 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9876 return shndx_pool
+ i
;
9879 /* Display a .debug_cu_index or .debug_tu_index section. */
9882 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9884 return process_cu_tu_index (section
, 1);
9888 display_debug_not_supported (struct dwarf_section
*section
,
9889 void *file ATTRIBUTE_UNUSED
)
9891 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9897 /* Like malloc, but takes two parameters like calloc.
9898 Verifies that the first parameter is not too large.
9899 Note: does *not* initialise the allocated memory to zero. */
9902 cmalloc (size_t nmemb
, size_t size
)
9904 /* Check for overflow. */
9905 if (nmemb
>= ~(size_t) 0 / size
)
9908 return xmalloc (nmemb
* size
);
9911 /* Like xmalloc, but takes two parameters like calloc.
9912 Verifies that the first parameter is not too large.
9913 Note: does *not* initialise the allocated memory to zero. */
9916 xcmalloc (size_t nmemb
, size_t size
)
9918 /* Check for overflow. */
9919 if (nmemb
>= ~(size_t) 0 / size
)
9922 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9927 return xmalloc (nmemb
* size
);
9930 /* Like xrealloc, but takes three parameters.
9931 Verifies that the second parameter is not too large.
9932 Note: does *not* initialise any new memory to zero. */
9935 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9937 /* Check for overflow. */
9938 if (nmemb
>= ~(size_t) 0 / size
)
9940 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9945 return xrealloc (ptr
, nmemb
* size
);
9948 /* Like xcalloc, but verifies that the first parameter is not too large. */
9951 xcalloc2 (size_t nmemb
, size_t size
)
9953 /* Check for overflow. */
9954 if (nmemb
>= ~(size_t) 0 / size
)
9956 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9961 return xcalloc (nmemb
, size
);
9964 static unsigned long
9965 calc_gnu_debuglink_crc32 (unsigned long crc
,
9966 const unsigned char * buf
,
9969 static const unsigned long crc32_table
[256] =
9971 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
9972 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
9973 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
9974 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
9975 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
9976 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
9977 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
9978 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
9979 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
9980 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
9981 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
9982 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
9983 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
9984 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
9985 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
9986 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
9987 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
9988 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
9989 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
9990 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
9991 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
9992 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
9993 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
9994 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
9995 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
9996 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
9997 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
9998 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
9999 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10000 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10001 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10002 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10003 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10004 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10005 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10006 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10007 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10008 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10009 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10010 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10011 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10012 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10013 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10014 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10015 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10016 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10017 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10018 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10019 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10020 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10021 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10024 const unsigned char *end
;
10026 crc
= ~crc
& 0xffffffff;
10027 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10028 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10029 return ~crc
& 0xffffffff;
10032 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10033 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10036 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10038 static unsigned char buffer
[8 * 1024];
10040 bfd_size_type count
;
10041 unsigned long crc
= 0;
10044 sep_data
= open_debug_file (pathname
);
10045 if (sep_data
== NULL
)
10048 /* Yes - we are opening the file twice... */
10049 f
= fopen (pathname
, "rb");
10052 /* Paranoia: This should never happen. */
10053 close_debug_file (sep_data
);
10054 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10058 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10059 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10063 if (crc
!= * (unsigned long *) crc_pointer
)
10065 close_debug_file (sep_data
);
10066 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10074 static const char *
10075 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10078 unsigned int crc_offset
;
10079 unsigned long * crc32
= (unsigned long *) data
;
10081 /* The name is first.
10082 The CRC value is stored after the filename, aligned up to 4 bytes. */
10083 name
= (const char *) section
->start
;
10086 crc_offset
= strnlen (name
, section
->size
) + 1;
10087 crc_offset
= (crc_offset
+ 3) & ~3;
10088 if (crc_offset
+ 4 > section
->size
)
10091 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10096 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10098 void * sep_data
= open_debug_file (filename
);
10100 if (sep_data
== NULL
)
10103 /* FIXME: We should now extract the build-id in the separate file
10109 typedef struct build_id_data
10112 const unsigned char * data
;
10115 static const char *
10116 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10119 bfd_size_type namelen
;
10120 bfd_size_type id_len
;
10121 Build_id_data
* build_id_data
;
10123 /* The name is first.
10124 The build-id follows immediately, with no padding, up to the section's end. */
10126 name
= (const char *) section
->start
;
10127 namelen
= strnlen (name
, section
->size
) + 1;
10128 if (namelen
>= section
->size
)
10131 id_len
= section
->size
- namelen
;
10135 build_id_data
= calloc (1, sizeof * build_id_data
);
10136 if (build_id_data
== NULL
)
10139 build_id_data
->len
= id_len
;
10140 build_id_data
->data
= section
->start
+ namelen
;
10142 * (Build_id_data
**) data
= build_id_data
;
10148 add_separate_debug_file (const char * filename
, void * handle
)
10150 separate_info
* i
= xmalloc (sizeof * i
);
10152 i
->filename
= filename
;
10153 i
->handle
= handle
;
10154 i
->next
= first_separate_info
;
10155 first_separate_info
= i
;
10158 #if HAVE_LIBDEBUGINFOD
10159 /* Query debuginfod servers for the target debuglink or debugaltlink
10160 file. If successful, store the path of the file in filename and
10161 return TRUE, otherwise return FALSE. */
10164 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10168 size_t build_id_len
;
10169 unsigned char * build_id
;
10171 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10173 /* Get the build-id of file. */
10174 build_id
= get_build_id (file
);
10177 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10179 /* Get the build-id of the debugaltlink file. */
10180 unsigned int filelen
;
10182 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10183 if (filelen
== section
->size
)
10184 /* Corrupt debugaltlink. */
10187 build_id
= section
->start
+ filelen
+ 1;
10188 build_id_len
= section
->size
- (filelen
+ 1);
10190 if (build_id_len
== 0)
10199 debuginfod_client
* client
;
10201 client
= debuginfod_begin ();
10202 if (client
== NULL
)
10205 /* Query debuginfod servers for the target file. If found its path
10206 will be stored in filename. */
10207 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10208 debuginfod_end (client
);
10210 /* Only free build_id if we allocated space for a hex string
10211 in get_build_id (). */
10212 if (build_id_len
== 0)
10217 /* File successfully retrieved. Close fd since we want to
10218 use open_debug_file () on filename instead. */
10229 load_separate_debug_info (const char * main_filename
,
10230 struct dwarf_section
* xlink
,
10231 parse_func_type parse_func
,
10232 check_func_type check_func
,
10234 void * file ATTRIBUTE_UNUSED
)
10236 const char * separate_filename
;
10237 char * debug_filename
;
10239 size_t canon_dirlen
;
10242 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10244 warn (_("Corrupt debuglink section: %s\n"),
10245 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10249 /* Attempt to locate the separate file.
10250 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10252 canon_dir
= lrealpath (main_filename
);
10254 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10255 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10257 canon_dir
[canon_dirlen
] = '\0';
10260 #define DEBUGDIR "/lib/debug"
10262 #ifndef EXTRA_DEBUG_ROOT1
10263 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10265 #ifndef EXTRA_DEBUG_ROOT2
10266 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10269 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10271 + strlen (".debug/")
10272 #ifdef EXTRA_DEBUG_ROOT1
10273 + strlen (EXTRA_DEBUG_ROOT1
)
10275 #ifdef EXTRA_DEBUG_ROOT2
10276 + strlen (EXTRA_DEBUG_ROOT2
)
10278 + strlen (separate_filename
)
10280 if (debug_filename
== NULL
)
10282 warn (_("Out of memory"));
10287 /* First try in the current directory. */
10288 sprintf (debug_filename
, "%s", separate_filename
);
10289 if (check_func (debug_filename
, func_data
))
10292 /* Then try in a subdirectory called .debug. */
10293 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10294 if (check_func (debug_filename
, func_data
))
10297 /* Then try in the same directory as the original file. */
10298 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10299 if (check_func (debug_filename
, func_data
))
10302 /* And the .debug subdirectory of that directory. */
10303 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10304 if (check_func (debug_filename
, func_data
))
10307 #ifdef EXTRA_DEBUG_ROOT1
10308 /* Try the first extra debug file root. */
10309 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10310 if (check_func (debug_filename
, func_data
))
10313 /* Try the first extra debug file root. */
10314 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10315 if (check_func (debug_filename
, func_data
))
10319 #ifdef EXTRA_DEBUG_ROOT2
10320 /* Try the second extra debug file root. */
10321 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10322 if (check_func (debug_filename
, func_data
))
10326 /* Then try in the global debug_filename directory. */
10327 strcpy (debug_filename
, DEBUGDIR
);
10328 dirlen
= strlen (DEBUGDIR
) - 1;
10329 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10330 strcat (debug_filename
, "/");
10331 strcat (debug_filename
, (const char *) separate_filename
);
10333 if (check_func (debug_filename
, func_data
))
10336 #if HAVE_LIBDEBUGINFOD
10338 char * tmp_filename
;
10340 if (debuginfod_fetch_separate_debug_info (xlink
,
10344 /* File successfully downloaded from server, replace
10345 debug_filename with the file's path. */
10346 free (debug_filename
);
10347 debug_filename
= tmp_filename
;
10353 /* Failed to find the file. */
10354 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10355 warn (_("tried: %s\n"), debug_filename
);
10357 #ifdef EXTRA_DEBUG_ROOT2
10358 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10359 warn (_("tried: %s\n"), debug_filename
);
10362 #ifdef EXTRA_DEBUG_ROOT1
10363 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10364 warn (_("tried: %s\n"), debug_filename
);
10366 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10367 warn (_("tried: %s\n"), debug_filename
);
10370 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10371 warn (_("tried: %s\n"), debug_filename
);
10373 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10374 warn (_("tried: %s\n"), debug_filename
);
10376 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10377 warn (_("tried: %s\n"), debug_filename
);
10379 sprintf (debug_filename
, "%s", separate_filename
);
10380 warn (_("tried: %s\n"), debug_filename
);
10382 #if HAVE_LIBDEBUGINFOD
10384 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
10388 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
10393 free (debug_filename
);
10399 void * debug_handle
;
10401 /* Now open the file.... */
10402 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
10404 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
10405 free (debug_filename
);
10409 /* FIXME: We do not check to see if there are any other separate debug info
10410 files that would also match. */
10412 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
10413 add_separate_debug_file (debug_filename
, debug_handle
);
10415 /* Do not free debug_filename - it might be referenced inside
10416 the structure returned by open_debug_file(). */
10417 return debug_handle
;
10420 /* Attempt to load a separate dwarf object file. */
10423 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
10425 char * separate_filename
;
10426 void * separate_handle
;
10428 /* FIXME: Skip adding / if dwo_dir ends in /. */
10429 separate_filename
= concat (dir
, "/", name
, NULL
);
10430 if (separate_filename
== NULL
)
10432 warn (_("Out of memory allocating dwo filename\n"));
10436 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
10438 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
10439 free (separate_filename
);
10443 /* FIXME: We should check the dwo_id. */
10445 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
10446 add_separate_debug_file (separate_filename
, separate_handle
);
10447 /* Note - separate_filename will be freed in free_debug_memory(). */
10448 return separate_handle
;
10451 /* Load the separate debug info file(s) attached to FILE, if any exist.
10452 Returns TRUE if any were found, FALSE otherwise.
10453 If TRUE is returned then the linked list starting at first_separate_info
10454 will be populated with open file handles. */
10457 load_separate_debug_files (void * file
, const char * filename
)
10459 /* Skip this operation if we are not interested in debug links. */
10460 if (! do_follow_links
&& ! do_debug_links
)
10463 /* See if there are any dwo links. */
10464 if (load_debug_section (str
, file
)
10465 && load_debug_section (abbrev
, file
)
10466 && load_debug_section (info
, file
))
10470 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10472 bfd_boolean introduced
= FALSE
;
10474 const char * dir
= NULL
;
10475 const char * id
= NULL
;
10477 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
10479 switch (dwinfo
->type
)
10482 if (do_debug_links
)
10486 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
10487 debug_displays
[info
].section
.uncompressed_name
);
10491 printf (_(" Name: %s\n"), dwinfo
->value
);
10492 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
10494 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
10496 printf (_(" ID: <unknown>\n"));
10500 if (do_follow_links
)
10501 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
10505 dir
= dwinfo
->value
;
10509 id
= dwinfo
->value
;
10513 error (_("Unexpected DWO INFO type"));
10520 if (! do_follow_links
)
10521 /* The other debug links will be displayed by display_debug_links()
10522 so we do not need to do any further processing here. */
10525 /* FIXME: We do not check for the presence of both link sections in the same file. */
10526 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10527 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10528 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10530 if (load_debug_section (gnu_debugaltlink
, file
))
10532 Build_id_data
* build_id_data
;
10534 load_separate_debug_info (filename
,
10535 & debug_displays
[gnu_debugaltlink
].section
,
10536 parse_gnu_debugaltlink
,
10537 check_gnu_debugaltlink
,
10542 if (load_debug_section (gnu_debuglink
, file
))
10544 unsigned long crc32
;
10546 load_separate_debug_info (filename
,
10547 & debug_displays
[gnu_debuglink
].section
,
10548 parse_gnu_debuglink
,
10549 check_gnu_debuglink
,
10554 if (first_separate_info
!= NULL
)
10557 do_follow_links
= 0;
10562 free_debug_memory (void)
10568 for (i
= 0; i
< max
; i
++)
10569 free_debug_section ((enum dwarf_section_display_enum
) i
);
10571 if (debug_information
!= NULL
)
10573 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10575 for (i
= 0; i
< num_debug_info_entries
; i
++)
10577 if (!debug_information
[i
].max_loc_offsets
)
10579 free (debug_information
[i
].loc_offsets
);
10580 free (debug_information
[i
].have_frame_base
);
10582 if (!debug_information
[i
].max_range_lists
)
10583 free (debug_information
[i
].range_lists
);
10586 free (debug_information
);
10587 debug_information
= NULL
;
10588 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10592 separate_info
* next
;
10594 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
10596 close_debug_file (d
->handle
);
10597 free ((void *) d
->filename
);
10601 first_separate_info
= NULL
;
10607 dwarf_select_sections_by_names (const char *names
)
10611 const char * option
;
10615 debug_dump_long_opts
;
10617 static const debug_dump_long_opts opts_table
[] =
10619 /* Please keep this table alpha- sorted. */
10620 { "Ranges", & do_debug_ranges
, 1 },
10621 { "abbrev", & do_debug_abbrevs
, 1 },
10622 { "addr", & do_debug_addr
, 1 },
10623 { "aranges", & do_debug_aranges
, 1 },
10624 { "cu_index", & do_debug_cu_index
, 1 },
10625 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10626 { "follow-links", & do_follow_links
, 1 },
10627 { "frames", & do_debug_frames
, 1 },
10628 { "frames-interp", & do_debug_frames_interp
, 1 },
10629 /* The special .gdb_index section. */
10630 { "gdb_index", & do_gdb_index
, 1 },
10631 { "info", & do_debug_info
, 1 },
10632 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10633 { "links", & do_debug_links
, 1 },
10634 { "loc", & do_debug_loc
, 1 },
10635 { "macro", & do_debug_macinfo
, 1 },
10636 { "pubnames", & do_debug_pubnames
, 1 },
10637 { "pubtypes", & do_debug_pubtypes
, 1 },
10638 /* This entry is for compatibility
10639 with earlier versions of readelf. */
10640 { "ranges", & do_debug_aranges
, 1 },
10641 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10642 { "str", & do_debug_str
, 1 },
10643 /* These trace_* sections are used by Itanium VMS. */
10644 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10645 { "trace_aranges", & do_trace_aranges
, 1 },
10646 { "trace_info", & do_trace_info
, 1 },
10655 const debug_dump_long_opts
* entry
;
10657 for (entry
= opts_table
; entry
->option
; entry
++)
10659 size_t len
= strlen (entry
->option
);
10661 if (strncmp (p
, entry
->option
, len
) == 0
10662 && (p
[len
] == ',' || p
[len
] == '\0'))
10664 * entry
->variable
|= entry
->val
;
10666 /* The --debug-dump=frames-interp option also
10667 enables the --debug-dump=frames option. */
10668 if (do_debug_frames_interp
)
10669 do_debug_frames
= 1;
10676 if (entry
->option
== NULL
)
10678 warn (_("Unrecognized debug option '%s'\n"), p
);
10679 p
= strchr (p
, ',');
10690 dwarf_select_sections_by_letters (const char *letters
)
10692 unsigned int lindex
= 0;
10694 while (letters
[lindex
])
10695 switch (letters
[lindex
++])
10697 case 'A': do_debug_addr
= 1; break;
10698 case 'a': do_debug_abbrevs
= 1; break;
10699 case 'c': do_debug_cu_index
= 1; break;
10700 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10701 case 'f': do_debug_frames
= 1; break;
10702 case 'g': do_gdb_index
= 1; break;
10703 case 'i': do_debug_info
= 1; break;
10704 case 'K': do_follow_links
= 1; break;
10705 case 'k': do_debug_links
= 1; break;
10706 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10707 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10708 case 'm': do_debug_macinfo
= 1; break;
10709 case 'o': do_debug_loc
= 1; break;
10710 case 'p': do_debug_pubnames
= 1; break;
10711 case 'R': do_debug_ranges
= 1; break;
10712 case 'r': do_debug_aranges
= 1; break;
10713 case 's': do_debug_str
= 1; break;
10714 case 'T': do_trace_aranges
= 1; break;
10715 case 't': do_debug_pubtypes
= 1; break;
10716 case 'U': do_trace_info
= 1; break;
10717 case 'u': do_trace_abbrevs
= 1; break;
10720 warn (_("Unrecognized debug option '%s'\n"), letters
);
10726 dwarf_select_sections_all (void)
10729 do_debug_abbrevs
= 1;
10730 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10731 do_debug_pubnames
= 1;
10732 do_debug_pubtypes
= 1;
10733 do_debug_aranges
= 1;
10734 do_debug_ranges
= 1;
10735 do_debug_frames
= 1;
10736 do_debug_macinfo
= 1;
10741 do_trace_abbrevs
= 1;
10742 do_trace_aranges
= 1;
10744 do_debug_cu_index
= 1;
10745 do_follow_links
= 1;
10746 do_debug_links
= 1;
10749 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10750 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10752 /* N.B. The order here must match the order in section_display_enum. */
10754 struct dwarf_section_display debug_displays
[] =
10756 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10757 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10758 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10759 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10760 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10761 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10762 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10763 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10764 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10765 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10766 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10767 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10768 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10769 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10770 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10771 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10772 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10773 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10774 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10775 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10776 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10777 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10778 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10779 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10780 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10781 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10782 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10783 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10784 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10785 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10786 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10787 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10788 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10789 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10790 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10791 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10792 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10793 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10794 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10795 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10796 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10797 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10798 /* Separate debug info files can containt their own .debug_str section,
10799 and this might be in *addition* to a .debug_str section already present
10800 in the main file. Hence we need to have two entries for .debug_str. */
10801 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10804 /* A static assertion. */
10805 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];