1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2019 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 #include "libiberty.h"
24 #include "bfd_stdint.h"
27 #include "elf/common.h"
30 #include "gdb/gdb-index.h"
31 #include "filenames.h"
36 #define MAX(a, b) ((a) > (b) ? (a) : (b))
37 #define MIN(a, b) ((a) < (b) ? (a) : (b))
39 static const char *regname (unsigned int regno
, int row
);
41 static int have_frame_base
;
42 static int need_base_address
;
44 static unsigned int num_debug_info_entries
= 0;
45 static unsigned int alloc_num_debug_info_entries
= 0;
46 static debug_info
*debug_information
= NULL
;
47 /* Special value for num_debug_info_entries to indicate
48 that the .debug_info section could not be loaded/parsed. */
49 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
51 static const char * dwo_name
;
52 static const char * dwo_dir
;
53 static const unsigned char * dwo_id
;
54 static bfd_size_type dwo_id_len
;
55 static bfd_boolean need_dwo_info
;
57 unsigned int eh_addr_size
;
62 int do_debug_pubnames
;
63 int do_debug_pubtypes
;
67 int do_debug_frames_interp
;
76 int do_debug_cu_index
;
81 int dwarf_cutoff_level
= -1;
82 unsigned long dwarf_start_die
;
86 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
87 testing whether e.g. a locview list is present. */
88 static const dwarf_vma vm1
= -1;
90 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
91 sections. For version 1 package files, each set is stored in SHNDX_POOL
92 as a zero-terminated list of section indexes comprising one set of debug
93 sections from a .dwo file. */
95 static unsigned int *shndx_pool
= NULL
;
96 static unsigned int shndx_pool_size
= 0;
97 static unsigned int shndx_pool_used
= 0;
99 /* Pointer to a separate file containing extra debug information. */
100 static void * separate_debug_file
= NULL
;
101 static const char * separate_debug_filename
= NULL
;
103 /* For version 2 package files, each set contains an array of section offsets
104 and an array of section sizes, giving the offset and size of the
105 contribution from a CU or TU within one of the debug sections.
106 When displaying debug info from a package file, we need to use these
107 tables to locate the corresponding contributions to each section. */
112 dwarf_vma section_offsets
[DW_SECT_MAX
];
113 size_t section_sizes
[DW_SECT_MAX
];
116 static int cu_count
= 0;
117 static int tu_count
= 0;
118 static struct cu_tu_set
*cu_sets
= NULL
;
119 static struct cu_tu_set
*tu_sets
= NULL
;
121 static bfd_boolean
load_cu_tu_indexes (void *);
123 /* Values for do_debug_lines. */
124 #define FLAG_DEBUG_LINES_RAW 1
125 #define FLAG_DEBUG_LINES_DECODED 2
128 size_of_encoded_value (int encoding
)
130 switch (encoding
& 0x7)
133 case 0: return eh_addr_size
;
141 get_encoded_value (unsigned char **pdata
,
143 struct dwarf_section
*section
,
146 unsigned char * data
= * pdata
;
147 unsigned int size
= size_of_encoded_value (encoding
);
150 if (data
+ size
>= end
)
152 warn (_("Encoded value extends past end of section\n"));
157 /* PR 17512: file: 002-829853-0.004. */
160 warn (_("Encoded size of %d is too large to read\n"), size
);
165 /* PR 17512: file: 1085-5603-0.004. */
168 warn (_("Encoded size of 0 is too small to read\n"));
173 if (encoding
& DW_EH_PE_signed
)
174 val
= byte_get_signed (data
, size
);
176 val
= byte_get (data
, size
);
178 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
179 val
+= section
->address
+ (data
- section
->start
);
181 * pdata
= data
+ size
;
185 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
187 # define DWARF_VMA_FMT "ll"
188 # define DWARF_VMA_FMT_LONG "%16.16llx"
190 # define DWARF_VMA_FMT "I64"
191 # define DWARF_VMA_FMT_LONG "%016I64x"
194 # define DWARF_VMA_FMT "l"
195 # define DWARF_VMA_FMT_LONG "%16.16lx"
198 /* Convert a dwarf vma value into a string. Returns a pointer to a static
199 buffer containing the converted VALUE. The value is converted according
200 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
201 it specifies the maximum number of bytes to be displayed in the converted
202 value and FMTCH is ignored - hex is always used. */
205 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
207 /* As dwarf_vmatoa is used more then once in a printf call
208 for output, we are cycling through an fixed array of pointers
209 for return address. */
210 static int buf_pos
= 0;
211 static struct dwarf_vmatoa_buf
217 ret
= buf
[buf_pos
++].place
;
218 buf_pos
%= ARRAY_SIZE (buf
);
222 /* Printf does not have a way of specifying a maximum field width for an
223 integer value, so we print the full value into a buffer and then select
224 the precision we need. */
225 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
228 return ret
+ (16 - 2 * num_bytes
);
235 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
237 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
238 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
243 static inline const char *
244 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
246 return dwarf_vmatoa_1 (fmtch
, value
, 0);
249 /* Print a dwarf_vma value (typically an address, offset or length) in
250 hexadecimal format, followed by a space. The length of the VALUE (and
251 hence the precision displayed) is determined by the NUM_BYTES parameter. */
254 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
256 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
259 /* Print a view number in hexadecimal value, with the same width
260 print_dwarf_vma would have printed it with the same num_bytes.
261 Print blanks for zero view, unless force is nonzero. */
264 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
272 assert (value
== (unsigned long) value
);
274 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
276 printf ("%*s", len
+ 1, "");
279 /* Format a 64-bit value, given as two 32-bit values, in hex.
280 For reentrancy, this uses a buffer provided by the caller. */
283 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
284 unsigned int buf_len
)
289 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
292 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
293 snprintf (buf
+ len
, buf_len
- len
,
294 "%08" DWARF_VMA_FMT
"x", lvalue
);
300 /* Read in a LEB128 encoded value starting at address DATA.
301 If SIGN is true, return a signed LEB128 value.
302 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
303 No bytes will be read at address END or beyond. */
306 read_leb128 (unsigned char *data
,
307 unsigned int *length_return
,
309 const unsigned char * const end
)
311 dwarf_vma result
= 0;
312 unsigned int num_read
= 0;
313 unsigned int shift
= 0;
314 unsigned char byte
= 0;
321 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
324 if ((byte
& 0x80) == 0)
327 /* PR 17512: file: 0ca183b8.
328 FIXME: Should we signal this error somehow ? */
329 if (shift
>= sizeof (result
) * 8)
333 if (length_return
!= NULL
)
334 *length_return
= num_read
;
336 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
337 result
|= -((dwarf_vma
) 1 << shift
);
342 /* Create a signed version to avoid painful typecasts. */
343 static inline dwarf_signed_vma
344 read_sleb128 (unsigned char * data
,
345 unsigned int * length_return
,
346 const unsigned char * const end
)
348 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
351 static inline dwarf_vma
352 read_uleb128 (unsigned char * data
,
353 unsigned int * length_return
,
354 const unsigned char * const end
)
356 return read_leb128 (data
, length_return
, FALSE
, end
);
359 #define SKIP_ULEB() read_uleb128 (start, & length_return, end); start += length_return
360 #define SKIP_SLEB() read_sleb128 (start, & length_return, end); start += length_return
362 #define READ_ULEB(var) \
367 (var) = _val = read_uleb128 (start, &length_return, end); \
369 error (_("Internal error: %s:%d: LEB value (%s) " \
370 "too large for containing variable\n"), \
371 __FILE__, __LINE__, dwarf_vmatoa ("u", _val)); \
372 start += length_return; \
376 #define READ_SLEB(var) \
379 dwarf_signed_vma _val; \
381 (var) = _val = read_sleb128 (start, &length_return, end); \
383 error (_("Internal error: %s:%d: LEB value (%s) " \
384 "too large for containing variable\n"), \
385 __FILE__, __LINE__, dwarf_vmatoa ("d", _val)); \
386 start += length_return; \
390 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
391 Checks to make sure that the read will not reach or pass END
392 and that VAL is big enough to hold AMOUNT bytes. */
393 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
396 unsigned int amount = (AMOUNT); \
397 if (sizeof (VAL) < amount) \
399 error (ngettext ("internal error: attempt to read %d byte " \
400 "of data in to %d sized variable", \
401 "internal error: attempt to read %d bytes " \
402 "of data in to %d sized variable", \
404 amount, (int) sizeof (VAL)); \
405 amount = sizeof (VAL); \
407 if (((PTR) + amount) >= (END)) \
410 amount = (END) - (PTR); \
414 if (amount == 0 || amount > 8) \
417 VAL = byte_get ((PTR), amount); \
421 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */
422 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
425 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
430 /* Like SAFE_BYTE_GET, but reads a signed value. */
431 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
434 unsigned int amount = (AMOUNT); \
435 if (((PTR) + amount) >= (END)) \
438 amount = (END) - (PTR); \
443 VAL = byte_get_signed ((PTR), amount); \
449 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */
450 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
453 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
458 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
461 if (((PTR) + 8) <= (END)) \
463 byte_get_64 ((PTR), (HIGH), (LOW)); \
467 * (LOW) = * (HIGH) = 0; \
472 typedef struct State_Machine_Registers
481 unsigned char op_index
;
482 unsigned char end_sequence
;
483 /* This variable hold the number of the last entry seen
484 in the File Table. */
485 unsigned int last_file_entry
;
488 static SMR state_machine_regs
;
491 reset_state_machine (int is_stmt
)
493 state_machine_regs
.address
= 0;
494 state_machine_regs
.view
= 0;
495 state_machine_regs
.op_index
= 0;
496 state_machine_regs
.file
= 1;
497 state_machine_regs
.line
= 1;
498 state_machine_regs
.column
= 0;
499 state_machine_regs
.is_stmt
= is_stmt
;
500 state_machine_regs
.basic_block
= 0;
501 state_machine_regs
.end_sequence
= 0;
502 state_machine_regs
.last_file_entry
= 0;
505 /* Handled an extend line op.
506 Returns the number of bytes read. */
509 process_extended_line_op (unsigned char * data
,
513 unsigned char op_code
;
514 unsigned int bytes_read
;
517 unsigned char *orig_data
= data
;
520 len
= read_uleb128 (data
, & bytes_read
, end
);
523 if (len
== 0 || data
== end
|| len
> (uintptr_t) (end
- data
))
525 warn (_("Badly formed extended line op encountered!\n"));
532 printf (_(" Extended opcode %d: "), op_code
);
536 case DW_LNE_end_sequence
:
537 printf (_("End of Sequence\n\n"));
538 reset_state_machine (is_stmt
);
541 case DW_LNE_set_address
:
542 /* PR 17512: file: 002-100480-0.004. */
543 if (len
- bytes_read
- 1 > 8)
545 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
546 len
- bytes_read
- 1);
550 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
551 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
552 state_machine_regs
.address
= adr
;
553 state_machine_regs
.view
= 0;
554 state_machine_regs
.op_index
= 0;
557 case DW_LNE_define_file
:
558 printf (_("define new File Table entry\n"));
559 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
560 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
566 l
= strnlen ((char *) data
, end
- data
);
568 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
570 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
572 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
574 printf ("%.*s\n\n", (int) l
, name
);
577 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
578 warn (_("DW_LNE_define_file: Bad opcode length\n"));
581 case DW_LNE_set_discriminator
:
582 printf (_("set Discriminator to %s\n"),
583 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
587 case DW_LNE_HP_negate_is_UV_update
:
588 printf ("DW_LNE_HP_negate_is_UV_update\n");
590 case DW_LNE_HP_push_context
:
591 printf ("DW_LNE_HP_push_context\n");
593 case DW_LNE_HP_pop_context
:
594 printf ("DW_LNE_HP_pop_context\n");
596 case DW_LNE_HP_set_file_line_column
:
597 printf ("DW_LNE_HP_set_file_line_column\n");
599 case DW_LNE_HP_set_routine_name
:
600 printf ("DW_LNE_HP_set_routine_name\n");
602 case DW_LNE_HP_set_sequence
:
603 printf ("DW_LNE_HP_set_sequence\n");
605 case DW_LNE_HP_negate_post_semantics
:
606 printf ("DW_LNE_HP_negate_post_semantics\n");
608 case DW_LNE_HP_negate_function_exit
:
609 printf ("DW_LNE_HP_negate_function_exit\n");
611 case DW_LNE_HP_negate_front_end_logical
:
612 printf ("DW_LNE_HP_negate_front_end_logical\n");
614 case DW_LNE_HP_define_proc
:
615 printf ("DW_LNE_HP_define_proc\n");
617 case DW_LNE_HP_source_file_correlation
:
619 unsigned char *edata
= data
+ len
- bytes_read
- 1;
621 printf ("DW_LNE_HP_source_file_correlation\n");
627 opc
= read_uleb128 (data
, & bytes_read
, edata
);
632 case DW_LNE_HP_SFC_formfeed
:
633 printf (" DW_LNE_HP_SFC_formfeed\n");
635 case DW_LNE_HP_SFC_set_listing_line
:
636 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
638 read_uleb128 (data
, & bytes_read
, edata
)));
641 case DW_LNE_HP_SFC_associate
:
642 printf (" DW_LNE_HP_SFC_associate ");
645 read_uleb128 (data
, & bytes_read
, edata
)));
649 read_uleb128 (data
, & bytes_read
, edata
)));
653 read_uleb128 (data
, & bytes_read
, edata
)));
657 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
667 unsigned int rlen
= len
- bytes_read
- 1;
669 if (op_code
>= DW_LNE_lo_user
670 /* The test against DW_LNW_hi_user is redundant due to
671 the limited range of the unsigned char data type used
673 /*&& op_code <= DW_LNE_hi_user*/)
674 printf (_("user defined: "));
676 printf (_("UNKNOWN: "));
677 printf (_("length %d ["), rlen
);
679 printf (" %02x", *data
++);
688 static const unsigned char *
689 fetch_indirect_string (dwarf_vma offset
)
691 struct dwarf_section
*section
= &debug_displays
[str
].section
;
692 const unsigned char * ret
;
694 if (section
->start
== NULL
)
695 return (const unsigned char *) _("<no .debug_str section>");
697 if (offset
>= section
->size
)
699 warn (_("DW_FORM_strp offset too big: %s\n"),
700 dwarf_vmatoa ("x", offset
));
701 return (const unsigned char *) _("<offset is too big>");
704 ret
= section
->start
+ offset
;
705 /* Unfortunately we cannot rely upon the .debug_str section ending with a
706 NUL byte. Since our caller is expecting to receive a well formed C
707 string we test for the lack of a terminating byte here. */
708 if (strnlen ((const char *) ret
, section
->size
- offset
)
709 == section
->size
- offset
)
710 ret
= (const unsigned char *)
711 _("<no NUL byte at end of .debug_str section>");
716 static const unsigned char *
717 fetch_indirect_line_string (dwarf_vma offset
)
719 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
720 const unsigned char * ret
;
722 if (section
->start
== NULL
)
723 return (const unsigned char *) _("<no .debug_line_str section>");
725 if (offset
>= section
->size
)
727 warn (_("DW_FORM_line_strp offset too big: %s\n"),
728 dwarf_vmatoa ("x", offset
));
729 return (const unsigned char *) _("<offset is too big>");
732 ret
= section
->start
+ offset
;
733 /* Unfortunately we cannot rely upon the .debug_line_str section ending
734 with a NUL byte. Since our caller is expecting to receive a well formed
735 C string we test for the lack of a terminating byte here. */
736 if (strnlen ((const char *) ret
, section
->size
- offset
)
737 == section
->size
- offset
)
738 ret
= (const unsigned char *)
739 _("<no NUL byte at end of .debug_line_str section>");
745 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
746 dwarf_vma offset_size
, bfd_boolean dwo
)
748 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
749 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
750 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
751 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
752 dwarf_vma index_offset
= idx
* offset_size
;
753 dwarf_vma str_offset
;
756 if (index_section
->start
== NULL
)
757 return (dwo
? _("<no .debug_str_offsets.dwo section>")
758 : _("<no .debug_str_offsets section>"));
760 if (this_set
!= NULL
)
761 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
762 if (index_offset
>= index_section
->size
)
764 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
765 dwarf_vmatoa ("x", index_offset
));
766 return _("<index offset is too big>");
769 if (str_section
->start
== NULL
)
770 return (dwo
? _("<no .debug_str.dwo section>")
771 : _("<no .debug_str section>"));
773 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
774 str_offset
-= str_section
->address
;
775 if (str_offset
>= str_section
->size
)
777 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
778 dwarf_vmatoa ("x", str_offset
));
779 return _("<indirect index offset is too big>");
782 ret
= (const char *) str_section
->start
+ str_offset
;
783 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
784 Since our caller is expecting to receive a well formed C string we test
785 for the lack of a terminating byte here. */
786 if (strnlen (ret
, str_section
->size
- str_offset
)
787 == str_section
->size
- str_offset
)
788 ret
= (const char *) _("<no NUL byte at end of section>");
794 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
796 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
798 if (section
->start
== NULL
)
799 return (_("<no .debug_addr section>"));
801 if (offset
+ bytes
> section
->size
)
803 warn (_("Offset into section %s too big: %s\n"),
804 section
->name
, dwarf_vmatoa ("x", offset
));
805 return "<offset too big>";
808 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
812 /* FIXME: There are better and more efficient ways to handle
813 these structures. For now though, I just want something that
814 is simple to implement. */
815 typedef struct abbrev_attr
817 unsigned long attribute
;
819 bfd_signed_vma implicit_const
;
820 struct abbrev_attr
*next
;
824 typedef struct abbrev_entry
829 struct abbrev_attr
*first_attr
;
830 struct abbrev_attr
*last_attr
;
831 struct abbrev_entry
*next
;
835 static abbrev_entry
*first_abbrev
= NULL
;
836 static abbrev_entry
*last_abbrev
= NULL
;
843 for (abbrv
= first_abbrev
; abbrv
;)
845 abbrev_entry
*next_abbrev
= abbrv
->next
;
848 for (attr
= abbrv
->first_attr
; attr
;)
850 abbrev_attr
*next_attr
= attr
->next
;
860 last_abbrev
= first_abbrev
= NULL
;
864 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
868 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
873 entry
->entry
= number
;
875 entry
->children
= children
;
876 entry
->first_attr
= NULL
;
877 entry
->last_attr
= NULL
;
880 if (first_abbrev
== NULL
)
881 first_abbrev
= entry
;
883 last_abbrev
->next
= entry
;
889 add_abbrev_attr (unsigned long attribute
, unsigned long form
,
890 bfd_signed_vma implicit_const
)
894 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
899 attr
->attribute
= attribute
;
901 attr
->implicit_const
= implicit_const
;
904 if (last_abbrev
->first_attr
== NULL
)
905 last_abbrev
->first_attr
= attr
;
907 last_abbrev
->last_attr
->next
= attr
;
909 last_abbrev
->last_attr
= attr
;
912 /* Processes the (partial) contents of a .debug_abbrev section.
913 Returns NULL if the end of the section was encountered.
914 Returns the address after the last byte read if the end of
915 an abbreviation set was found. */
917 static unsigned char *
918 process_abbrev_section (unsigned char *start
, unsigned char *end
)
920 if (first_abbrev
!= NULL
)
925 unsigned int bytes_read
;
928 unsigned long attribute
;
931 entry
= read_uleb128 (start
, & bytes_read
, end
);
934 /* A single zero is supposed to end the section according
935 to the standard. If there's more, then signal that to
942 tag
= read_uleb128 (start
, & bytes_read
, end
);
949 add_abbrev (entry
, tag
, children
);
954 /* Initialize it due to a false compiler warning. */
955 bfd_signed_vma implicit_const
= -1;
957 attribute
= read_uleb128 (start
, & bytes_read
, end
);
962 form
= read_uleb128 (start
, & bytes_read
, end
);
967 if (form
== DW_FORM_implicit_const
)
969 implicit_const
= read_sleb128 (start
, & bytes_read
, end
);
975 add_abbrev_attr (attribute
, form
, implicit_const
);
977 while (attribute
!= 0);
980 /* Report the missing single zero which ends the section. */
981 error (_(".debug_abbrev section not zero terminated\n"));
987 get_TAG_name (unsigned long tag
)
989 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
993 static char buffer
[100];
995 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
996 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
998 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
1006 get_FORM_name (unsigned long form
)
1011 return "DW_FORM value: 0";
1013 name
= get_DW_FORM_name (form
);
1016 static char buffer
[100];
1018 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1026 get_IDX_name (unsigned long idx
)
1028 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1032 static char buffer
[100];
1034 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1041 static unsigned char *
1042 display_block (unsigned char *data
,
1044 const unsigned char * const end
, char delimiter
)
1048 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1050 return (unsigned char *) end
;
1052 maxlen
= (dwarf_vma
) (end
- data
);
1053 length
= length
> maxlen
? maxlen
: length
;
1056 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1062 decode_location_expression (unsigned char * data
,
1063 unsigned int pointer_size
,
1064 unsigned int offset_size
,
1067 dwarf_vma cu_offset
,
1068 struct dwarf_section
* section
)
1071 unsigned int bytes_read
;
1073 dwarf_signed_vma svalue
;
1074 unsigned char *end
= data
+ length
;
1075 int need_frame_base
= 0;
1084 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1085 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1088 printf ("DW_OP_deref");
1091 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1092 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1095 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1096 printf ("DW_OP_const1s: %ld", (long) svalue
);
1099 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1100 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1103 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1104 printf ("DW_OP_const2s: %ld", (long) svalue
);
1107 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1108 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1111 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1112 printf ("DW_OP_const4s: %ld", (long) svalue
);
1115 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1116 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1117 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1118 printf ("%lu", (unsigned long) uvalue
);
1121 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1122 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1123 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1124 printf ("%ld", (long) svalue
);
1127 printf ("DW_OP_constu: %s",
1128 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1132 printf ("DW_OP_consts: %s",
1133 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1137 printf ("DW_OP_dup");
1140 printf ("DW_OP_drop");
1143 printf ("DW_OP_over");
1146 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1147 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1150 printf ("DW_OP_swap");
1153 printf ("DW_OP_rot");
1156 printf ("DW_OP_xderef");
1159 printf ("DW_OP_abs");
1162 printf ("DW_OP_and");
1165 printf ("DW_OP_div");
1168 printf ("DW_OP_minus");
1171 printf ("DW_OP_mod");
1174 printf ("DW_OP_mul");
1177 printf ("DW_OP_neg");
1180 printf ("DW_OP_not");
1183 printf ("DW_OP_or");
1186 printf ("DW_OP_plus");
1188 case DW_OP_plus_uconst
:
1189 printf ("DW_OP_plus_uconst: %s",
1190 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1194 printf ("DW_OP_shl");
1197 printf ("DW_OP_shr");
1200 printf ("DW_OP_shra");
1203 printf ("DW_OP_xor");
1206 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1207 printf ("DW_OP_bra: %ld", (long) svalue
);
1210 printf ("DW_OP_eq");
1213 printf ("DW_OP_ge");
1216 printf ("DW_OP_gt");
1219 printf ("DW_OP_le");
1222 printf ("DW_OP_lt");
1225 printf ("DW_OP_ne");
1228 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1229 printf ("DW_OP_skip: %ld", (long) svalue
);
1264 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1299 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1300 regname (op
- DW_OP_reg0
, 1));
1335 printf ("DW_OP_breg%d (%s): %s",
1337 regname (op
- DW_OP_breg0
, 1),
1338 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1343 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1345 printf ("DW_OP_regx: %s (%s)",
1346 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1349 need_frame_base
= 1;
1350 printf ("DW_OP_fbreg: %s",
1351 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1355 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1357 printf ("DW_OP_bregx: %s (%s) %s",
1358 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1359 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1363 printf ("DW_OP_piece: %s",
1364 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1367 case DW_OP_deref_size
:
1368 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1369 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1371 case DW_OP_xderef_size
:
1372 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1373 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1376 printf ("DW_OP_nop");
1379 /* DWARF 3 extensions. */
1380 case DW_OP_push_object_address
:
1381 printf ("DW_OP_push_object_address");
1384 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1385 this ought to be an 8-byte wide computation. */
1386 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1387 printf ("DW_OP_call2: <0x%s>",
1388 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1391 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1392 this ought to be an 8-byte wide computation. */
1393 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1394 printf ("DW_OP_call4: <0x%s>",
1395 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1397 case DW_OP_call_ref
:
1398 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1399 this ought to be an 8-byte wide computation. */
1400 if (dwarf_version
== -1)
1402 printf (_("(DW_OP_call_ref in frame info)"));
1403 /* No way to tell where the next op is, so just bail. */
1404 return need_frame_base
;
1406 if (dwarf_version
== 2)
1408 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1412 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1414 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1416 case DW_OP_form_tls_address
:
1417 printf ("DW_OP_form_tls_address");
1419 case DW_OP_call_frame_cfa
:
1420 printf ("DW_OP_call_frame_cfa");
1422 case DW_OP_bit_piece
:
1423 printf ("DW_OP_bit_piece: ");
1424 printf (_("size: %s "),
1425 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1427 printf (_("offset: %s "),
1428 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1432 /* DWARF 4 extensions. */
1433 case DW_OP_stack_value
:
1434 printf ("DW_OP_stack_value");
1437 case DW_OP_implicit_value
:
1438 printf ("DW_OP_implicit_value");
1439 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1441 data
= display_block (data
, uvalue
, end
, ' ');
1444 /* GNU extensions. */
1445 case DW_OP_GNU_push_tls_address
:
1446 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1448 case DW_OP_GNU_uninit
:
1449 printf ("DW_OP_GNU_uninit");
1450 /* FIXME: Is there data associated with this OP ? */
1452 case DW_OP_GNU_encoded_addr
:
1459 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1461 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1462 print_dwarf_vma (addr
, pointer_size
);
1465 case DW_OP_implicit_pointer
:
1466 case DW_OP_GNU_implicit_pointer
:
1467 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1468 this ought to be an 8-byte wide computation. */
1469 if (dwarf_version
== -1)
1471 printf (_("(%s in frame info)"),
1472 (op
== DW_OP_implicit_pointer
1473 ? "DW_OP_implicit_pointer"
1474 : "DW_OP_GNU_implicit_pointer"));
1475 /* No way to tell where the next op is, so just bail. */
1476 return need_frame_base
;
1478 if (dwarf_version
== 2)
1480 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1484 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1486 printf ("%s: <0x%s> %s",
1487 (op
== DW_OP_implicit_pointer
1488 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1489 dwarf_vmatoa ("x", uvalue
),
1490 dwarf_vmatoa ("d", read_sleb128 (data
,
1491 &bytes_read
, end
)));
1494 case DW_OP_entry_value
:
1495 case DW_OP_GNU_entry_value
:
1496 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1498 /* PR 17531: file: 0cc9cd00. */
1499 if (uvalue
> (dwarf_vma
) (end
- data
))
1500 uvalue
= end
- data
;
1501 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1502 : "DW_OP_GNU_entry_value"));
1503 if (decode_location_expression (data
, pointer_size
, offset_size
,
1504 dwarf_version
, uvalue
,
1505 cu_offset
, section
))
1506 need_frame_base
= 1;
1512 case DW_OP_const_type
:
1513 case DW_OP_GNU_const_type
:
1514 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1516 printf ("%s: <0x%s> ",
1517 (op
== DW_OP_const_type
? "DW_OP_const_type"
1518 : "DW_OP_GNU_const_type"),
1519 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1520 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1521 data
= display_block (data
, uvalue
, end
, ' ');
1523 case DW_OP_regval_type
:
1524 case DW_OP_GNU_regval_type
:
1525 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1527 printf ("%s: %s (%s)",
1528 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1529 : "DW_OP_GNU_regval_type"),
1530 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1531 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1533 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1535 case DW_OP_deref_type
:
1536 case DW_OP_GNU_deref_type
:
1537 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1539 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1540 : "DW_OP_GNU_deref_type"),
1542 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1544 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1547 case DW_OP_GNU_convert
:
1548 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1550 printf ("%s <0x%s>",
1551 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1552 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1554 case DW_OP_reinterpret
:
1555 case DW_OP_GNU_reinterpret
:
1556 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1558 printf ("%s <0x%s>",
1559 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1560 : "DW_OP_GNU_reinterpret"),
1561 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1563 case DW_OP_GNU_parameter_ref
:
1564 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1565 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1566 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1568 case DW_OP_GNU_addr_index
:
1569 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1571 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1573 case DW_OP_GNU_const_index
:
1574 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1576 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1578 case DW_OP_GNU_variable_value
:
1579 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1580 this ought to be an 8-byte wide computation. */
1581 if (dwarf_version
== -1)
1583 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1584 /* No way to tell where the next op is, so just bail. */
1585 return need_frame_base
;
1587 if (dwarf_version
== 2)
1589 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1593 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1595 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1598 /* HP extensions. */
1599 case DW_OP_HP_is_value
:
1600 printf ("DW_OP_HP_is_value");
1601 /* FIXME: Is there data associated with this OP ? */
1603 case DW_OP_HP_fltconst4
:
1604 printf ("DW_OP_HP_fltconst4");
1605 /* FIXME: Is there data associated with this OP ? */
1607 case DW_OP_HP_fltconst8
:
1608 printf ("DW_OP_HP_fltconst8");
1609 /* FIXME: Is there data associated with this OP ? */
1611 case DW_OP_HP_mod_range
:
1612 printf ("DW_OP_HP_mod_range");
1613 /* FIXME: Is there data associated with this OP ? */
1615 case DW_OP_HP_unmod_range
:
1616 printf ("DW_OP_HP_unmod_range");
1617 /* FIXME: Is there data associated with this OP ? */
1620 printf ("DW_OP_HP_tls");
1621 /* FIXME: Is there data associated with this OP ? */
1624 /* PGI (STMicroelectronics) extensions. */
1625 case DW_OP_PGI_omp_thread_num
:
1626 /* Pushes the thread number for the current thread as it would be
1627 returned by the standard OpenMP library function:
1628 omp_get_thread_num(). The "current thread" is the thread for
1629 which the expression is being evaluated. */
1630 printf ("DW_OP_PGI_omp_thread_num");
1634 if (op
>= DW_OP_lo_user
1635 && op
<= DW_OP_hi_user
)
1636 printf (_("(User defined location op 0x%x)"), op
);
1638 printf (_("(Unknown location op 0x%x)"), op
);
1639 /* No way to tell where the next op is, so just bail. */
1640 return need_frame_base
;
1643 /* Separate the ops. */
1648 return need_frame_base
;
1651 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1652 This is used for DWARF package files. */
1654 static struct cu_tu_set
*
1655 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1657 struct cu_tu_set
*p
;
1659 unsigned int dw_sect
;
1665 dw_sect
= DW_SECT_TYPES
;
1671 dw_sect
= DW_SECT_INFO
;
1675 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1683 /* Add INC to HIGH_BITS:LOW_BITS. */
1685 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1687 dwarf_vma tmp
= * low_bits
;
1691 /* FIXME: There is probably a better way of handling this:
1693 We need to cope with dwarf_vma being a 32-bit or 64-bit
1694 type. Plus regardless of its size LOW_BITS is meant to
1695 only hold 32-bits, so if there is overflow or wrap around
1696 we must propagate into HIGH_BITS. */
1697 if (tmp
< * low_bits
)
1701 else if (sizeof (tmp
) > 8
1712 fetch_alt_indirect_string (dwarf_vma offset
)
1714 struct dwarf_section
* section
;
1717 if (! do_follow_links
)
1720 if (separate_debug_file
== NULL
)
1721 return _("<following link not possible>");
1723 if (! load_debug_section (separate_debug_str
, separate_debug_file
))
1724 return _("<could not load separate string section>");
1726 section
= &debug_displays
[separate_debug_str
].section
;
1727 if (section
->start
== NULL
)
1728 return _("<no .debug_str section>");
1730 if (offset
>= section
->size
)
1732 warn (_("DW_FORM_GNU_strp_alt offset too big: %s\n"), dwarf_vmatoa ("x", offset
));
1733 return _("<offset is too big>");
1736 ret
= (const char *) (section
->start
+ offset
);
1737 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1738 NUL byte. Since our caller is expecting to receive a well formed C
1739 string we test for the lack of a terminating byte here. */
1740 if (strnlen ((const char *) ret
, section
->size
- offset
)
1741 == section
->size
- offset
)
1742 return _("<no NUL byte at end of .debug_str section>");
1748 get_AT_name (unsigned long attribute
)
1753 return "DW_AT value: 0";
1755 /* One value is shared by the MIPS and HP extensions: */
1756 if (attribute
== DW_AT_MIPS_fde
)
1757 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1759 name
= get_DW_AT_name (attribute
);
1763 static char buffer
[100];
1765 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1773 static unsigned char *
1774 read_and_display_attr_value (unsigned long attribute
,
1776 dwarf_signed_vma implicit_const
,
1777 unsigned char * data
,
1778 unsigned char * end
,
1779 dwarf_vma cu_offset
,
1780 dwarf_vma pointer_size
,
1781 dwarf_vma offset_size
,
1783 debug_info
* debug_info_p
,
1785 struct dwarf_section
* section
,
1786 struct cu_tu_set
* this_set
,
1789 dwarf_vma uvalue
= 0;
1790 unsigned char *block_start
= NULL
;
1791 unsigned char * orig_data
= data
;
1792 unsigned int bytes_read
;
1794 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
1796 warn (_("Corrupt attribute\n"));
1805 case DW_FORM_ref_addr
:
1806 if (dwarf_version
== 2)
1807 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1808 else if (dwarf_version
== 3 || dwarf_version
== 4)
1809 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1811 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1816 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1820 case DW_FORM_line_strp
:
1821 case DW_FORM_sec_offset
:
1822 case DW_FORM_GNU_ref_alt
:
1823 case DW_FORM_GNU_strp_alt
:
1824 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1827 case DW_FORM_flag_present
:
1834 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1839 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1844 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1848 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1852 case DW_FORM_GNU_str_index
:
1853 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1857 case DW_FORM_ref_udata
:
1859 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1863 case DW_FORM_indirect
:
1864 form
= read_uleb128 (data
, & bytes_read
, end
);
1867 printf ("%c%s", delimiter
, get_FORM_name (form
));
1868 if (form
== DW_FORM_implicit_const
)
1870 implicit_const
= read_sleb128 (data
, & bytes_read
, end
);
1873 return read_and_display_attr_value (attribute
, form
, implicit_const
, data
,
1874 end
, cu_offset
, pointer_size
,
1875 offset_size
, dwarf_version
,
1876 debug_info_p
, do_loc
,
1877 section
, this_set
, delimiter
);
1878 case DW_FORM_GNU_addr_index
:
1879 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1886 case DW_FORM_ref_addr
:
1888 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
1891 case DW_FORM_GNU_ref_alt
:
1893 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
1894 /* FIXME: Follow the reference... */
1900 case DW_FORM_ref_udata
:
1902 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1907 case DW_FORM_sec_offset
:
1909 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
1912 case DW_FORM_flag_present
:
1919 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
1922 case DW_FORM_implicit_const
:
1924 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
1931 dwarf_vma high_bits
;
1935 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1937 if (form
== DW_FORM_ref8
)
1938 add64 (& high_bits
, & utmp
, cu_offset
);
1939 printf ("%c0x%s", delimiter
,
1940 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1943 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1944 && num_debug_info_entries
== 0)
1946 if (sizeof (uvalue
) == 8)
1947 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1949 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1955 case DW_FORM_data16
:
1958 dwarf_vma left_high_bits
, left_low_bits
;
1959 dwarf_vma right_high_bits
, right_low_bits
;
1961 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
1962 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
1963 if (byte_get
== byte_get_little_endian
)
1966 left_high_bits
^= right_high_bits
;
1967 right_high_bits
^= left_high_bits
;
1968 left_high_bits
^= right_high_bits
;
1969 left_low_bits
^= right_low_bits
;
1970 right_low_bits
^= left_low_bits
;
1971 left_low_bits
^= right_low_bits
;
1973 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
1974 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
1975 left_high_bits
, left_low_bits
, right_high_bits
,
1981 case DW_FORM_string
:
1983 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
1984 data
+= strnlen ((char *) data
, end
- data
) + 1;
1988 case DW_FORM_exprloc
:
1989 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1990 block_start
= data
+ bytes_read
;
1991 if (block_start
>= end
)
1993 warn (_("Block ends prematurely\n"));
1997 /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1998 gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute
1999 block_start + uvalue here. */
2000 data
= block_start
+ uvalue
;
2001 /* PR 17512: file: 008-103549-0.001:0.1. */
2002 if (block_start
+ uvalue
> end
|| data
< block_start
)
2004 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
2005 uvalue
= end
- block_start
;
2008 data
= block_start
+ uvalue
;
2010 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2013 case DW_FORM_block1
:
2014 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
2015 block_start
= data
+ 1;
2016 if (block_start
>= end
)
2018 warn (_("Block ends prematurely\n"));
2022 data
= block_start
+ uvalue
;
2023 if (block_start
+ uvalue
> end
|| data
< block_start
)
2025 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
2026 uvalue
= end
- block_start
;
2029 data
= block_start
+ uvalue
;
2031 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2034 case DW_FORM_block2
:
2035 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
2036 block_start
= data
+ 2;
2037 if (block_start
>= end
)
2039 warn (_("Block ends prematurely\n"));
2043 data
= block_start
+ uvalue
;
2044 if (block_start
+ uvalue
> end
|| data
< block_start
)
2046 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
2047 uvalue
= end
- block_start
;
2050 data
= block_start
+ uvalue
;
2052 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2055 case DW_FORM_block4
:
2056 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
2057 block_start
= data
+ 4;
2058 /* PR 17512: file: 3371-3907-0.004. */
2059 if (block_start
>= end
)
2061 warn (_("Block ends prematurely\n"));
2065 data
= block_start
+ uvalue
;
2066 if (block_start
+ uvalue
> end
2067 /* PR 17531: file: 5b5f0592. */
2068 || data
< block_start
)
2070 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
2071 uvalue
= end
- block_start
;
2074 data
= block_start
+ uvalue
;
2076 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2081 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2082 dwarf_vmatoa ("x", uvalue
),
2083 fetch_indirect_string (uvalue
));
2086 case DW_FORM_line_strp
:
2088 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2089 dwarf_vmatoa ("x", uvalue
),
2090 fetch_indirect_line_string (uvalue
));
2093 case DW_FORM_GNU_str_index
:
2096 const char * suffix
= strrchr (section
->name
, '.');
2097 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
2099 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2100 dwarf_vmatoa ("x", uvalue
),
2101 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2105 case DW_FORM_GNU_strp_alt
:
2108 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2109 dwarf_vmatoa ("x", uvalue
),
2110 fetch_alt_indirect_string (uvalue
));
2114 case DW_FORM_indirect
:
2115 /* Handled above. */
2118 case DW_FORM_ref_sig8
:
2121 dwarf_vma high_bits
;
2124 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2125 printf ("%csignature: 0x%s", delimiter
,
2126 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2131 case DW_FORM_GNU_addr_index
:
2133 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2134 dwarf_vmatoa ("x", uvalue
),
2135 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2139 warn (_("Unrecognized form: %lu\n"), form
);
2143 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2144 && num_debug_info_entries
== 0
2145 && debug_info_p
!= NULL
)
2149 case DW_AT_frame_base
:
2150 have_frame_base
= 1;
2152 case DW_AT_location
:
2153 case DW_AT_GNU_locviews
:
2154 case DW_AT_string_length
:
2155 case DW_AT_return_addr
:
2156 case DW_AT_data_member_location
:
2157 case DW_AT_vtable_elem_location
:
2159 case DW_AT_static_link
:
2160 case DW_AT_use_location
:
2161 case DW_AT_call_value
:
2162 case DW_AT_GNU_call_site_value
:
2163 case DW_AT_call_data_value
:
2164 case DW_AT_GNU_call_site_data_value
:
2165 case DW_AT_call_target
:
2166 case DW_AT_GNU_call_site_target
:
2167 case DW_AT_call_target_clobbered
:
2168 case DW_AT_GNU_call_site_target_clobbered
:
2169 if ((dwarf_version
< 4
2170 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2171 || form
== DW_FORM_sec_offset
)
2173 /* Process location list. */
2174 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2175 unsigned int num
= debug_info_p
->num_loc_offsets
;
2177 if (lmax
== 0 || num
>= lmax
)
2180 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2181 xcrealloc (debug_info_p
->loc_offsets
,
2182 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2183 debug_info_p
->loc_views
= (dwarf_vma
*)
2184 xcrealloc (debug_info_p
->loc_views
,
2185 lmax
, sizeof (*debug_info_p
->loc_views
));
2186 debug_info_p
->have_frame_base
= (int *)
2187 xcrealloc (debug_info_p
->have_frame_base
,
2188 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2189 debug_info_p
->max_loc_offsets
= lmax
;
2191 if (this_set
!= NULL
)
2192 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2193 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2194 if (attribute
!= DW_AT_GNU_locviews
)
2196 /* Corrupt DWARF info can produce more offsets than views.
2197 See PR 23062 for an example. */
2198 if (debug_info_p
->num_loc_offsets
2199 > debug_info_p
->num_loc_views
)
2200 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2203 debug_info_p
->loc_offsets
[num
] = uvalue
;
2204 debug_info_p
->num_loc_offsets
++;
2209 assert (debug_info_p
->num_loc_views
<= num
);
2210 num
= debug_info_p
->num_loc_views
;
2211 if (num
> debug_info_p
->num_loc_offsets
)
2212 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2215 debug_info_p
->loc_views
[num
] = uvalue
;
2216 debug_info_p
->num_loc_views
++;
2223 if (need_base_address
)
2224 debug_info_p
->base_address
= uvalue
;
2227 case DW_AT_GNU_addr_base
:
2228 debug_info_p
->addr_base
= uvalue
;
2231 case DW_AT_GNU_ranges_base
:
2232 debug_info_p
->ranges_base
= uvalue
;
2236 if ((dwarf_version
< 4
2237 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2238 || form
== DW_FORM_sec_offset
)
2240 /* Process range list. */
2241 unsigned int lmax
= debug_info_p
->max_range_lists
;
2242 unsigned int num
= debug_info_p
->num_range_lists
;
2244 if (lmax
== 0 || num
>= lmax
)
2247 debug_info_p
->range_lists
= (dwarf_vma
*)
2248 xcrealloc (debug_info_p
->range_lists
,
2249 lmax
, sizeof (*debug_info_p
->range_lists
));
2250 debug_info_p
->max_range_lists
= lmax
;
2252 debug_info_p
->range_lists
[num
] = uvalue
;
2253 debug_info_p
->num_range_lists
++;
2257 case DW_AT_GNU_dwo_name
:
2258 case DW_AT_dwo_name
:
2263 dwo_name
= (const char *) fetch_indirect_string (uvalue
);
2265 case DW_FORM_GNU_str_index
:
2266 dwo_name
= fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
);
2268 case DW_FORM_string
:
2269 dwo_name
= (const char *) orig_data
;
2272 warn (_("Unsupported form (%s) for attribute %s\n"),
2273 get_FORM_name (form
), get_AT_name (attribute
));
2274 dwo_name
= _("<unknown>");
2279 case DW_AT_comp_dir
:
2280 /* FIXME: Also extract a build-id in a CU/TU. */
2285 dwo_dir
= (const char *) fetch_indirect_string (uvalue
);
2287 case DW_FORM_line_strp
:
2288 dwo_dir
= (const char *) fetch_indirect_line_string (uvalue
);
2290 case DW_FORM_GNU_str_index
:
2291 dwo_dir
= fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
);
2293 case DW_FORM_string
:
2294 dwo_dir
= (const char *) orig_data
;
2297 warn (_("Unsupported form (%s) for attribute %s\n"),
2298 get_FORM_name (form
), get_AT_name (attribute
));
2299 dwo_dir
= _("<unknown>");
2304 case DW_AT_GNU_dwo_id
:
2313 warn (_("Unsupported form (%s) for attribute %s\n"),
2314 get_FORM_name (form
), get_AT_name (attribute
));
2325 if (do_loc
|| attribute
== 0)
2328 /* For some attributes we can display further information. */
2335 case DW_INL_not_inlined
:
2336 printf (_("(not inlined)"));
2338 case DW_INL_inlined
:
2339 printf (_("(inlined)"));
2341 case DW_INL_declared_not_inlined
:
2342 printf (_("(declared as inline but ignored)"));
2344 case DW_INL_declared_inlined
:
2345 printf (_("(declared as inline and inlined)"));
2348 printf (_(" (Unknown inline attribute value: %s)"),
2349 dwarf_vmatoa ("x", uvalue
));
2354 case DW_AT_language
:
2358 /* Ordered by the numeric value of these constants. */
2359 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2360 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2361 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2362 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2363 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2364 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2365 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2366 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2367 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2368 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2369 /* DWARF 2.1 values. */
2370 case DW_LANG_Java
: printf ("(Java)"); break;
2371 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2372 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2373 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2374 /* DWARF 3 values. */
2375 case DW_LANG_PLI
: printf ("(PLI)"); break;
2376 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2377 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2378 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2379 case DW_LANG_D
: printf ("(D)"); break;
2380 /* DWARF 4 values. */
2381 case DW_LANG_Python
: printf ("(Python)"); break;
2382 /* DWARF 5 values. */
2383 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
2384 case DW_LANG_Go
: printf ("(Go)"); break;
2385 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
2386 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
2387 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
2388 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2389 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
2390 case DW_LANG_Rust
: printf ("(Rust)"); break;
2391 case DW_LANG_C11
: printf ("(C11)"); break;
2392 case DW_LANG_Swift
: printf ("(Swift)"); break;
2393 case DW_LANG_Julia
: printf ("(Julia)"); break;
2394 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
2395 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2396 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2397 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2398 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
2399 /* MIPS extension. */
2400 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2401 /* UPC extension. */
2402 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2404 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2405 printf (_("(implementation defined: %s)"),
2406 dwarf_vmatoa ("x", uvalue
));
2408 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2413 case DW_AT_encoding
:
2417 case DW_ATE_void
: printf ("(void)"); break;
2418 case DW_ATE_address
: printf ("(machine address)"); break;
2419 case DW_ATE_boolean
: printf ("(boolean)"); break;
2420 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2421 case DW_ATE_float
: printf ("(float)"); break;
2422 case DW_ATE_signed
: printf ("(signed)"); break;
2423 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2424 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2425 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2426 /* DWARF 2.1 values: */
2427 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2428 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2429 /* DWARF 3 values: */
2430 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2431 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2432 case DW_ATE_edited
: printf ("(edited)"); break;
2433 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2434 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2435 /* DWARF 4 values: */
2436 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2437 /* DWARF 5 values: */
2438 case DW_ATE_UCS
: printf ("(UCS)"); break;
2439 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2441 /* HP extensions: */
2442 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2443 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2444 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2445 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2446 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2447 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2448 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2451 if (uvalue
>= DW_ATE_lo_user
2452 && uvalue
<= DW_ATE_hi_user
)
2453 printf (_("(user defined type)"));
2455 printf (_("(unknown type)"));
2460 case DW_AT_accessibility
:
2464 case DW_ACCESS_public
: printf ("(public)"); break;
2465 case DW_ACCESS_protected
: printf ("(protected)"); break;
2466 case DW_ACCESS_private
: printf ("(private)"); break;
2468 printf (_("(unknown accessibility)"));
2473 case DW_AT_visibility
:
2477 case DW_VIS_local
: printf ("(local)"); break;
2478 case DW_VIS_exported
: printf ("(exported)"); break;
2479 case DW_VIS_qualified
: printf ("(qualified)"); break;
2480 default: printf (_("(unknown visibility)")); break;
2484 case DW_AT_endianity
:
2488 case DW_END_default
: printf ("(default)"); break;
2489 case DW_END_big
: printf ("(big)"); break;
2490 case DW_END_little
: printf ("(little)"); break;
2492 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2493 printf (_("(user specified)"));
2495 printf (_("(unknown endianity)"));
2500 case DW_AT_virtuality
:
2504 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2505 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2506 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2507 default: printf (_("(unknown virtuality)")); break;
2511 case DW_AT_identifier_case
:
2515 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2516 case DW_ID_up_case
: printf ("(up_case)"); break;
2517 case DW_ID_down_case
: printf ("(down_case)"); break;
2518 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2519 default: printf (_("(unknown case)")); break;
2523 case DW_AT_calling_convention
:
2527 case DW_CC_normal
: printf ("(normal)"); break;
2528 case DW_CC_program
: printf ("(program)"); break;
2529 case DW_CC_nocall
: printf ("(nocall)"); break;
2530 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2531 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2532 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2533 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2535 if (uvalue
>= DW_CC_lo_user
2536 && uvalue
<= DW_CC_hi_user
)
2537 printf (_("(user defined)"));
2539 printf (_("(unknown convention)"));
2543 case DW_AT_ordering
:
2548 case -1: printf (_("(undefined)")); break;
2549 case 0: printf ("(row major)"); break;
2550 case 1: printf ("(column major)"); break;
2554 case DW_AT_decimal_sign
:
2558 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2559 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2560 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2561 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2562 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2563 default: printf (_("(unrecognised)")); break;
2567 case DW_AT_defaulted
:
2571 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2572 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2573 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2574 default: printf (_("(unrecognised)")); break;
2578 case DW_AT_discr_list
:
2582 case DW_DSC_label
: printf (_("(label)")); break;
2583 case DW_DSC_range
: printf (_("(range)")); break;
2584 default: printf (_("(unrecognised)")); break;
2588 case DW_AT_frame_base
:
2589 have_frame_base
= 1;
2591 case DW_AT_location
:
2592 case DW_AT_string_length
:
2593 case DW_AT_return_addr
:
2594 case DW_AT_data_member_location
:
2595 case DW_AT_vtable_elem_location
:
2597 case DW_AT_static_link
:
2598 case DW_AT_use_location
:
2599 case DW_AT_call_value
:
2600 case DW_AT_GNU_call_site_value
:
2601 case DW_AT_call_data_value
:
2602 case DW_AT_GNU_call_site_data_value
:
2603 case DW_AT_call_target
:
2604 case DW_AT_GNU_call_site_target
:
2605 case DW_AT_call_target_clobbered
:
2606 case DW_AT_GNU_call_site_target_clobbered
:
2607 if ((dwarf_version
< 4
2608 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2609 || form
== DW_FORM_sec_offset
)
2610 printf (_(" (location list)"));
2612 case DW_AT_allocated
:
2613 case DW_AT_associated
:
2614 case DW_AT_data_location
:
2616 case DW_AT_upper_bound
:
2617 case DW_AT_lower_bound
:
2620 int need_frame_base
;
2623 need_frame_base
= decode_location_expression (block_start
,
2628 cu_offset
, section
);
2630 if (need_frame_base
&& !have_frame_base
)
2631 printf (_(" [without DW_AT_frame_base]"));
2635 case DW_AT_data_bit_offset
:
2636 case DW_AT_byte_size
:
2637 case DW_AT_bit_size
:
2638 case DW_AT_string_length_byte_size
:
2639 case DW_AT_string_length_bit_size
:
2640 case DW_AT_bit_stride
:
2641 if (form
== DW_FORM_exprloc
)
2644 (void) decode_location_expression (block_start
, pointer_size
,
2645 offset_size
, dwarf_version
,
2646 uvalue
, cu_offset
, section
);
2653 if (form
== DW_FORM_ref_sig8
2654 || form
== DW_FORM_GNU_ref_alt
)
2657 if (form
== DW_FORM_ref1
2658 || form
== DW_FORM_ref2
2659 || form
== DW_FORM_ref4
2660 || form
== DW_FORM_ref_udata
)
2661 uvalue
+= cu_offset
;
2663 if (uvalue
>= section
->size
)
2664 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2665 dwarf_vmatoa ("x", uvalue
),
2666 (unsigned long) (orig_data
- section
->start
));
2669 unsigned long abbrev_number
;
2670 abbrev_entry
* entry
;
2672 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2674 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2675 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2676 use different abbrev table, and we don't track .debug_info chunks
2678 if (form
!= DW_FORM_ref_addr
)
2680 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2681 if (entry
->entry
== abbrev_number
)
2684 printf (" (%s)", get_TAG_name (entry
->tag
));
2698 static unsigned char *
2699 read_and_display_attr (unsigned long attribute
,
2701 dwarf_signed_vma implicit_const
,
2702 unsigned char * data
,
2703 unsigned char * end
,
2704 dwarf_vma cu_offset
,
2705 dwarf_vma pointer_size
,
2706 dwarf_vma offset_size
,
2708 debug_info
* debug_info_p
,
2710 struct dwarf_section
* section
,
2711 struct cu_tu_set
* this_set
)
2714 printf (" %-18s:", get_AT_name (attribute
));
2715 data
= read_and_display_attr_value (attribute
, form
, implicit_const
, data
, end
,
2716 cu_offset
, pointer_size
, offset_size
,
2717 dwarf_version
, debug_info_p
,
2718 do_loc
, section
, this_set
, ' ');
2724 /* Like load_debug_section, but if the ordinary call fails, and we are
2725 following debug links, and we have been able to load a separate debug
2726 info file, then attempt to load the requested section from the separate
2730 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
2733 if (load_debug_section (sec_enum
, data
))
2735 if (data
== separate_debug_file
)
2736 debug_displays
[sec_enum
].section
.filename
= separate_debug_filename
;
2738 /* FIXME: We should check to see if there is a separate debug info file
2739 that also contains this section, and if so, issue a warning. */
2743 if (do_follow_links
&& separate_debug_file
!= NULL
)
2744 if (load_debug_section (sec_enum
, separate_debug_file
))
2746 debug_displays
[sec_enum
].section
.filename
= separate_debug_filename
;
2754 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
2758 if (do_follow_links
&& section
->filename
)
2759 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
2760 section
->name
, section
->filename
);
2762 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
2766 if (do_follow_links
&& section
->filename
)
2767 printf (_("Contents of the %s section (loaded from %s):\n\n"),
2768 section
->name
, section
->filename
);
2770 printf (_("Contents of the %s section:\n\n"), section
->name
);
2774 /* Process the contents of a .debug_info section.
2775 If do_loc is TRUE then we are scanning for location lists and dwo tags
2776 and we do not want to display anything to the user.
2777 If do_types is TRUE, we are processing a .debug_types section instead of
2778 a .debug_info section.
2779 The information displayed is restricted by the values in DWARF_START_DIE
2780 and DWARF_CUTOFF_LEVEL.
2781 Returns TRUE upon success. Otherwise an error or warning message is
2782 printed and FALSE is returned. */
2785 process_debug_info (struct dwarf_section
* section
,
2787 enum dwarf_section_display_enum abbrev_sec
,
2789 bfd_boolean do_types
)
2791 unsigned char *start
= section
->start
;
2792 unsigned char *end
= start
+ section
->size
;
2793 unsigned char *section_begin
;
2795 unsigned int num_units
= 0;
2797 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2798 && num_debug_info_entries
== 0
2803 /* First scan the section to get the number of comp units. */
2804 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2807 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2808 will be the length. For a 64-bit DWARF section, it'll be
2809 the escape code 0xffffffff followed by an 8 byte length. */
2810 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2812 if (length
== 0xffffffff)
2814 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2815 section_begin
+= length
+ 12;
2817 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2819 warn (_("Reserved length value (0x%s) found in section %s\n"),
2820 dwarf_vmatoa ("x", length
), section
->name
);
2824 section_begin
+= length
+ 4;
2826 /* Negative values are illegal, they may even cause infinite
2827 looping. This can happen if we can't accurately apply
2828 relocations to an object file, or if the file is corrupt. */
2829 if ((signed long) length
<= 0 || section_begin
< start
)
2831 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2832 dwarf_vmatoa ("x", length
), section
->name
);
2839 error (_("No comp units in %s section ?\n"), section
->name
);
2843 /* Then allocate an array to hold the information. */
2844 debug_information
= (debug_info
*) cmalloc (num_units
,
2845 sizeof (* debug_information
));
2846 if (debug_information
== NULL
)
2848 error (_("Not enough memory for a debug info array of %u entries\n"),
2850 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
2854 /* PR 17531: file: 92ca3797.
2855 We cannot rely upon the debug_information array being initialised
2856 before it is used. A corrupt file could easily contain references
2857 to a unit for which information has not been made available. So
2858 we ensure that the array is zeroed here. */
2859 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
2861 alloc_num_debug_info_entries
= num_units
;
2866 load_debug_section_with_follow (str
, file
);
2867 load_debug_section_with_follow (line_str
, file
);
2868 load_debug_section_with_follow (str_dwo
, file
);
2869 load_debug_section_with_follow (str_index
, file
);
2870 load_debug_section_with_follow (str_index_dwo
, file
);
2871 load_debug_section_with_follow (debug_addr
, file
);
2874 load_debug_section_with_follow (abbrev_sec
, file
);
2875 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2877 warn (_("Unable to locate %s section!\n"),
2878 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
2882 if (!do_loc
&& dwarf_start_die
== 0)
2883 introduce (section
, FALSE
);
2885 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2887 DWARF2_Internal_CompUnit compunit
;
2888 unsigned char *hdrptr
;
2889 unsigned char *tags
;
2890 int level
, last_level
, saved_level
;
2891 dwarf_vma cu_offset
;
2892 unsigned long sec_off
;
2893 unsigned int offset_size
;
2894 unsigned int initial_length_size
;
2895 dwarf_vma signature_high
= 0;
2896 dwarf_vma signature_low
= 0;
2897 dwarf_vma type_offset
= 0;
2898 struct cu_tu_set
*this_set
;
2899 dwarf_vma abbrev_base
;
2904 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2906 if (compunit
.cu_length
== 0xffffffff)
2908 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2910 initial_length_size
= 12;
2915 initial_length_size
= 4;
2918 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2920 cu_offset
= start
- section_begin
;
2922 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2924 if (compunit
.cu_version
< 5)
2926 compunit
.cu_unit_type
= DW_UT_compile
;
2927 /* Initialize it due to a false compiler warning. */
2928 compunit
.cu_pointer_size
= -1;
2932 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
2933 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
2935 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2938 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2940 if (this_set
== NULL
)
2943 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2947 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2948 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2951 if (compunit
.cu_version
< 5)
2952 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2954 /* PR 17512: file: 001-108546-0.001:0.1. */
2955 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2957 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2958 compunit
.cu_pointer_size
, offset_size
);
2959 compunit
.cu_pointer_size
= offset_size
;
2964 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2966 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2969 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
2970 + initial_length_size
))
2972 start
= section_begin
+ cu_offset
+ compunit
.cu_length
2973 + initial_length_size
;
2977 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2978 && num_debug_info_entries
== 0
2981 debug_information
[unit
].cu_offset
= cu_offset
;
2982 debug_information
[unit
].pointer_size
2983 = compunit
.cu_pointer_size
;
2984 debug_information
[unit
].offset_size
= offset_size
;
2985 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2986 debug_information
[unit
].base_address
= 0;
2987 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2988 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2989 debug_information
[unit
].loc_offsets
= NULL
;
2990 debug_information
[unit
].have_frame_base
= NULL
;
2991 debug_information
[unit
].max_loc_offsets
= 0;
2992 debug_information
[unit
].num_loc_offsets
= 0;
2993 debug_information
[unit
].range_lists
= NULL
;
2994 debug_information
[unit
].max_range_lists
= 0;
2995 debug_information
[unit
].num_range_lists
= 0;
2998 if (!do_loc
&& dwarf_start_die
== 0)
3000 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3001 dwarf_vmatoa ("x", cu_offset
));
3002 printf (_(" Length: 0x%s (%s)\n"),
3003 dwarf_vmatoa ("x", compunit
.cu_length
),
3004 offset_size
== 8 ? "64-bit" : "32-bit");
3005 printf (_(" Version: %d\n"), compunit
.cu_version
);
3006 printf (_(" Abbrev Offset: 0x%s\n"),
3007 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3008 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3013 printf (_(" Signature: 0x%s\n"),
3014 dwarf_vmatoa64 (signature_high
, signature_low
,
3015 buf
, sizeof (buf
)));
3016 printf (_(" Type Offset: 0x%s\n"),
3017 dwarf_vmatoa ("x", type_offset
));
3019 if (this_set
!= NULL
)
3021 dwarf_vma
*offsets
= this_set
->section_offsets
;
3022 size_t *sizes
= this_set
->section_sizes
;
3024 printf (_(" Section contributions:\n"));
3025 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3026 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3027 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3028 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3029 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3030 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3031 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3032 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3033 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3034 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3035 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3036 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3040 sec_off
= cu_offset
+ initial_length_size
;
3041 if (sec_off
+ compunit
.cu_length
< sec_off
3042 || sec_off
+ compunit
.cu_length
> section
->size
)
3044 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3046 (unsigned long) cu_offset
,
3047 dwarf_vmatoa ("x", compunit
.cu_length
));
3053 start
+= compunit
.cu_length
+ initial_length_size
;
3055 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3057 warn (_("CU at offset %s contains corrupt or "
3058 "unsupported version number: %d.\n"),
3059 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3063 if (compunit
.cu_unit_type
!= DW_UT_compile
3064 && compunit
.cu_unit_type
!= DW_UT_type
)
3066 warn (_("CU at offset %s contains corrupt or "
3067 "unsupported unit type: %d.\n"),
3068 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3074 /* Process the abbrevs used by this compilation unit. */
3075 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3076 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3077 (unsigned long) compunit
.cu_abbrev_offset
,
3078 (unsigned long) abbrev_size
);
3079 /* PR 17531: file:4bcd9ce9. */
3080 else if ((abbrev_base
+ abbrev_size
)
3081 > debug_displays
[abbrev_sec
].section
.size
)
3082 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3083 (unsigned long) abbrev_base
+ abbrev_size
,
3084 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3086 process_abbrev_section
3087 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3088 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3089 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3090 + abbrev_base
+ abbrev_size
));
3095 while (tags
< start
)
3097 unsigned int bytes_read
;
3098 unsigned long abbrev_number
;
3099 unsigned long die_offset
;
3100 abbrev_entry
*entry
;
3102 int do_printing
= 1;
3104 die_offset
= tags
- section_begin
;
3106 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
3109 /* A null DIE marks the end of a list of siblings or it may also be
3110 a section padding. */
3111 if (abbrev_number
== 0)
3113 /* Check if it can be a section padding for the last CU. */
3114 if (level
== 0 && start
== end
)
3118 for (chk
= tags
; chk
< start
; chk
++)
3125 if (!do_loc
&& die_offset
>= dwarf_start_die
3126 && (dwarf_cutoff_level
== -1
3127 || level
< dwarf_cutoff_level
))
3128 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3134 static unsigned num_bogus_warns
= 0;
3136 if (num_bogus_warns
< 3)
3138 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3139 die_offset
, section
->name
);
3141 if (num_bogus_warns
== 3)
3142 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3145 if (dwarf_start_die
!= 0 && level
< saved_level
)
3152 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3156 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3157 saved_level
= level
;
3158 do_printing
= (dwarf_cutoff_level
== -1
3159 || level
< dwarf_cutoff_level
);
3161 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3162 level
, die_offset
, abbrev_number
);
3163 else if (dwarf_cutoff_level
== -1
3164 || last_level
< dwarf_cutoff_level
)
3165 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3170 /* Scan through the abbreviation list until we reach the
3172 for (entry
= first_abbrev
;
3173 entry
&& entry
->entry
!= abbrev_number
;
3174 entry
= entry
->next
)
3179 if (!do_loc
&& do_printing
)
3184 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3185 die_offset
, abbrev_number
);
3189 if (!do_loc
&& do_printing
)
3190 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3195 need_base_address
= 0;
3197 case DW_TAG_compile_unit
:
3198 need_base_address
= 1;
3199 need_dwo_info
= do_loc
;
3201 case DW_TAG_entry_point
:
3202 case DW_TAG_subprogram
:
3203 need_base_address
= 0;
3204 /* Assuming that there is no DW_AT_frame_base. */
3205 have_frame_base
= 0;
3209 debug_info
*debug_info_p
=
3210 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3211 ? debug_information
+ unit
: NULL
;
3213 assert (!debug_info_p
3214 || (debug_info_p
->num_loc_offsets
3215 == debug_info_p
->num_loc_views
));
3217 for (attr
= entry
->first_attr
;
3218 attr
&& attr
->attribute
;
3221 if (! do_loc
&& do_printing
)
3222 /* Show the offset from where the tag was extracted. */
3223 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3225 tags
= read_and_display_attr (attr
->attribute
,
3227 attr
->implicit_const
,
3231 compunit
.cu_pointer_size
,
3233 compunit
.cu_version
,
3235 do_loc
|| ! do_printing
,
3240 /* If a locview attribute appears before a location one,
3241 make sure we don't associate it with an earlier
3244 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3247 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3248 debug_info_p
->num_loc_views
++;
3249 assert (debug_info_p
->num_loc_views
3250 == debug_info_p
->num_loc_offsets
);
3257 warn(_("DIE has locviews without loclist\n"));
3258 debug_info_p
->num_loc_views
--;
3265 if (entry
->children
)
3270 /* Set num_debug_info_entries here so that it can be used to check if
3271 we need to process .debug_loc and .debug_ranges sections. */
3272 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3273 && num_debug_info_entries
== 0
3276 if (num_units
> alloc_num_debug_info_entries
)
3277 num_debug_info_entries
= alloc_num_debug_info_entries
;
3279 num_debug_info_entries
= num_units
;
3288 /* Locate and scan the .debug_info section in the file and record the pointer
3289 sizes and offsets for the compilation units in it. Usually an executable
3290 will have just one pointer size, but this is not guaranteed, and so we try
3291 not to make any assumptions. Returns zero upon failure, or the number of
3292 compilation units upon success. */
3295 load_debug_info (void * file
)
3297 /* If we have already tried and failed to load the .debug_info
3298 section then do not bother to repeat the task. */
3299 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3302 /* If we already have the information there is nothing else to do. */
3303 if (num_debug_info_entries
> 0)
3304 return num_debug_info_entries
;
3306 /* If this is a DWARF package file, load the CU and TU indexes. */
3307 (void) load_cu_tu_indexes (file
);
3309 if (load_debug_section_with_follow (info
, file
)
3310 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3311 return num_debug_info_entries
;
3313 if (load_debug_section_with_follow (info_dwo
, file
)
3314 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3315 abbrev_dwo
, TRUE
, FALSE
))
3316 return num_debug_info_entries
;
3318 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3322 /* Read a DWARF .debug_line section header starting at DATA.
3323 Upon success returns an updated DATA pointer and the LINFO
3324 structure and the END_OF_SEQUENCE pointer will be filled in.
3325 Otherwise returns NULL. */
3327 static unsigned char *
3328 read_debug_line_header (struct dwarf_section
* section
,
3329 unsigned char * data
,
3330 unsigned char * end
,
3331 DWARF2_Internal_LineInfo
* linfo
,
3332 unsigned char ** end_of_sequence
)
3334 unsigned char *hdrptr
;
3335 unsigned int initial_length_size
;
3336 unsigned char address_size
, segment_selector_size
;
3338 /* Extract information from the Line Number Program Header.
3339 (section 6.2.4 in the Dwarf3 doc). */
3342 /* Get and check the length of the block. */
3343 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3345 if (linfo
->li_length
== 0xffffffff)
3347 /* This section is 64-bit DWARF 3. */
3348 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3349 linfo
->li_offset_size
= 8;
3350 initial_length_size
= 12;
3354 linfo
->li_offset_size
= 4;
3355 initial_length_size
= 4;
3358 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3360 /* If the length field has a relocation against it, then we should
3361 not complain if it is inaccurate (and probably negative). This
3362 happens in object files when the .debug_line section is actually
3363 comprised of several different .debug_line.* sections, (some of
3364 which may be removed by linker garbage collection), and a relocation
3365 is used to compute the correct length once that is done. */
3366 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3368 linfo
->li_length
= (end
- data
) - initial_length_size
;
3372 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3373 (long) linfo
->li_length
);
3378 /* Get and check the version number. */
3379 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3381 if (linfo
->li_version
!= 2
3382 && linfo
->li_version
!= 3
3383 && linfo
->li_version
!= 4
3384 && linfo
->li_version
!= 5)
3386 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3387 "is currently supported.\n"));
3391 if (linfo
->li_version
>= 5)
3393 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
3395 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
3396 if (segment_selector_size
!= 0)
3398 warn (_("The %s section contains "
3399 "unsupported segment selector size: %d.\n"),
3400 section
->name
, segment_selector_size
);
3405 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3406 linfo
->li_offset_size
, end
);
3407 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3409 if (linfo
->li_version
>= 4)
3411 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3413 if (linfo
->li_max_ops_per_insn
== 0)
3415 warn (_("Invalid maximum operations per insn.\n"));
3420 linfo
->li_max_ops_per_insn
= 1;
3422 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3423 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3424 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3425 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3427 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3428 /* PR 17512: file:002-117414-0.004. */
3429 if (* end_of_sequence
> end
)
3431 warn (_("Line length %s extends beyond end of section\n"),
3432 dwarf_vmatoa ("u", linfo
->li_length
));
3433 * end_of_sequence
= end
;
3440 static unsigned char *
3441 display_formatted_table (unsigned char * data
,
3442 unsigned char * start
,
3443 unsigned char * end
,
3444 const DWARF2_Internal_LineInfo
* linfo
,
3445 struct dwarf_section
* section
,
3448 unsigned char *format_start
, format_count
, *format
, formati
;
3449 dwarf_vma data_count
, datai
;
3450 unsigned int bytes_read
, namepass
, last_entry
= 0;
3452 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3453 format_start
= data
;
3454 for (formati
= 0; formati
< format_count
; formati
++)
3456 read_uleb128 (data
, & bytes_read
, end
);
3458 read_uleb128 (data
, & bytes_read
, end
);
3463 warn (_("Corrupt directory format table entry\n"));
3465 warn (_("Corrupt file name format table entry\n"));
3470 data_count
= read_uleb128 (data
, & bytes_read
, end
);
3475 warn (_("Corrupt directory list\n"));
3477 warn (_("Corrupt file name list\n"));
3481 if (data_count
== 0)
3484 printf (_("\n The Directory Table is empty.\n"));
3486 printf (_("\n The File Name Table is empty.\n"));
3491 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3492 (long) (data
- start
));
3494 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3495 (long) (data
- start
));
3497 printf (_(" Entry"));
3498 /* Delay displaying name as the last entry for better screen layout. */
3499 for (namepass
= 0; namepass
< 2; namepass
++)
3501 format
= format_start
;
3502 for (formati
= 0; formati
< format_count
; formati
++)
3504 dwarf_vma content_type
;
3506 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3507 format
+= bytes_read
;
3508 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3509 switch (content_type
)
3512 printf (_("\tName"));
3514 case DW_LNCT_directory_index
:
3515 printf (_("\tDir"));
3517 case DW_LNCT_timestamp
:
3518 printf (_("\tTime"));
3521 printf (_("\tSize"));
3524 printf (_("\tMD5"));
3527 printf (_("\t(Unknown format content type %s)"),
3528 dwarf_vmatoa ("u", content_type
));
3530 read_uleb128 (format
, & bytes_read
, end
);
3531 format
+= bytes_read
;
3536 for (datai
= 0; datai
< data_count
; datai
++)
3538 unsigned char *datapass
= data
;
3540 printf (" %d", last_entry
++);
3541 /* Delay displaying name as the last entry for better screen layout. */
3542 for (namepass
= 0; namepass
< 2; namepass
++)
3544 format
= format_start
;
3546 for (formati
= 0; formati
< format_count
; formati
++)
3548 dwarf_vma content_type
, form
;
3550 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3551 format
+= bytes_read
;
3552 form
= read_uleb128 (format
, & bytes_read
, end
);
3553 format
+= bytes_read
;
3554 data
= read_and_display_attr_value (0, form
, 0, data
, end
, 0, 0,
3555 linfo
->li_offset_size
,
3556 linfo
->li_version
, NULL
,
3557 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3558 section
, NULL
, '\t');
3564 warn (_("Corrupt directory entries list\n"));
3566 warn (_("Corrupt file name entries list\n"));
3575 display_debug_lines_raw (struct dwarf_section
* section
,
3576 unsigned char * data
,
3577 unsigned char * end
,
3580 unsigned char *start
= section
->start
;
3581 int verbose_view
= 0;
3583 introduce (section
, TRUE
);
3587 static DWARF2_Internal_LineInfo saved_linfo
;
3588 DWARF2_Internal_LineInfo linfo
;
3589 unsigned char *standard_opcodes
;
3590 unsigned char *end_of_sequence
;
3593 if (const_strneq (section
->name
, ".debug_line.")
3594 /* Note: the following does not apply to .debug_line.dwo sections.
3595 These are full debug_line sections. */
3596 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3598 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3599 section containing just the Line Number Statements. They are
3600 created by the assembler and intended to be used alongside gcc's
3601 -ffunction-sections command line option. When the linker's
3602 garbage collection decides to discard a .text.<foo> section it
3603 can then also discard the line number information in .debug_line.<foo>.
3605 Since the section is a fragment it does not have the details
3606 needed to fill out a LineInfo structure, so instead we use the
3607 details from the last full debug_line section that we processed. */
3608 end_of_sequence
= end
;
3609 standard_opcodes
= NULL
;
3610 linfo
= saved_linfo
;
3611 /* PR 17531: file: 0522b371. */
3612 if (linfo
.li_line_range
== 0)
3614 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3617 reset_state_machine (linfo
.li_default_is_stmt
);
3621 unsigned char * hdrptr
;
3623 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3624 & end_of_sequence
)) == NULL
)
3627 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3628 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3629 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3630 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3631 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3632 if (linfo
.li_version
>= 4)
3633 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3634 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3635 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3636 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3637 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3639 /* PR 17512: file: 1665-6428-0.004. */
3640 if (linfo
.li_line_range
== 0)
3642 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3643 linfo
.li_line_range
= 1;
3646 reset_state_machine (linfo
.li_default_is_stmt
);
3648 /* Display the contents of the Opcodes table. */
3649 standard_opcodes
= hdrptr
;
3651 /* PR 17512: file: 002-417945-0.004. */
3652 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3654 warn (_("Line Base extends beyond end of section\n"));
3658 printf (_("\n Opcodes:\n"));
3660 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3661 printf (ngettext (" Opcode %d has %d arg\n",
3662 " Opcode %d has %d args\n",
3663 standard_opcodes
[i
- 1]),
3664 i
, standard_opcodes
[i
- 1]);
3666 /* Display the contents of the Directory table. */
3667 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3669 if (linfo
.li_version
>= 5)
3671 load_debug_section_with_follow (line_str
, file
);
3673 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3675 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3681 printf (_("\n The Directory Table is empty.\n"));
3684 unsigned int last_dir_entry
= 0;
3686 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3687 (long)(data
- start
));
3689 while (data
< end
&& *data
!= 0)
3691 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
3693 data
+= strnlen ((char *) data
, end
- data
) + 1;
3696 /* PR 17512: file: 002-132094-0.004. */
3697 if (data
>= end
- 1)
3701 /* Skip the NUL at the end of the table. */
3704 /* Display the contents of the File Name table. */
3706 printf (_("\n The File Name Table is empty.\n"));
3709 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3710 (long)(data
- start
));
3711 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3713 while (data
< end
&& *data
!= 0)
3715 unsigned char *name
;
3716 unsigned int bytes_read
;
3718 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
3720 data
+= strnlen ((char *) data
, end
- data
) + 1;
3723 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3726 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3729 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3731 printf ("%.*s\n", (int)(end
- name
), name
);
3735 warn (_("Corrupt file name table entry\n"));
3741 /* Skip the NUL at the end of the table. */
3746 saved_linfo
= linfo
;
3749 /* Now display the statements. */
3750 if (data
>= end_of_sequence
)
3751 printf (_(" No Line Number Statements.\n"));
3754 printf (_(" Line Number Statements:\n"));
3756 while (data
< end_of_sequence
)
3758 unsigned char op_code
;
3759 dwarf_signed_vma adv
;
3761 unsigned int bytes_read
;
3763 printf (" [0x%08lx]", (long)(data
- start
));
3767 if (op_code
>= linfo
.li_opcode_base
)
3769 op_code
-= linfo
.li_opcode_base
;
3770 uladv
= (op_code
/ linfo
.li_line_range
);
3771 if (linfo
.li_max_ops_per_insn
== 1)
3773 uladv
*= linfo
.li_min_insn_length
;
3774 state_machine_regs
.address
+= uladv
;
3776 state_machine_regs
.view
= 0;
3777 printf (_(" Special opcode %d: "
3778 "advance Address by %s to 0x%s%s"),
3779 op_code
, dwarf_vmatoa ("u", uladv
),
3780 dwarf_vmatoa ("x", state_machine_regs
.address
),
3781 verbose_view
&& uladv
3782 ? _(" (reset view)") : "");
3787 = ((state_machine_regs
.op_index
+ uladv
)
3788 / linfo
.li_max_ops_per_insn
)
3789 * linfo
.li_min_insn_length
;
3791 state_machine_regs
.address
+= addrdelta
;
3792 state_machine_regs
.op_index
3793 = (state_machine_regs
.op_index
+ uladv
)
3794 % linfo
.li_max_ops_per_insn
;
3796 state_machine_regs
.view
= 0;
3797 printf (_(" Special opcode %d: "
3798 "advance Address by %s to 0x%s[%d]%s"),
3799 op_code
, dwarf_vmatoa ("u", uladv
),
3800 dwarf_vmatoa ("x", state_machine_regs
.address
),
3801 state_machine_regs
.op_index
,
3802 verbose_view
&& addrdelta
3803 ? _(" (reset view)") : "");
3805 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3806 state_machine_regs
.line
+= adv
;
3807 printf (_(" and Line by %s to %d"),
3808 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
3809 if (verbose_view
|| state_machine_regs
.view
)
3810 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3813 state_machine_regs
.view
++;
3815 else switch (op_code
)
3817 case DW_LNS_extended_op
:
3818 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3822 printf (_(" Copy"));
3823 if (verbose_view
|| state_machine_regs
.view
)
3824 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3827 state_machine_regs
.view
++;
3830 case DW_LNS_advance_pc
:
3831 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3833 if (linfo
.li_max_ops_per_insn
== 1)
3835 uladv
*= linfo
.li_min_insn_length
;
3836 state_machine_regs
.address
+= uladv
;
3838 state_machine_regs
.view
= 0;
3839 printf (_(" Advance PC by %s to 0x%s%s\n"),
3840 dwarf_vmatoa ("u", uladv
),
3841 dwarf_vmatoa ("x", state_machine_regs
.address
),
3842 verbose_view
&& uladv
3843 ? _(" (reset view)") : "");
3848 = ((state_machine_regs
.op_index
+ uladv
)
3849 / linfo
.li_max_ops_per_insn
)
3850 * linfo
.li_min_insn_length
;
3851 state_machine_regs
.address
3853 state_machine_regs
.op_index
3854 = (state_machine_regs
.op_index
+ uladv
)
3855 % linfo
.li_max_ops_per_insn
;
3857 state_machine_regs
.view
= 0;
3858 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
3859 dwarf_vmatoa ("u", uladv
),
3860 dwarf_vmatoa ("x", state_machine_regs
.address
),
3861 state_machine_regs
.op_index
,
3862 verbose_view
&& addrdelta
3863 ? _(" (reset view)") : "");
3867 case DW_LNS_advance_line
:
3868 adv
= read_sleb128 (data
, & bytes_read
, end
);
3870 state_machine_regs
.line
+= adv
;
3871 printf (_(" Advance Line by %s to %d\n"),
3872 dwarf_vmatoa ("d", adv
),
3873 state_machine_regs
.line
);
3876 case DW_LNS_set_file
:
3877 adv
= read_uleb128 (data
, & bytes_read
, end
);
3879 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3880 dwarf_vmatoa ("d", adv
));
3881 state_machine_regs
.file
= adv
;
3884 case DW_LNS_set_column
:
3885 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3887 printf (_(" Set column to %s\n"),
3888 dwarf_vmatoa ("u", uladv
));
3889 state_machine_regs
.column
= uladv
;
3892 case DW_LNS_negate_stmt
:
3893 adv
= state_machine_regs
.is_stmt
;
3895 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3896 state_machine_regs
.is_stmt
= adv
;
3899 case DW_LNS_set_basic_block
:
3900 printf (_(" Set basic block\n"));
3901 state_machine_regs
.basic_block
= 1;
3904 case DW_LNS_const_add_pc
:
3905 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3906 if (linfo
.li_max_ops_per_insn
)
3908 uladv
*= linfo
.li_min_insn_length
;
3909 state_machine_regs
.address
+= uladv
;
3911 state_machine_regs
.view
= 0;
3912 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
3913 dwarf_vmatoa ("u", uladv
),
3914 dwarf_vmatoa ("x", state_machine_regs
.address
),
3915 verbose_view
&& uladv
3916 ? _(" (reset view)") : "");
3921 = ((state_machine_regs
.op_index
+ uladv
)
3922 / linfo
.li_max_ops_per_insn
)
3923 * linfo
.li_min_insn_length
;
3924 state_machine_regs
.address
3926 state_machine_regs
.op_index
3927 = (state_machine_regs
.op_index
+ uladv
)
3928 % linfo
.li_max_ops_per_insn
;
3930 state_machine_regs
.view
= 0;
3931 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
3932 dwarf_vmatoa ("u", uladv
),
3933 dwarf_vmatoa ("x", state_machine_regs
.address
),
3934 state_machine_regs
.op_index
,
3935 verbose_view
&& addrdelta
3936 ? _(" (reset view)") : "");
3940 case DW_LNS_fixed_advance_pc
:
3941 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3942 state_machine_regs
.address
+= uladv
;
3943 state_machine_regs
.op_index
= 0;
3944 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3945 dwarf_vmatoa ("u", uladv
),
3946 dwarf_vmatoa ("x", state_machine_regs
.address
));
3947 /* Do NOT reset view. */
3950 case DW_LNS_set_prologue_end
:
3951 printf (_(" Set prologue_end to true\n"));
3954 case DW_LNS_set_epilogue_begin
:
3955 printf (_(" Set epilogue_begin to true\n"));
3958 case DW_LNS_set_isa
:
3959 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3961 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3965 printf (_(" Unknown opcode %d with operands: "), op_code
);
3967 if (standard_opcodes
!= NULL
)
3968 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3970 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3972 i
== 1 ? "" : ", ");
3988 unsigned char *name
;
3989 unsigned int directory_index
;
3990 unsigned int modification_date
;
3991 unsigned int length
;
3994 /* Output a decoded representation of the .debug_line section. */
3997 display_debug_lines_decoded (struct dwarf_section
* section
,
3998 unsigned char * data
,
3999 unsigned char * end
,
4002 static DWARF2_Internal_LineInfo saved_linfo
;
4004 introduce (section
, FALSE
);
4008 /* This loop amounts to one iteration per compilation unit. */
4009 DWARF2_Internal_LineInfo linfo
;
4010 unsigned char *standard_opcodes
;
4011 unsigned char *end_of_sequence
;
4013 File_Entry
*file_table
= NULL
;
4014 unsigned int n_files
= 0;
4015 unsigned char **directory_table
= NULL
;
4016 dwarf_vma n_directories
= 0;
4018 if (const_strneq (section
->name
, ".debug_line.")
4019 /* Note: the following does not apply to .debug_line.dwo sections.
4020 These are full debug_line sections. */
4021 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4023 /* See comment in display_debug_lines_raw(). */
4024 end_of_sequence
= end
;
4025 standard_opcodes
= NULL
;
4026 linfo
= saved_linfo
;
4027 /* PR 17531: file: 0522b371. */
4028 if (linfo
.li_line_range
== 0)
4030 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4033 reset_state_machine (linfo
.li_default_is_stmt
);
4037 unsigned char *hdrptr
;
4039 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4040 & end_of_sequence
)) == NULL
)
4043 /* PR 17531: file: 0522b371. */
4044 if (linfo
.li_line_range
== 0)
4046 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4047 linfo
.li_line_range
= 1;
4049 reset_state_machine (linfo
.li_default_is_stmt
);
4051 /* Save a pointer to the contents of the Opcodes table. */
4052 standard_opcodes
= hdrptr
;
4054 /* Traverse the Directory table just to count entries. */
4055 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4059 warn (_("opcode base of %d extends beyond end of section\n"),
4060 linfo
.li_opcode_base
);
4064 if (linfo
.li_version
>= 5)
4066 unsigned char *format_start
, format_count
, *format
;
4067 dwarf_vma formati
, entryi
;
4068 unsigned int bytes_read
;
4070 load_debug_section_with_follow (line_str
, fileptr
);
4072 /* Skip directories format. */
4073 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4074 format_start
= data
;
4075 for (formati
= 0; formati
< format_count
; formati
++)
4077 read_uleb128 (data
, & bytes_read
, end
);
4079 read_uleb128 (data
, & bytes_read
, end
);
4083 n_directories
= read_uleb128 (data
, & bytes_read
, end
);
4087 warn (_("Corrupt directories list\n"));
4091 directory_table
= (unsigned char **)
4092 xmalloc (n_directories
* sizeof (unsigned char *));
4094 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4096 unsigned char **pathp
= &directory_table
[entryi
];
4098 format
= format_start
;
4099 for (formati
= 0; formati
< format_count
; formati
++)
4101 dwarf_vma content_type
, form
;
4104 content_type
= read_uleb128 (format
, & bytes_read
, end
);
4105 format
+= bytes_read
;
4106 form
= read_uleb128 (format
, & bytes_read
, end
);
4107 format
+= bytes_read
;
4110 warn (_("Corrupt directories list\n"));
4113 switch (content_type
)
4118 case DW_FORM_string
:
4121 case DW_FORM_line_strp
:
4122 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4124 /* Remove const by the cast. */
4125 *pathp
= (unsigned char *)
4126 fetch_indirect_line_string (uvalue
);
4131 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
4133 linfo
.li_offset_size
,
4140 warn (_("Corrupt directories list\n"));
4145 /* Skip files format. */
4146 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4147 format_start
= data
;
4148 for (formati
= 0; formati
< format_count
; formati
++)
4150 read_uleb128 (data
, & bytes_read
, end
);
4152 read_uleb128 (data
, & bytes_read
, end
);
4156 n_files
= read_uleb128 (data
, & bytes_read
, end
);
4160 warn (_("Corrupt file name list\n"));
4164 file_table
= (File_Entry
*) xcalloc (1, n_files
4165 * sizeof (File_Entry
));
4167 for (entryi
= 0; entryi
< n_files
; entryi
++)
4169 File_Entry
*file
= &file_table
[entryi
];
4171 format
= format_start
;
4172 for (formati
= 0; formati
< format_count
; formati
++)
4174 dwarf_vma content_type
, form
;
4177 content_type
= read_uleb128 (format
, & bytes_read
, end
);
4178 format
+= bytes_read
;
4179 form
= read_uleb128 (format
, & bytes_read
, end
);
4180 format
+= bytes_read
;
4183 warn (_("Corrupt file name list\n"));
4186 switch (content_type
)
4191 case DW_FORM_string
:
4194 case DW_FORM_line_strp
:
4195 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4197 /* Remove const by the cast. */
4198 file
->name
= (unsigned char *)
4199 fetch_indirect_line_string (uvalue
);
4203 case DW_LNCT_directory_index
:
4207 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4211 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4215 file
->directory_index
= read_uleb128 (data
, NULL
,
4221 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
4223 linfo
.li_offset_size
,
4230 warn (_("Corrupt file name list\n"));
4239 unsigned char *ptr_directory_table
= data
;
4241 while (data
< end
&& *data
!= 0)
4243 data
+= strnlen ((char *) data
, end
- data
) + 1;
4250 warn (_("directory table ends unexpectedly\n"));
4255 /* Go through the directory table again to save the directories. */
4256 directory_table
= (unsigned char **)
4257 xmalloc (n_directories
* sizeof (unsigned char *));
4260 while (*ptr_directory_table
!= 0)
4262 directory_table
[i
] = ptr_directory_table
;
4263 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4264 ptr_directory_table
- end
) + 1;
4268 /* Skip the NUL at the end of the table. */
4271 /* Traverse the File Name table just to count the entries. */
4272 if (data
< end
&& *data
!= 0)
4274 unsigned char *ptr_file_name_table
= data
;
4276 while (data
< end
&& *data
!= 0)
4278 unsigned int bytes_read
;
4280 /* Skip Name, directory index, last modification time and length
4282 data
+= strnlen ((char *) data
, end
- data
) + 1;
4283 read_uleb128 (data
, & bytes_read
, end
);
4285 read_uleb128 (data
, & bytes_read
, end
);
4287 read_uleb128 (data
, & bytes_read
, end
);
4295 warn (_("file table ends unexpectedly\n"));
4300 /* Go through the file table again to save the strings. */
4301 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4304 while (*ptr_file_name_table
!= 0)
4306 unsigned int bytes_read
;
4308 file_table
[i
].name
= ptr_file_name_table
;
4309 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4310 end
- ptr_file_name_table
) + 1;
4312 /* We are not interested in directory, time or size. */
4313 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
4315 ptr_file_name_table
+= bytes_read
;
4316 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
4318 ptr_file_name_table
+= bytes_read
;
4319 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
4320 ptr_file_name_table
+= bytes_read
;
4326 /* Skip the NUL at the end of the table. */
4330 /* Print the Compilation Unit's name and a header. */
4331 if (file_table
== NULL
)
4333 else if (directory_table
== NULL
)
4334 printf (_("CU: %s:\n"), file_table
[0].name
);
4337 unsigned int ix
= file_table
[0].directory_index
;
4338 const char *directory
;
4343 else if (n_directories
== 0)
4344 directory
= _("<unknown>");
4345 else if (ix
> n_directories
)
4347 warn (_("directory index %u > number of directories %s\n"),
4348 ix
, dwarf_vmatoa ("u", n_directories
));
4349 directory
= _("<corrupt>");
4352 directory
= (char *) directory_table
[ix
- 1];
4354 if (do_wide
|| strlen (directory
) < 76)
4355 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4357 printf ("%s:\n", file_table
[0].name
);
4360 printf (_("File name Line number Starting address View Stmt\n"));
4361 saved_linfo
= linfo
;
4364 /* This loop iterates through the Dwarf Line Number Program. */
4365 while (data
< end_of_sequence
)
4367 unsigned char op_code
;
4370 unsigned long int uladv
;
4371 unsigned int bytes_read
;
4372 int is_special_opcode
= 0;
4377 if (op_code
>= linfo
.li_opcode_base
)
4379 op_code
-= linfo
.li_opcode_base
;
4380 uladv
= (op_code
/ linfo
.li_line_range
);
4381 if (linfo
.li_max_ops_per_insn
== 1)
4383 uladv
*= linfo
.li_min_insn_length
;
4384 state_machine_regs
.address
+= uladv
;
4386 state_machine_regs
.view
= 0;
4391 = ((state_machine_regs
.op_index
+ uladv
)
4392 / linfo
.li_max_ops_per_insn
)
4393 * linfo
.li_min_insn_length
;
4394 state_machine_regs
.address
4396 state_machine_regs
.op_index
4397 = (state_machine_regs
.op_index
+ uladv
)
4398 % linfo
.li_max_ops_per_insn
;
4400 state_machine_regs
.view
= 0;
4403 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4404 state_machine_regs
.line
+= adv
;
4405 is_special_opcode
= 1;
4406 /* Increment view after printing this row. */
4408 else switch (op_code
)
4410 case DW_LNS_extended_op
:
4412 unsigned int ext_op_code_len
;
4413 unsigned char ext_op_code
;
4414 unsigned char *op_code_data
= data
;
4416 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
4418 op_code_data
+= bytes_read
;
4420 if (ext_op_code_len
== 0)
4422 warn (_("Badly formed extended line op encountered!\n"));
4425 ext_op_code_len
+= bytes_read
;
4426 ext_op_code
= *op_code_data
++;
4430 switch (ext_op_code
)
4432 case DW_LNE_end_sequence
:
4433 /* Reset stuff after printing this row. */
4435 case DW_LNE_set_address
:
4436 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4438 ext_op_code_len
- bytes_read
- 1,
4440 state_machine_regs
.op_index
= 0;
4441 state_machine_regs
.view
= 0;
4443 case DW_LNE_define_file
:
4445 file_table
= (File_Entry
*) xrealloc
4446 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4448 ++state_machine_regs
.last_file_entry
;
4449 /* Source file name. */
4450 file_table
[n_files
].name
= op_code_data
;
4451 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4452 /* Directory index. */
4453 file_table
[n_files
].directory_index
=
4454 read_uleb128 (op_code_data
, & bytes_read
,
4456 op_code_data
+= bytes_read
;
4457 /* Last modification time. */
4458 file_table
[n_files
].modification_date
=
4459 read_uleb128 (op_code_data
, & bytes_read
,
4461 op_code_data
+= bytes_read
;
4463 file_table
[n_files
].length
=
4464 read_uleb128 (op_code_data
, & bytes_read
,
4470 case DW_LNE_set_discriminator
:
4471 case DW_LNE_HP_set_sequence
:
4472 /* Simply ignored. */
4476 printf (_("UNKNOWN (%u): length %d\n"),
4477 ext_op_code
, ext_op_code_len
- bytes_read
);
4480 data
+= ext_op_code_len
;
4484 /* Increment view after printing this row. */
4487 case DW_LNS_advance_pc
:
4488 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4490 if (linfo
.li_max_ops_per_insn
== 1)
4492 uladv
*= linfo
.li_min_insn_length
;
4493 state_machine_regs
.address
+= uladv
;
4495 state_machine_regs
.view
= 0;
4500 = ((state_machine_regs
.op_index
+ uladv
)
4501 / linfo
.li_max_ops_per_insn
)
4502 * linfo
.li_min_insn_length
;
4503 state_machine_regs
.address
4505 state_machine_regs
.op_index
4506 = (state_machine_regs
.op_index
+ uladv
)
4507 % linfo
.li_max_ops_per_insn
;
4509 state_machine_regs
.view
= 0;
4513 case DW_LNS_advance_line
:
4514 adv
= read_sleb128 (data
, & bytes_read
, end
);
4516 state_machine_regs
.line
+= adv
;
4519 case DW_LNS_set_file
:
4520 adv
= read_uleb128 (data
, & bytes_read
, end
);
4522 state_machine_regs
.file
= adv
;
4525 unsigned file
= state_machine_regs
.file
- 1;
4528 if (file_table
== NULL
|| n_files
== 0)
4529 printf (_("\n [Use file table entry %d]\n"), file
);
4531 else if (file
>= n_files
)
4533 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4534 printf (_("\n <over large file table index %u>"), file
);
4536 else if ((dir
= file_table
[file
].directory_index
) == 0)
4537 /* If directory index is 0, that means current directory. */
4538 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4539 else if (directory_table
== NULL
|| n_directories
== 0)
4540 printf (_("\n [Use file %s in directory table entry %d]\n"),
4541 file_table
[file
].name
, dir
);
4543 else if (dir
> n_directories
)
4545 warn (_("directory index %u > number of directories %s\n"),
4546 dir
, dwarf_vmatoa ("u", n_directories
));
4547 printf (_("\n <over large directory table entry %u>\n"), dir
);
4550 printf ("\n%s/%s:\n",
4551 /* The directory index starts counting at 1. */
4552 directory_table
[dir
- 1], file_table
[file
].name
);
4556 case DW_LNS_set_column
:
4557 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4559 state_machine_regs
.column
= uladv
;
4562 case DW_LNS_negate_stmt
:
4563 adv
= state_machine_regs
.is_stmt
;
4565 state_machine_regs
.is_stmt
= adv
;
4568 case DW_LNS_set_basic_block
:
4569 state_machine_regs
.basic_block
= 1;
4572 case DW_LNS_const_add_pc
:
4573 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4574 if (linfo
.li_max_ops_per_insn
== 1)
4576 uladv
*= linfo
.li_min_insn_length
;
4577 state_machine_regs
.address
+= uladv
;
4579 state_machine_regs
.view
= 0;
4584 = ((state_machine_regs
.op_index
+ uladv
)
4585 / linfo
.li_max_ops_per_insn
)
4586 * linfo
.li_min_insn_length
;
4587 state_machine_regs
.address
4589 state_machine_regs
.op_index
4590 = (state_machine_regs
.op_index
+ uladv
)
4591 % linfo
.li_max_ops_per_insn
;
4593 state_machine_regs
.view
= 0;
4597 case DW_LNS_fixed_advance_pc
:
4598 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4599 state_machine_regs
.address
+= uladv
;
4600 state_machine_regs
.op_index
= 0;
4601 /* Do NOT reset view. */
4604 case DW_LNS_set_prologue_end
:
4607 case DW_LNS_set_epilogue_begin
:
4610 case DW_LNS_set_isa
:
4611 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4613 printf (_(" Set ISA to %lu\n"), uladv
);
4617 printf (_(" Unknown opcode %d with operands: "), op_code
);
4619 if (standard_opcodes
!= NULL
)
4620 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4622 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
4624 i
== 1 ? "" : ", ");
4631 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4632 to the DWARF address/line matrix. */
4633 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4634 || (xop
== DW_LNS_copy
))
4636 const unsigned int MAX_FILENAME_LENGTH
= 35;
4638 char *newFileName
= NULL
;
4639 size_t fileNameLength
;
4643 unsigned indx
= state_machine_regs
.file
- 1;
4645 if (indx
>= n_files
)
4647 warn (_("corrupt file index %u encountered\n"), indx
);
4648 fileName
= _("<corrupt>");
4651 fileName
= (char *) file_table
[indx
].name
;
4654 fileName
= _("<unknown>");
4656 fileNameLength
= strlen (fileName
);
4658 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4660 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4661 /* Truncate file name */
4662 strncpy (newFileName
,
4663 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4664 MAX_FILENAME_LENGTH
+ 1);
4668 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4669 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4672 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4674 if (linfo
.li_max_ops_per_insn
== 1)
4675 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4676 newFileName
, state_machine_regs
.line
,
4677 state_machine_regs
.address
);
4679 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4680 newFileName
, state_machine_regs
.line
,
4681 state_machine_regs
.address
,
4682 state_machine_regs
.op_index
);
4686 if (linfo
.li_max_ops_per_insn
== 1)
4687 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
4688 newFileName
, state_machine_regs
.line
,
4689 state_machine_regs
.address
);
4691 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4692 newFileName
, state_machine_regs
.line
,
4693 state_machine_regs
.address
,
4694 state_machine_regs
.op_index
);
4697 if (state_machine_regs
.view
)
4698 printf (" %6u", state_machine_regs
.view
);
4702 if (state_machine_regs
.is_stmt
)
4706 state_machine_regs
.view
++;
4708 if (xop
== -DW_LNE_end_sequence
)
4710 reset_state_machine (linfo
.li_default_is_stmt
);
4725 if (directory_table
)
4727 free (directory_table
);
4728 directory_table
= NULL
;
4739 display_debug_lines (struct dwarf_section
*section
, void *file
)
4741 unsigned char *data
= section
->start
;
4742 unsigned char *end
= data
+ section
->size
;
4744 int retValDecoded
= 1;
4746 if (do_debug_lines
== 0)
4747 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
4749 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
4750 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
4752 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
4753 retValDecoded
= display_debug_lines_decoded (section
, data
, end
, file
);
4755 if (!retValRaw
|| !retValDecoded
)
4762 find_debug_info_for_offset (unsigned long offset
)
4766 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4769 for (i
= 0; i
< num_debug_info_entries
; i
++)
4770 if (debug_information
[i
].cu_offset
== offset
)
4771 return debug_information
+ i
;
4777 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
4779 /* See gdb/gdb-index.h. */
4780 static const char * const kinds
[] =
4792 return _ (kinds
[kind
]);
4796 display_debug_pubnames_worker (struct dwarf_section
*section
,
4797 void *file ATTRIBUTE_UNUSED
,
4800 DWARF2_Internal_PubNames names
;
4801 unsigned char *start
= section
->start
;
4802 unsigned char *end
= start
+ section
->size
;
4804 /* It does not matter if this load fails,
4805 we test for that later on. */
4806 load_debug_info (file
);
4808 introduce (section
, FALSE
);
4812 unsigned char *data
;
4813 unsigned long sec_off
;
4814 unsigned int offset_size
, initial_length_size
;
4816 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
4817 if (names
.pn_length
== 0xffffffff)
4819 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
4821 initial_length_size
= 12;
4826 initial_length_size
= 4;
4829 sec_off
= start
- section
->start
;
4830 if (sec_off
+ names
.pn_length
< sec_off
4831 || sec_off
+ names
.pn_length
> section
->size
)
4833 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
4835 sec_off
- initial_length_size
,
4836 dwarf_vmatoa ("x", names
.pn_length
));
4841 start
+= names
.pn_length
;
4843 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
4844 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
4846 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4847 && num_debug_info_entries
> 0
4848 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
4849 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4850 (unsigned long) names
.pn_offset
, section
->name
);
4852 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
4854 printf (_(" Length: %ld\n"),
4855 (long) names
.pn_length
);
4856 printf (_(" Version: %d\n"),
4858 printf (_(" Offset into .debug_info section: 0x%lx\n"),
4859 (unsigned long) names
.pn_offset
);
4860 printf (_(" Size of area in .debug_info section: %ld\n"),
4861 (long) names
.pn_size
);
4863 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
4865 static int warned
= 0;
4869 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
4877 printf (_("\n Offset Kind Name\n"));
4879 printf (_("\n Offset\tName\n"));
4883 bfd_size_type maxprint
;
4886 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
4891 data
+= offset_size
;
4894 maxprint
= (end
- data
) - 1;
4898 unsigned int kind_data
;
4899 gdb_index_symbol_kind kind
;
4900 const char *kind_name
;
4903 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
4906 /* GCC computes the kind as the upper byte in the CU index
4907 word, and then right shifts it by the CU index size.
4908 Left shift KIND to where the gdb-index.h accessor macros
4910 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
4911 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
4912 kind_name
= get_gdb_index_symbol_kind_name (kind
);
4913 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
4914 printf (" %-6lx %s,%-10s %.*s\n",
4915 (unsigned long) offset
, is_static
? _("s") : _("g"),
4916 kind_name
, (int) maxprint
, data
);
4919 printf (" %-6lx\t%.*s\n",
4920 (unsigned long) offset
, (int) maxprint
, data
);
4922 data
+= strnlen ((char *) data
, maxprint
) + 1;
4933 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
4935 return display_debug_pubnames_worker (section
, file
, 0);
4939 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
4941 return display_debug_pubnames_worker (section
, file
, 1);
4945 display_debug_macinfo (struct dwarf_section
*section
,
4946 void *file ATTRIBUTE_UNUSED
)
4948 unsigned char *start
= section
->start
;
4949 unsigned char *end
= start
+ section
->size
;
4950 unsigned char *curr
= start
;
4951 unsigned int bytes_read
;
4952 enum dwarf_macinfo_record_type op
;
4954 introduce (section
, FALSE
);
4958 unsigned int lineno
;
4959 const unsigned char *string
;
4961 op
= (enum dwarf_macinfo_record_type
) *curr
;
4966 case DW_MACINFO_start_file
:
4968 unsigned int filenum
;
4970 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4972 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
4975 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
4980 case DW_MACINFO_end_file
:
4981 printf (_(" DW_MACINFO_end_file\n"));
4984 case DW_MACINFO_define
:
4985 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4988 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4989 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
4993 case DW_MACINFO_undef
:
4994 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4997 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4998 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5002 case DW_MACINFO_vendor_ext
:
5004 unsigned int constant
;
5006 constant
= read_uleb128 (curr
, & bytes_read
, end
);
5009 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5010 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5020 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5021 filename and dirname corresponding to file name table entry with index
5022 FILEIDX. Return NULL on failure. */
5024 static unsigned char *
5025 get_line_filename_and_dirname (dwarf_vma line_offset
,
5027 unsigned char **dir_name
)
5029 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5030 unsigned char *hdrptr
, *dirtable
, *file_name
;
5031 unsigned int offset_size
, initial_length_size
;
5032 unsigned int version
, opcode_base
, bytes_read
;
5033 dwarf_vma length
, diridx
;
5034 const unsigned char * end
;
5037 if (section
->start
== NULL
5038 || line_offset
>= section
->size
5042 hdrptr
= section
->start
+ line_offset
;
5043 end
= section
->start
+ section
->size
;
5045 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5046 if (length
== 0xffffffff)
5048 /* This section is 64-bit DWARF 3. */
5049 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5051 initial_length_size
= 12;
5056 initial_length_size
= 4;
5058 if (length
+ initial_length_size
< length
5059 || length
+ initial_length_size
> section
->size
)
5062 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5063 if (version
!= 2 && version
!= 3 && version
!= 4)
5065 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5067 hdrptr
++; /* Skip max_ops_per_insn. */
5068 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5070 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5071 if (opcode_base
== 0)
5074 hdrptr
+= opcode_base
- 1;
5079 /* Skip over dirname table. */
5080 while (*hdrptr
!= '\0')
5082 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5086 hdrptr
++; /* Skip the NUL at the end of the table. */
5088 /* Now skip over preceding filename table entries. */
5089 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5091 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5092 read_uleb128 (hdrptr
, &bytes_read
, end
);
5093 hdrptr
+= bytes_read
;
5094 read_uleb128 (hdrptr
, &bytes_read
, end
);
5095 hdrptr
+= bytes_read
;
5096 read_uleb128 (hdrptr
, &bytes_read
, end
);
5097 hdrptr
+= bytes_read
;
5099 if (hdrptr
>= end
|| *hdrptr
== '\0')
5103 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5106 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
5109 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5110 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5111 if (dirtable
>= end
|| *dirtable
== '\0')
5113 *dir_name
= dirtable
;
5118 display_debug_macro (struct dwarf_section
*section
,
5121 unsigned char *start
= section
->start
;
5122 unsigned char *end
= start
+ section
->size
;
5123 unsigned char *curr
= start
;
5124 unsigned char *extended_op_buf
[256];
5125 unsigned int bytes_read
;
5127 load_debug_section_with_follow (str
, file
);
5128 load_debug_section_with_follow (line
, file
);
5130 introduce (section
, FALSE
);
5134 unsigned int lineno
, version
, flags
;
5135 unsigned int offset_size
= 4;
5136 const unsigned char *string
;
5137 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5138 unsigned char **extended_ops
= NULL
;
5140 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5141 if (version
!= 4 && version
!= 5)
5143 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5148 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5151 printf (_(" Offset: 0x%lx\n"),
5152 (unsigned long) sec_offset
);
5153 printf (_(" Version: %d\n"), version
);
5154 printf (_(" Offset size: %d\n"), offset_size
);
5157 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5158 printf (_(" Offset into .debug_line: 0x%lx\n"),
5159 (unsigned long) line_offset
);
5163 unsigned int i
, count
, op
;
5166 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5168 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5169 extended_ops
= extended_op_buf
;
5172 printf (_(" Extension opcode arguments:\n"));
5173 for (i
= 0; i
< count
; i
++)
5175 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5176 extended_ops
[op
] = curr
;
5177 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
5180 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5183 printf (_(" DW_MACRO_%02x arguments: "), op
);
5184 for (n
= 0; n
< nargs
; n
++)
5188 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5189 printf ("%s%s", get_FORM_name (form
),
5190 n
== nargs
- 1 ? "\n" : ", ");
5200 case DW_FORM_block1
:
5201 case DW_FORM_block2
:
5202 case DW_FORM_block4
:
5204 case DW_FORM_string
:
5206 case DW_FORM_sec_offset
:
5209 error (_("Invalid extension opcode form %s\n"),
5210 get_FORM_name (form
));
5226 error (_(".debug_macro section not zero terminated\n"));
5230 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5236 case DW_MACRO_start_file
:
5238 unsigned int filenum
;
5239 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5241 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5243 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
5246 if ((flags
& 2) == 0)
5247 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5250 = get_line_filename_and_dirname (line_offset
, filenum
,
5252 if (file_name
== NULL
)
5253 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5256 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5258 dir_name
!= NULL
? (const char *) dir_name
: "",
5259 dir_name
!= NULL
? "/" : "", file_name
);
5263 case DW_MACRO_end_file
:
5264 printf (_(" DW_MACRO_end_file\n"));
5267 case DW_MACRO_define
:
5268 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5271 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5272 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5276 case DW_MACRO_undef
:
5277 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5280 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5281 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5285 case DW_MACRO_define_strp
:
5286 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5288 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5289 string
= fetch_indirect_string (offset
);
5290 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5294 case DW_MACRO_undef_strp
:
5295 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5297 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5298 string
= fetch_indirect_string (offset
);
5299 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5303 case DW_MACRO_import
:
5304 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5305 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5306 (unsigned long) offset
);
5309 case DW_MACRO_define_sup
:
5310 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5312 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5313 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5314 lineno
, (unsigned long) offset
);
5317 case DW_MACRO_undef_sup
:
5318 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5320 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5321 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5322 lineno
, (unsigned long) offset
);
5325 case DW_MACRO_import_sup
:
5326 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5327 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5328 (unsigned long) offset
);
5332 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5334 error (_(" Unknown macro opcode %02x seen\n"), op
);
5339 /* Skip over unhandled opcodes. */
5341 unsigned char *desc
= extended_ops
[op
];
5342 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
5346 printf (_(" DW_MACRO_%02x\n"), op
);
5349 printf (_(" DW_MACRO_%02x -"), op
);
5350 for (n
= 0; n
< nargs
; n
++)
5354 /* DW_FORM_implicit_const is not expected here. */
5355 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5357 = read_and_display_attr_value (0, val
, 0,
5358 curr
, end
, 0, 0, offset_size
,
5359 version
, NULL
, 0, NULL
,
5377 display_debug_abbrev (struct dwarf_section
*section
,
5378 void *file ATTRIBUTE_UNUSED
)
5380 abbrev_entry
*entry
;
5381 unsigned char *start
= section
->start
;
5382 unsigned char *end
= start
+ section
->size
;
5384 introduce (section
, FALSE
);
5388 unsigned char *last
;
5393 start
= process_abbrev_section (start
, end
);
5395 if (first_abbrev
== NULL
)
5398 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5400 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5404 printf (" %ld %s [%s]\n",
5406 get_TAG_name (entry
->tag
),
5407 entry
->children
? _("has children") : _("no children"));
5409 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5411 printf (" %-18s %s",
5412 get_AT_name (attr
->attribute
),
5413 get_FORM_name (attr
->form
));
5414 if (attr
->form
== DW_FORM_implicit_const
)
5415 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5427 /* Return true when ADDR is the maximum address, when addresses are
5428 POINTER_SIZE bytes long. */
5431 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5433 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5434 return ((addr
& mask
) == mask
);
5437 /* Display a view pair list starting at *VSTART_PTR and ending at
5438 VLISTEND within SECTION. */
5441 display_view_pair_list (struct dwarf_section
*section
,
5442 unsigned char **vstart_ptr
,
5443 unsigned int debug_info_entry
,
5444 unsigned char *vlistend
)
5446 unsigned char *vstart
= *vstart_ptr
;
5447 unsigned char *section_end
= section
->start
+ section
->size
;
5448 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5450 if (vlistend
< section_end
)
5451 section_end
= vlistend
;
5455 while (vstart
< section_end
)
5457 dwarf_vma off
= vstart
- section
->start
;
5458 dwarf_vma vbegin
, vend
;
5460 unsigned int bytes_read
;
5461 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5462 vstart
+= bytes_read
;
5463 if (vstart
== section_end
)
5465 vstart
-= bytes_read
;
5469 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5470 vstart
+= bytes_read
;
5472 printf (" %8.8lx ", (unsigned long) off
);
5474 print_dwarf_view (vbegin
, pointer_size
, 1);
5475 print_dwarf_view (vend
, pointer_size
, 1);
5476 printf (_("location view pair\n"));
5480 *vstart_ptr
= vstart
;
5483 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5486 display_loc_list (struct dwarf_section
*section
,
5487 unsigned char **start_ptr
,
5488 unsigned int debug_info_entry
,
5490 dwarf_vma base_address
,
5491 unsigned char **vstart_ptr
,
5494 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5495 unsigned char *section_end
= section
->start
+ section
->size
;
5496 unsigned long cu_offset
;
5497 unsigned int pointer_size
;
5498 unsigned int offset_size
;
5503 unsigned short length
;
5504 int need_frame_base
;
5506 if (debug_info_entry
>= num_debug_info_entries
)
5508 warn (_("No debug information available for loc lists of entry: %u\n"),
5513 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5514 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5515 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5516 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5518 if (pointer_size
< 2 || pointer_size
> 8)
5520 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5521 pointer_size
, debug_info_entry
);
5527 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5528 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5530 if (start
+ 2 * pointer_size
> section_end
)
5532 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5533 (unsigned long) offset
);
5537 printf (" %8.8lx ", (unsigned long) off
);
5539 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5540 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5542 if (begin
== 0 && end
== 0)
5544 /* PR 18374: In a object file we can have a location list that
5545 starts with a begin and end of 0 because there are relocations
5546 that need to be applied to the addresses. Actually applying
5547 the relocations now does not help as they will probably resolve
5548 to 0, since the object file has not been fully linked. Real
5549 end of list markers will not have any relocations against them. */
5550 if (! reloc_at (section
, off
)
5551 && ! reloc_at (section
, off
+ pointer_size
))
5553 printf (_("<End of list>\n"));
5558 /* Check base address specifiers. */
5559 if (is_max_address (begin
, pointer_size
)
5560 && !is_max_address (end
, pointer_size
))
5563 print_dwarf_vma (begin
, pointer_size
);
5564 print_dwarf_vma (end
, pointer_size
);
5565 printf (_("(base address)\n"));
5571 unsigned int bytes_read
;
5573 off
= offset
+ (vstart
- *start_ptr
);
5575 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5576 vstart
+= bytes_read
;
5577 print_dwarf_view (vbegin
, pointer_size
, 1);
5579 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5580 vstart
+= bytes_read
;
5581 print_dwarf_view (vend
, pointer_size
, 1);
5583 printf (_("views at %8.8lx for:\n %*s "),
5584 (unsigned long) off
, 8, "");
5587 if (start
+ 2 > section_end
)
5589 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5590 (unsigned long) offset
);
5594 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5596 if (start
+ length
> section_end
)
5598 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5599 (unsigned long) offset
);
5603 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5604 print_dwarf_vma (end
+ base_address
, pointer_size
);
5607 need_frame_base
= decode_location_expression (start
,
5612 cu_offset
, section
);
5615 if (need_frame_base
&& !has_frame_base
)
5616 printf (_(" [without DW_AT_frame_base]"));
5618 if (begin
== end
&& vbegin
== vend
)
5619 fputs (_(" (start == end)"), stdout
);
5620 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5621 fputs (_(" (start > end)"), stdout
);
5629 *vstart_ptr
= vstart
;
5632 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5635 display_loclists_list (struct dwarf_section
*section
,
5636 unsigned char **start_ptr
,
5637 unsigned int debug_info_entry
,
5639 dwarf_vma base_address
,
5640 unsigned char **vstart_ptr
,
5643 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5644 unsigned char *section_end
= section
->start
+ section
->size
;
5645 unsigned long cu_offset
;
5646 unsigned int pointer_size
;
5647 unsigned int offset_size
;
5649 unsigned int bytes_read
;
5651 /* Initialize it due to a false compiler warning. */
5652 dwarf_vma begin
= -1, vbegin
= -1;
5653 dwarf_vma end
= -1, vend
= -1;
5655 int need_frame_base
;
5657 if (debug_info_entry
>= num_debug_info_entries
)
5659 warn (_("No debug information available for "
5660 "loclists lists of entry: %u\n"),
5665 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5666 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5667 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5668 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5670 if (pointer_size
< 2 || pointer_size
> 8)
5672 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5673 pointer_size
, debug_info_entry
);
5679 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5680 enum dwarf_location_list_entry_type llet
;
5682 if (start
+ 1 > section_end
)
5684 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5685 (unsigned long) offset
);
5689 printf (" %8.8lx ", (unsigned long) off
);
5691 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5693 if (vstart
&& llet
== DW_LLE_offset_pair
)
5695 off
= offset
+ (vstart
- *start_ptr
);
5697 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5698 vstart
+= bytes_read
;
5699 print_dwarf_view (vbegin
, pointer_size
, 1);
5701 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5702 vstart
+= bytes_read
;
5703 print_dwarf_view (vend
, pointer_size
, 1);
5705 printf (_("views at %8.8lx for:\n %*s "),
5706 (unsigned long) off
, 8, "");
5711 case DW_LLE_end_of_list
:
5712 printf (_("<End of list>\n"));
5714 case DW_LLE_offset_pair
:
5715 begin
= read_uleb128 (start
, &bytes_read
, section_end
);
5716 start
+= bytes_read
;
5717 end
= read_uleb128 (start
, &bytes_read
, section_end
);
5718 start
+= bytes_read
;
5720 case DW_LLE_base_address
:
5721 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
5723 print_dwarf_vma (base_address
, pointer_size
);
5724 printf (_("(base address)\n"));
5726 #ifdef DW_LLE_view_pair
5727 case DW_LLE_view_pair
:
5729 printf (_("View pair entry in loclist with locviews attribute\n"));
5730 vbegin
= read_uleb128 (start
, &bytes_read
, section_end
);
5731 start
+= bytes_read
;
5732 print_dwarf_view (vbegin
, pointer_size
, 1);
5734 vend
= read_uleb128 (start
, &bytes_read
, section_end
);
5735 start
+= bytes_read
;
5736 print_dwarf_view (vend
, pointer_size
, 1);
5738 printf (_("views for:\n"));
5742 error (_("Invalid location list entry type %d\n"), llet
);
5745 if (llet
== DW_LLE_end_of_list
)
5747 if (llet
!= DW_LLE_offset_pair
)
5750 if (start
+ 2 > section_end
)
5752 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5753 (unsigned long) offset
);
5757 length
= read_uleb128 (start
, &bytes_read
, section_end
);
5758 start
+= bytes_read
;
5760 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5761 print_dwarf_vma (end
+ base_address
, pointer_size
);
5764 need_frame_base
= decode_location_expression (start
,
5769 cu_offset
, section
);
5772 if (need_frame_base
&& !has_frame_base
)
5773 printf (_(" [without DW_AT_frame_base]"));
5775 if (begin
== end
&& vbegin
== vend
)
5776 fputs (_(" (start == end)"), stdout
);
5777 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5778 fputs (_(" (start > end)"), stdout
);
5786 if (vbegin
!= vm1
|| vend
!= vm1
)
5787 printf (_("Trailing view pair not used in a range"));
5790 *vstart_ptr
= vstart
;
5793 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
5794 right-adjusted in a field of length LEN, and followed by a space. */
5797 print_addr_index (unsigned int idx
, unsigned int len
)
5799 static char buf
[15];
5800 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
5801 printf ("%*s ", len
, buf
);
5804 /* Display a location list from a .dwo section. It uses address indexes rather
5805 than embedded addresses. This code closely follows display_loc_list, but the
5806 two are sufficiently different that combining things is very ugly. */
5809 display_loc_list_dwo (struct dwarf_section
*section
,
5810 unsigned char **start_ptr
,
5811 unsigned int debug_info_entry
,
5813 unsigned char **vstart_ptr
,
5816 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5817 unsigned char *section_end
= section
->start
+ section
->size
;
5818 unsigned long cu_offset
;
5819 unsigned int pointer_size
;
5820 unsigned int offset_size
;
5823 unsigned short length
;
5824 int need_frame_base
;
5826 unsigned int bytes_read
;
5828 if (debug_info_entry
>= num_debug_info_entries
)
5830 warn (_("No debug information for loc lists of entry: %u\n"),
5835 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5836 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5837 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5838 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5840 if (pointer_size
< 2 || pointer_size
> 8)
5842 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5843 pointer_size
, debug_info_entry
);
5849 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
5851 if (start
>= section_end
)
5853 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5854 (unsigned long) offset
);
5858 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
5871 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
5873 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5874 vstart
+= bytes_read
;
5875 print_dwarf_view (view
, 8, 1);
5877 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5878 vstart
+= bytes_read
;
5879 print_dwarf_view (view
, 8, 1);
5881 printf (_("views at %8.8lx for:\n %*s "),
5882 (unsigned long) off
, 8, "");
5890 case 0: /* A terminating entry. */
5892 *vstart_ptr
= vstart
;
5893 printf (_("<End of list>\n"));
5895 case 1: /* A base-address entry. */
5896 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5897 start
+= bytes_read
;
5898 print_addr_index (idx
, 8);
5899 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
5900 printf (_("(base address selection entry)\n"));
5902 case 2: /* A start/end entry. */
5903 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5904 start
+= bytes_read
;
5905 print_addr_index (idx
, 8);
5906 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5907 start
+= bytes_read
;
5908 print_addr_index (idx
, 8);
5910 case 3: /* A start/length entry. */
5911 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5912 start
+= bytes_read
;
5913 print_addr_index (idx
, 8);
5914 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5915 printf ("%08x ", idx
);
5917 case 4: /* An offset pair entry. */
5918 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5919 printf ("%08x ", idx
);
5920 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5921 printf ("%08x ", idx
);
5924 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
5926 *vstart_ptr
= vstart
;
5930 if (start
+ 2 > section_end
)
5932 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5933 (unsigned long) offset
);
5937 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5938 if (start
+ length
> section_end
)
5940 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5941 (unsigned long) offset
);
5946 need_frame_base
= decode_location_expression (start
,
5951 cu_offset
, section
);
5954 if (need_frame_base
&& !has_frame_base
)
5955 printf (_(" [without DW_AT_frame_base]"));
5963 *vstart_ptr
= vstart
;
5966 /* Sort array of indexes in ascending order of loc_offsets[idx] and
5969 static dwarf_vma
*loc_offsets
, *loc_views
;
5972 loc_offsets_compar (const void *ap
, const void *bp
)
5974 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
5975 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
5977 int ret
= (a
> b
) - (b
> a
);
5981 a
= loc_views
[*(const unsigned int *) ap
];
5982 b
= loc_views
[*(const unsigned int *) bp
];
5984 ret
= (a
> b
) - (b
> a
);
5990 display_debug_loc (struct dwarf_section
*section
, void *file
)
5992 unsigned char *start
= section
->start
, *vstart
= NULL
;
5993 unsigned long bytes
;
5994 unsigned char *section_begin
= start
;
5995 unsigned int num_loc_list
= 0;
5996 unsigned long last_offset
= 0;
5997 unsigned long last_view
= 0;
5998 unsigned int first
= 0;
6001 int seen_first_offset
= 0;
6002 int locs_sorted
= 1;
6003 unsigned char *next
= start
, *vnext
= vstart
;
6004 unsigned int *array
= NULL
;
6005 const char *suffix
= strrchr (section
->name
, '.');
6007 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6008 dwarf_vma expected_start
= 0;
6010 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6013 bytes
= section
->size
;
6017 printf (_("\nThe %s section is empty.\n"), section
->name
);
6023 unsigned char *hdrptr
= section_begin
;
6024 dwarf_vma ll_length
;
6025 unsigned short ll_version
;
6026 unsigned char *end
= section_begin
+ section
->size
;
6027 unsigned char address_size
, segment_selector_size
;
6028 uint32_t offset_entry_count
;
6030 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6031 if (ll_length
== 0xffffffff)
6032 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6034 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6035 if (ll_version
!= 5)
6037 warn (_("The %s section contains corrupt or "
6038 "unsupported version number: %d.\n"),
6039 section
->name
, ll_version
);
6043 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6045 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6046 if (segment_selector_size
!= 0)
6048 warn (_("The %s section contains "
6049 "unsupported segment selector size: %d.\n"),
6050 section
->name
, segment_selector_size
);
6054 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6055 if (offset_entry_count
!= 0)
6057 warn (_("The %s section contains "
6058 "unsupported offset entry count: %d.\n"),
6059 section
->name
, offset_entry_count
);
6063 expected_start
= hdrptr
- section_begin
;
6066 if (load_debug_info (file
) == 0)
6068 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6073 /* Check the order of location list in .debug_info section. If
6074 offsets of location lists are in the ascending order, we can
6075 use `debug_information' directly. */
6076 for (i
= 0; i
< num_debug_info_entries
; i
++)
6080 num
= debug_information
[i
].num_loc_offsets
;
6081 if (num
> num_loc_list
)
6084 /* Check if we can use `debug_information' directly. */
6085 if (locs_sorted
&& num
!= 0)
6087 if (!seen_first_offset
)
6089 /* This is the first location list. */
6090 last_offset
= debug_information
[i
].loc_offsets
[0];
6091 last_view
= debug_information
[i
].loc_views
[0];
6093 seen_first_offset
= 1;
6099 for (; j
< num
; j
++)
6102 debug_information
[i
].loc_offsets
[j
]
6103 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6104 && last_view
> debug_information
[i
].loc_views
[j
]))
6109 last_offset
= debug_information
[i
].loc_offsets
[j
];
6110 last_view
= debug_information
[i
].loc_views
[j
];
6115 if (!seen_first_offset
)
6116 error (_("No location lists in .debug_info section!\n"));
6118 if (debug_information
[first
].num_loc_offsets
> 0
6119 && debug_information
[first
].loc_offsets
[0] != expected_start
6120 && debug_information
[first
].loc_views
[0] != expected_start
)
6121 warn (_("Location lists in %s section start at 0x%s\n"),
6123 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6126 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6128 introduce (section
, FALSE
);
6130 if (reloc_at (section
, 0))
6131 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6133 printf (_(" Offset Begin End Expression\n"));
6135 seen_first_offset
= 0;
6136 for (i
= first
; i
< num_debug_info_entries
; i
++)
6138 dwarf_vma offset
, voffset
;
6139 dwarf_vma base_address
;
6145 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6147 loc_offsets
= debug_information
[i
].loc_offsets
;
6148 loc_views
= debug_information
[i
].loc_views
;
6149 qsort (array
, debug_information
[i
].num_loc_offsets
,
6150 sizeof (*array
), loc_offsets_compar
);
6153 int adjacent_view_loclists
= 1;
6154 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6156 j
= locs_sorted
? k
: array
[k
];
6158 && (debug_information
[i
].loc_offsets
[locs_sorted
6159 ? k
- 1 : array
[k
- 1]]
6160 == debug_information
[i
].loc_offsets
[j
])
6161 && (debug_information
[i
].loc_views
[locs_sorted
6162 ? k
- 1 : array
[k
- 1]]
6163 == debug_information
[i
].loc_views
[j
]))
6165 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6166 offset
= debug_information
[i
].loc_offsets
[j
];
6167 next
= section_begin
+ offset
;
6168 voffset
= debug_information
[i
].loc_views
[j
];
6170 vnext
= section_begin
+ voffset
;
6173 base_address
= debug_information
[i
].base_address
;
6175 if (vnext
&& vnext
< next
)
6178 display_view_pair_list (section
, &vstart
, i
, next
);
6183 if (!seen_first_offset
|| !adjacent_view_loclists
)
6184 seen_first_offset
= 1;
6188 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6189 (unsigned long) (start
- section_begin
),
6190 (unsigned long) offset
);
6191 else if (start
> next
)
6192 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6193 (unsigned long) (start
- section_begin
),
6194 (unsigned long) offset
);
6199 if (offset
>= bytes
)
6201 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6202 (unsigned long) offset
);
6206 if (vnext
&& voffset
>= bytes
)
6208 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6209 (unsigned long) voffset
);
6216 display_loc_list_dwo (section
, &start
, i
, offset
,
6217 &vstart
, has_frame_base
);
6219 display_loc_list (section
, &start
, i
, offset
, base_address
,
6220 &vstart
, has_frame_base
);
6225 warn (_("DWO is not yet supported.\n"));
6227 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6228 &vstart
, has_frame_base
);
6231 /* FIXME: this arrangement is quite simplistic. Nothing
6232 requires locview lists to be adjacent to corresponding
6233 loclists, and a single loclist could be augmented by
6234 different locview lists, and vice-versa, unlikely as it
6235 is that it would make sense to do so. Hopefully we'll
6236 have view pair support built into loclists before we ever
6237 need to address all these possibilities. */
6238 if (adjacent_view_loclists
&& vnext
6239 && vnext
!= start
&& vstart
!= next
)
6241 adjacent_view_loclists
= 0;
6242 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6245 if (vnext
&& vnext
== start
)
6246 display_view_pair_list (section
, &start
, i
, vstart
);
6250 if (start
< section
->start
+ section
->size
)
6251 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6252 "There are %ld unused bytes at the end of section %s\n",
6253 (long) (section
->start
+ section
->size
- start
)),
6254 (long) (section
->start
+ section
->size
- start
), section
->name
);
6261 display_debug_str (struct dwarf_section
*section
,
6262 void *file ATTRIBUTE_UNUSED
)
6264 unsigned char *start
= section
->start
;
6265 unsigned long bytes
= section
->size
;
6266 dwarf_vma addr
= section
->address
;
6270 printf (_("\nThe %s section is empty.\n"), section
->name
);
6274 introduce (section
, FALSE
);
6282 lbytes
= (bytes
> 16 ? 16 : bytes
);
6284 printf (" 0x%8.8lx ", (unsigned long) addr
);
6286 for (j
= 0; j
< 16; j
++)
6289 printf ("%2.2x", start
[j
]);
6297 for (j
= 0; j
< lbytes
; j
++)
6300 if (k
>= ' ' && k
< 0x80)
6319 display_debug_info (struct dwarf_section
*section
, void *file
)
6321 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6325 display_debug_types (struct dwarf_section
*section
, void *file
)
6327 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6331 display_trace_info (struct dwarf_section
*section
, void *file
)
6333 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6337 display_debug_aranges (struct dwarf_section
*section
,
6338 void *file ATTRIBUTE_UNUSED
)
6340 unsigned char *start
= section
->start
;
6341 unsigned char *end
= start
+ section
->size
;
6343 introduce (section
, FALSE
);
6345 /* It does not matter if this load fails,
6346 we test for that later on. */
6347 load_debug_info (file
);
6351 unsigned char *hdrptr
;
6352 DWARF2_Internal_ARange arange
;
6353 unsigned char *addr_ranges
;
6356 unsigned long sec_off
;
6357 unsigned char address_size
;
6359 unsigned int offset_size
;
6360 unsigned int initial_length_size
;
6364 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6365 if (arange
.ar_length
== 0xffffffff)
6367 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6369 initial_length_size
= 12;
6374 initial_length_size
= 4;
6377 sec_off
= hdrptr
- section
->start
;
6378 if (sec_off
+ arange
.ar_length
< sec_off
6379 || sec_off
+ arange
.ar_length
> section
->size
)
6381 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6383 sec_off
- initial_length_size
,
6384 dwarf_vmatoa ("x", arange
.ar_length
));
6388 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6389 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6391 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6392 && num_debug_info_entries
> 0
6393 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6394 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6395 (unsigned long) arange
.ar_info_offset
, section
->name
);
6397 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6398 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6400 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6402 /* PR 19872: A version number of 0 probably means that there is
6403 padding at the end of the .debug_aranges section. Gold puts
6404 it there when performing an incremental link, for example.
6405 So do not generate a warning in this case. */
6406 if (arange
.ar_version
)
6407 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6411 printf (_(" Length: %ld\n"),
6412 (long) arange
.ar_length
);
6413 printf (_(" Version: %d\n"), arange
.ar_version
);
6414 printf (_(" Offset into .debug_info: 0x%lx\n"),
6415 (unsigned long) arange
.ar_info_offset
);
6416 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6417 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6419 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6421 /* PR 17512: file: 001-108546-0.001:0.1. */
6422 if (address_size
== 0 || address_size
> 8)
6424 error (_("Invalid address size in %s section!\n"),
6429 /* The DWARF spec does not require that the address size be a power
6430 of two, but we do. This will have to change if we ever encounter
6431 an uneven architecture. */
6432 if ((address_size
& (address_size
- 1)) != 0)
6434 warn (_("Pointer size + Segment size is not a power of two.\n"));
6438 if (address_size
> 4)
6439 printf (_("\n Address Length\n"));
6441 printf (_("\n Address Length\n"));
6443 addr_ranges
= hdrptr
;
6445 /* Must pad to an alignment boundary that is twice the address size. */
6446 excess
= (hdrptr
- start
) % (2 * address_size
);
6448 addr_ranges
+= (2 * address_size
) - excess
;
6450 start
+= arange
.ar_length
+ initial_length_size
;
6452 while (addr_ranges
+ 2 * address_size
<= start
)
6454 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6455 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6458 print_dwarf_vma (address
, address_size
);
6459 print_dwarf_vma (length
, address_size
);
6469 /* Comparison function for qsort. */
6471 comp_addr_base (const void * v0
, const void * v1
)
6473 debug_info
* info0
= (debug_info
*) v0
;
6474 debug_info
* info1
= (debug_info
*) v1
;
6475 return info0
->addr_base
- info1
->addr_base
;
6478 /* Display the debug_addr section. */
6480 display_debug_addr (struct dwarf_section
*section
,
6483 debug_info
**debug_addr_info
;
6484 unsigned char *entry
;
6489 if (section
->size
== 0)
6491 printf (_("\nThe %s section is empty.\n"), section
->name
);
6495 if (load_debug_info (file
) == 0)
6497 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6502 introduce (section
, FALSE
);
6504 /* PR 17531: file: cf38d01b.
6505 We use xcalloc because a corrupt file may not have initialised all of the
6506 fields in the debug_info structure, which means that the sort below might
6507 try to move uninitialised data. */
6508 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6509 sizeof (debug_info
*));
6512 for (i
= 0; i
< num_debug_info_entries
; i
++)
6513 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6515 /* PR 17531: file: cf38d01b. */
6516 if (debug_information
[i
].addr_base
>= section
->size
)
6517 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6518 (unsigned long) debug_information
[i
].addr_base
, i
);
6520 debug_addr_info
[count
++] = debug_information
+ i
;
6523 /* Add a sentinel to make iteration convenient. */
6524 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6525 debug_addr_info
[count
]->addr_base
= section
->size
;
6526 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6528 for (i
= 0; i
< count
; i
++)
6531 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6533 printf (_(" For compilation unit at offset 0x%s:\n"),
6534 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6536 printf (_("\tIndex\tAddress\n"));
6537 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6538 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6542 dwarf_vma base
= byte_get (entry
, address_size
);
6543 printf (_("\t%d:\t"), idx
);
6544 print_dwarf_vma (base
, address_size
);
6546 entry
+= address_size
;
6552 free (debug_addr_info
);
6556 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6558 display_debug_str_offsets (struct dwarf_section
*section
,
6559 void *file ATTRIBUTE_UNUSED
)
6561 if (section
->size
== 0)
6563 printf (_("\nThe %s section is empty.\n"), section
->name
);
6566 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6567 what the offset size is for this section. */
6571 /* Each debug_information[x].range_lists[y] gets this representation for
6572 sorting purposes. */
6576 /* The debug_information[x].range_lists[y] value. */
6577 dwarf_vma ranges_offset
;
6579 /* Original debug_information to find parameters of the data. */
6580 debug_info
*debug_info_p
;
6583 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6586 range_entry_compar (const void *ap
, const void *bp
)
6588 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6589 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6590 const dwarf_vma a
= a_re
->ranges_offset
;
6591 const dwarf_vma b
= b_re
->ranges_offset
;
6593 return (a
> b
) - (b
> a
);
6597 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6598 unsigned int pointer_size
, unsigned long offset
,
6599 unsigned long base_address
)
6601 while (start
< finish
)
6606 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6607 if (start
>= finish
)
6609 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6612 printf (" %8.8lx ", offset
);
6614 if (begin
== 0 && end
== 0)
6616 printf (_("<End of list>\n"));
6620 /* Check base address specifiers. */
6621 if (is_max_address (begin
, pointer_size
)
6622 && !is_max_address (end
, pointer_size
))
6625 print_dwarf_vma (begin
, pointer_size
);
6626 print_dwarf_vma (end
, pointer_size
);
6627 printf ("(base address)\n");
6631 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6632 print_dwarf_vma (end
+ base_address
, pointer_size
);
6635 fputs (_("(start == end)"), stdout
);
6636 else if (begin
> end
)
6637 fputs (_("(start > end)"), stdout
);
6644 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
6645 unsigned int pointer_size
, unsigned long offset
,
6646 unsigned long base_address
)
6648 unsigned char *next
= start
;
6652 unsigned long off
= offset
+ (start
- next
);
6653 enum dwarf_range_list_entry rlet
;
6654 /* Initialize it due to a false compiler warning. */
6655 dwarf_vma begin
= -1, length
, end
= -1;
6656 unsigned int bytes_read
;
6658 if (start
+ 1 > finish
)
6660 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6665 printf (" %8.8lx ", off
);
6667 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
6671 case DW_RLE_end_of_list
:
6672 printf (_("<End of list>\n"));
6674 case DW_RLE_base_address
:
6675 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
6676 print_dwarf_vma (base_address
, pointer_size
);
6677 printf (_("(base address)\n"));
6679 case DW_RLE_start_length
:
6680 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6681 length
= read_uleb128 (start
, &bytes_read
, finish
);
6682 start
+= bytes_read
;
6683 end
= begin
+ length
;
6685 case DW_RLE_offset_pair
:
6686 begin
= read_uleb128 (start
, &bytes_read
, finish
);
6687 start
+= bytes_read
;
6688 end
= read_uleb128 (start
, &bytes_read
, finish
);
6689 start
+= bytes_read
;
6691 case DW_RLE_start_end
:
6692 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6693 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6696 error (_("Invalid range list entry type %d\n"), rlet
);
6697 rlet
= DW_RLE_end_of_list
;
6700 if (rlet
== DW_RLE_end_of_list
)
6702 if (rlet
== DW_RLE_base_address
)
6705 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6706 print_dwarf_vma (end
+ base_address
, pointer_size
);
6709 fputs (_("(start == end)"), stdout
);
6710 else if (begin
> end
)
6711 fputs (_("(start > end)"), stdout
);
6718 display_debug_ranges (struct dwarf_section
*section
,
6719 void *file ATTRIBUTE_UNUSED
)
6721 unsigned char *start
= section
->start
;
6722 unsigned char *last_start
= start
;
6723 unsigned long bytes
= section
->size
;
6724 unsigned char *section_begin
= start
;
6725 unsigned char *finish
= start
+ bytes
;
6726 unsigned int num_range_list
, i
;
6727 struct range_entry
*range_entries
, *range_entry_fill
;
6728 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
6729 /* Initialize it due to a false compiler warning. */
6730 unsigned char address_size
= 0;
6734 printf (_("\nThe %s section is empty.\n"), section
->name
);
6740 dwarf_vma initial_length
;
6741 unsigned int initial_length_size
;
6742 unsigned char segment_selector_size
;
6743 unsigned int offset_size
, offset_entry_count
;
6744 unsigned short version
;
6746 /* Get and check the length of the block. */
6747 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
6749 if (initial_length
== 0xffffffff)
6751 /* This section is 64-bit DWARF 3. */
6752 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
6754 initial_length_size
= 12;
6759 initial_length_size
= 4;
6762 if (initial_length
+ initial_length_size
> section
->size
)
6764 /* If the length field has a relocation against it, then we should
6765 not complain if it is inaccurate (and probably negative).
6766 It is copied from .debug_line handling code. */
6767 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
6769 initial_length
= (finish
- start
) - initial_length_size
;
6773 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6774 (long) initial_length
);
6779 /* Get and check the version number. */
6780 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
6784 warn (_("Only DWARF version 5 debug_rnglists info "
6785 "is currently supported.\n"));
6789 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
6791 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
6792 if (segment_selector_size
!= 0)
6794 warn (_("The %s section contains "
6795 "unsupported segment selector size: %d.\n"),
6796 section
->name
, segment_selector_size
);
6800 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
6801 if (offset_entry_count
!= 0)
6803 warn (_("The %s section contains "
6804 "unsupported offset entry count: %u.\n"),
6805 section
->name
, offset_entry_count
);
6810 if (load_debug_info (file
) == 0)
6812 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6818 for (i
= 0; i
< num_debug_info_entries
; i
++)
6819 num_range_list
+= debug_information
[i
].num_range_lists
;
6821 if (num_range_list
== 0)
6823 /* This can happen when the file was compiled with -gsplit-debug
6824 which removes references to range lists from the primary .o file. */
6825 printf (_("No range lists in .debug_info section.\n"));
6829 range_entries
= (struct range_entry
*)
6830 xmalloc (sizeof (*range_entries
) * num_range_list
);
6831 range_entry_fill
= range_entries
;
6833 for (i
= 0; i
< num_debug_info_entries
; i
++)
6835 debug_info
*debug_info_p
= &debug_information
[i
];
6838 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
6840 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
6841 range_entry_fill
->debug_info_p
= debug_info_p
;
6846 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
6847 range_entry_compar
);
6849 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
6850 warn (_("Range lists in %s section start at 0x%lx\n"),
6851 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
6853 introduce (section
, FALSE
);
6855 printf (_(" Offset Begin End\n"));
6857 for (i
= 0; i
< num_range_list
; i
++)
6859 struct range_entry
*range_entry
= &range_entries
[i
];
6860 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
6861 unsigned int pointer_size
;
6863 unsigned char *next
;
6864 dwarf_vma base_address
;
6866 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
6867 offset
= range_entry
->ranges_offset
;
6868 next
= section_begin
+ offset
;
6869 base_address
= debug_info_p
->base_address
;
6871 /* PR 17512: file: 001-101485-0.001:0.1. */
6872 if (pointer_size
< 2 || pointer_size
> 8)
6874 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
6875 pointer_size
, (unsigned long) offset
);
6879 if (next
< section_begin
|| next
>= finish
)
6881 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
6882 (unsigned long) offset
, i
);
6886 if (dwarf_check
!= 0 && i
> 0)
6889 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
6890 (unsigned long) (start
- section_begin
),
6891 (unsigned long) (next
- section_begin
), section
->name
);
6892 else if (start
> next
)
6894 if (next
== last_start
)
6896 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
6897 (unsigned long) (start
- section_begin
),
6898 (unsigned long) (next
- section_begin
), section
->name
);
6905 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
6906 (start
, finish
, pointer_size
, offset
, base_address
);
6910 free (range_entries
);
6915 typedef struct Frame_Chunk
6917 struct Frame_Chunk
*next
;
6918 unsigned char *chunk_start
;
6920 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6921 short int *col_type
;
6924 unsigned int code_factor
;
6928 unsigned int cfa_reg
;
6929 dwarf_vma cfa_offset
;
6931 unsigned char fde_encoding
;
6932 unsigned char cfa_exp
;
6933 unsigned char ptr_size
;
6934 unsigned char segment_size
;
6938 static const char *const *dwarf_regnames
;
6939 static unsigned int dwarf_regnames_count
;
6941 /* A marker for a col_type that means this column was never referenced
6942 in the frame info. */
6943 #define DW_CFA_unreferenced (-1)
6945 /* Return 0 if no more space is needed, 1 if more space is needed,
6946 -1 for invalid reg. */
6949 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
6951 unsigned int prev
= fc
->ncols
;
6953 if (reg
< (unsigned int) fc
->ncols
)
6956 if (dwarf_regnames_count
6957 && reg
> dwarf_regnames_count
)
6960 fc
->ncols
= reg
+ 1;
6961 /* PR 17512: file: 10450-2643-0.004.
6962 If reg == -1 then this can happen... */
6966 /* PR 17512: file: 2844a11d. */
6967 if (fc
->ncols
> 1024)
6969 error (_("Unfeasibly large register number: %u\n"), reg
);
6971 /* FIXME: 1024 is an arbitrary limit. Increase it if
6972 we ever encounter a valid binary that exceeds it. */
6976 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
6977 sizeof (short int));
6978 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
6979 /* PR 17512: file:002-10025-0.005. */
6980 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
6982 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
6988 while (prev
< fc
->ncols
)
6990 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
6991 fc
->col_offset
[prev
] = 0;
6997 static const char *const dwarf_regnames_i386
[] =
6999 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7000 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7001 "eip", "eflags", NULL
, /* 8 - 10 */
7002 "st0", "st1", "st2", "st3", /* 11 - 14 */
7003 "st4", "st5", "st6", "st7", /* 15 - 18 */
7004 NULL
, NULL
, /* 19 - 20 */
7005 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7006 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7007 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7008 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7009 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7010 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7011 "tr", "ldtr", /* 48 - 49 */
7012 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7013 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7014 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7015 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7016 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7017 NULL
, NULL
, NULL
, /* 90 - 92 */
7018 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7021 static const char *const dwarf_regnames_iamcu
[] =
7023 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7024 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7025 "eip", "eflags", NULL
, /* 8 - 10 */
7026 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7027 NULL
, NULL
, /* 19 - 20 */
7028 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7029 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7030 NULL
, NULL
, NULL
, /* 37 - 39 */
7031 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7032 "tr", "ldtr", /* 48 - 49 */
7033 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7034 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7035 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7036 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7037 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7038 NULL
, NULL
, NULL
, /* 90 - 92 */
7039 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7043 init_dwarf_regnames_i386 (void)
7045 dwarf_regnames
= dwarf_regnames_i386
;
7046 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7050 init_dwarf_regnames_iamcu (void)
7052 dwarf_regnames
= dwarf_regnames_iamcu
;
7053 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7056 static const char *const dwarf_regnames_x86_64
[] =
7058 "rax", "rdx", "rcx", "rbx",
7059 "rsi", "rdi", "rbp", "rsp",
7060 "r8", "r9", "r10", "r11",
7061 "r12", "r13", "r14", "r15",
7063 "xmm0", "xmm1", "xmm2", "xmm3",
7064 "xmm4", "xmm5", "xmm6", "xmm7",
7065 "xmm8", "xmm9", "xmm10", "xmm11",
7066 "xmm12", "xmm13", "xmm14", "xmm15",
7067 "st0", "st1", "st2", "st3",
7068 "st4", "st5", "st6", "st7",
7069 "mm0", "mm1", "mm2", "mm3",
7070 "mm4", "mm5", "mm6", "mm7",
7072 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7073 "fs.base", "gs.base", NULL
, NULL
,
7075 "mxcsr", "fcw", "fsw",
7076 "xmm16", "xmm17", "xmm18", "xmm19",
7077 "xmm20", "xmm21", "xmm22", "xmm23",
7078 "xmm24", "xmm25", "xmm26", "xmm27",
7079 "xmm28", "xmm29", "xmm30", "xmm31",
7080 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7081 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7082 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7083 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7084 NULL
, NULL
, NULL
, /* 115 - 117 */
7085 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7089 init_dwarf_regnames_x86_64 (void)
7091 dwarf_regnames
= dwarf_regnames_x86_64
;
7092 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7095 static const char *const dwarf_regnames_aarch64
[] =
7097 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7098 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7099 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7100 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7101 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7102 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7103 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7104 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7105 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7106 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7107 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7108 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7112 init_dwarf_regnames_aarch64 (void)
7114 dwarf_regnames
= dwarf_regnames_aarch64
;
7115 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7118 static const char *const dwarf_regnames_s390
[] =
7120 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7121 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7122 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7123 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7124 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7125 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7126 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7127 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7128 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7131 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7132 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7136 init_dwarf_regnames_s390 (void)
7138 dwarf_regnames
= dwarf_regnames_s390
;
7139 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7142 static const char *const dwarf_regnames_riscv
[] =
7144 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7145 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7146 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7147 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7148 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7149 "fs0", "fs1", /* 40 - 41 */
7150 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7151 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7152 "fs10", "fs11", /* 58 - 59 */
7153 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7157 init_dwarf_regnames_riscv (void)
7159 dwarf_regnames
= dwarf_regnames_riscv
;
7160 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_riscv
);
7164 init_dwarf_regnames (unsigned int e_machine
)
7169 init_dwarf_regnames_i386 ();
7173 init_dwarf_regnames_iamcu ();
7179 init_dwarf_regnames_x86_64 ();
7183 init_dwarf_regnames_aarch64 ();
7187 init_dwarf_regnames_s390 ();
7191 init_dwarf_regnames_riscv ();
7200 regname (unsigned int regno
, int row
)
7202 static char reg
[64];
7205 && regno
< dwarf_regnames_count
7206 && dwarf_regnames
[regno
] != NULL
)
7209 return dwarf_regnames
[regno
];
7210 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
7211 dwarf_regnames
[regno
]);
7214 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7219 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7224 if (*max_regs
!= fc
->ncols
)
7225 *max_regs
= fc
->ncols
;
7227 if (*need_col_headers
)
7229 static const char *sloc
= " LOC";
7231 *need_col_headers
= 0;
7233 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7235 for (r
= 0; r
< *max_regs
; r
++)
7236 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7241 printf ("%-5s ", regname (r
, 1));
7247 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7249 strcpy (tmp
, "exp");
7251 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7252 printf ("%-8s ", tmp
);
7254 for (r
= 0; r
< fc
->ncols
; r
++)
7256 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7258 switch (fc
->col_type
[r
])
7260 case DW_CFA_undefined
:
7263 case DW_CFA_same_value
:
7267 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7269 case DW_CFA_val_offset
:
7270 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7272 case DW_CFA_register
:
7273 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7275 case DW_CFA_expression
:
7276 strcpy (tmp
, "exp");
7278 case DW_CFA_val_expression
:
7279 strcpy (tmp
, "vexp");
7282 strcpy (tmp
, "n/a");
7285 printf ("%-5s ", tmp
);
7291 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7293 static unsigned char *
7294 read_cie (unsigned char *start
, unsigned char *end
,
7295 Frame_Chunk
**p_cie
, int *p_version
,
7296 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7300 unsigned int length_return
;
7301 unsigned char *augmentation_data
= NULL
;
7302 bfd_size_type augmentation_data_len
= 0;
7305 /* PR 17512: file: 001-228113-0.004. */
7309 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7310 memset (fc
, 0, sizeof (Frame_Chunk
));
7312 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7313 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7317 fc
->augmentation
= (char *) start
;
7318 /* PR 17512: file: 001-228113-0.004.
7319 Skip past augmentation name, but avoid running off the end of the data. */
7321 if (* start
++ == '\0')
7325 warn (_("No terminator for augmentation name\n"));
7329 if (strcmp (fc
->augmentation
, "eh") == 0)
7330 start
+= eh_addr_size
;
7334 GET (fc
->ptr_size
, 1);
7335 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7337 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7341 GET (fc
->segment_size
, 1);
7342 /* PR 17512: file: e99d2804. */
7343 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7345 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7349 eh_addr_size
= fc
->ptr_size
;
7353 fc
->ptr_size
= eh_addr_size
;
7354 fc
->segment_size
= 0;
7357 READ_ULEB (fc
->code_factor
);
7358 READ_SLEB (fc
->data_factor
);
7369 if (fc
->augmentation
[0] == 'z')
7371 READ_ULEB (augmentation_data_len
);
7372 augmentation_data
= start
;
7373 /* PR 17512: file: 11042-2589-0.004. */
7374 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7376 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7377 dwarf_vmatoa ("x", augmentation_data_len
),
7378 (unsigned long) (end
- start
));
7381 start
+= augmentation_data_len
;
7384 if (augmentation_data_len
)
7388 unsigned char *qend
;
7390 p
= (unsigned char *) fc
->augmentation
+ 1;
7391 q
= augmentation_data
;
7392 qend
= q
+ augmentation_data_len
;
7394 while (p
< end
&& q
< qend
)
7399 q
+= 1 + size_of_encoded_value (*q
);
7401 fc
->fde_encoding
= *q
++;
7410 /* Note - it is OK if this loop terminates with q < qend.
7411 Padding may have been inserted to align the end of the CIE. */
7416 *p_version
= version
;
7419 *p_aug_len
= augmentation_data_len
;
7420 *p_aug
= augmentation_data
;
7425 free (fc
->col_offset
);
7426 free (fc
->col_type
);
7431 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7432 If do_wide is not enabled, then formats the output to fit into 80 columns.
7433 PRINTED contains the number of characters already written to the current
7437 display_data (bfd_size_type printed
,
7438 const unsigned char * data
,
7439 const bfd_size_type len
)
7441 if (do_wide
|| len
< ((80 - printed
) / 3))
7442 for (printed
= 0; printed
< len
; ++printed
)
7443 printf (" %02x", data
[printed
]);
7446 for (printed
= 0; printed
< len
; ++printed
)
7448 if (printed
% (80 / 3) == 0)
7450 printf (" %02x", data
[printed
]);
7455 /* Prints out the contents on the augmentation data array.
7456 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7459 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7463 i
= printf (_(" Augmentation data: "));
7464 display_data (i
, data
, len
);
7468 display_debug_frames (struct dwarf_section
*section
,
7469 void *file ATTRIBUTE_UNUSED
)
7471 unsigned char *start
= section
->start
;
7472 unsigned char *end
= start
+ section
->size
;
7473 unsigned char *section_start
= start
;
7474 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
7475 Frame_Chunk
*remembered_state
= NULL
;
7477 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7478 unsigned int length_return
;
7479 unsigned int max_regs
= 0;
7480 const char *bad_reg
= _("bad register: ");
7481 unsigned int saved_eh_addr_size
= eh_addr_size
;
7483 introduce (section
, FALSE
);
7487 unsigned char *saved_start
;
7488 unsigned char *block_end
;
7493 int need_col_headers
= 1;
7494 unsigned char *augmentation_data
= NULL
;
7495 bfd_size_type augmentation_data_len
= 0;
7496 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7497 unsigned int offset_size
;
7498 unsigned int initial_length_size
;
7499 bfd_boolean all_nops
;
7501 saved_start
= start
;
7503 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7507 printf ("\n%08lx ZERO terminator\n\n",
7508 (unsigned long)(saved_start
- section_start
));
7509 /* Skip any zero terminators that directly follow.
7510 A corrupt section size could have loaded a whole
7511 slew of zero filled memory bytes. eg
7512 PR 17512: file: 070-19381-0.004. */
7513 while (start
< end
&& * start
== 0)
7518 if (length
== 0xffffffff)
7520 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7522 initial_length_size
= 12;
7527 initial_length_size
= 4;
7530 block_end
= saved_start
+ length
+ initial_length_size
;
7531 if (block_end
> end
|| block_end
< start
)
7533 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7534 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7535 (unsigned long) (saved_start
- section_start
));
7539 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7541 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7542 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7547 start
= read_cie (start
, end
, &cie
, &version
,
7548 &augmentation_data_len
, &augmentation_data
);
7549 /* PR 17512: file: 027-135133-0.005. */
7556 fc
->chunk_start
= saved_start
;
7557 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7560 if (frame_need_space (fc
, mreg
) < 0)
7562 if (fc
->fde_encoding
)
7563 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7565 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7566 print_dwarf_vma (length
, fc
->ptr_size
);
7567 print_dwarf_vma (cie_id
, offset_size
);
7569 if (do_debug_frames_interp
)
7571 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7572 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7577 printf (" Version: %d\n", version
);
7578 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7581 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7582 printf (" Segment Size: %u\n", fc
->segment_size
);
7584 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7585 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7586 printf (" Return address column: %d\n", fc
->ra
);
7588 if (augmentation_data_len
)
7589 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7596 unsigned char *look_for
;
7597 static Frame_Chunk fde_fc
;
7598 unsigned long segment_selector
;
7602 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7603 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7606 look_for
= section_start
+ cie_id
;
7608 if (look_for
<= saved_start
)
7610 for (cie
= chunks
; cie
; cie
= cie
->next
)
7611 if (cie
->chunk_start
== look_for
)
7616 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7617 if (cie
->chunk_start
== look_for
)
7621 unsigned int off_size
;
7622 unsigned char *cie_scan
;
7624 cie_scan
= look_for
;
7626 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7627 if (length
== 0xffffffff)
7629 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7636 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7639 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7640 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7645 read_cie (cie_scan
, end
, &cie
, &version
,
7646 &augmentation_data_len
, &augmentation_data
);
7647 /* PR 17512: file: 3450-2098-0.004. */
7650 warn (_("Failed to read CIE information\n"));
7653 cie
->next
= forward_refs
;
7655 cie
->chunk_start
= look_for
;
7656 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7659 if (frame_need_space (cie
, mreg
) < 0)
7661 warn (_("Invalid max register\n"));
7664 if (cie
->fde_encoding
)
7666 = size_of_encoded_value (cie
->fde_encoding
);
7673 memset (fc
, 0, sizeof (Frame_Chunk
));
7677 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7678 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7679 (unsigned long) (saved_start
- section_start
));
7681 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7682 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7683 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
7685 warn (_("Invalid max register\n"));
7689 fc
->augmentation
= "";
7690 fc
->fde_encoding
= 0;
7691 fc
->ptr_size
= eh_addr_size
;
7692 fc
->segment_size
= 0;
7696 fc
->ncols
= cie
->ncols
;
7697 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
7698 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
7699 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
7700 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
7701 fc
->augmentation
= cie
->augmentation
;
7702 fc
->ptr_size
= cie
->ptr_size
;
7703 eh_addr_size
= cie
->ptr_size
;
7704 fc
->segment_size
= cie
->segment_size
;
7705 fc
->code_factor
= cie
->code_factor
;
7706 fc
->data_factor
= cie
->data_factor
;
7707 fc
->cfa_reg
= cie
->cfa_reg
;
7708 fc
->cfa_offset
= cie
->cfa_offset
;
7710 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
7712 warn (_("Invalid max register\n"));
7715 fc
->fde_encoding
= cie
->fde_encoding
;
7718 if (fc
->fde_encoding
)
7719 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7721 segment_selector
= 0;
7722 if (fc
->segment_size
)
7724 if (fc
->segment_size
> sizeof (segment_selector
))
7726 /* PR 17512: file: 9e196b3e. */
7727 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
7728 fc
->segment_size
= 4;
7730 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
7733 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
7735 /* FIXME: It appears that sometimes the final pc_range value is
7736 encoded in less than encoded_ptr_size bytes. See the x86_64
7737 run of the "objcopy on compressed debug sections" test for an
7739 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
7741 if (cie
->augmentation
[0] == 'z')
7743 READ_ULEB (augmentation_data_len
);
7744 augmentation_data
= start
;
7745 start
+= augmentation_data_len
;
7746 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
7748 || ((bfd_signed_vma
) augmentation_data_len
) < 0
7749 || augmentation_data
> start
)
7751 warn (_("Corrupt augmentation data length: 0x%s\n"),
7752 dwarf_vmatoa ("x", augmentation_data_len
));
7754 augmentation_data
= NULL
;
7755 augmentation_data_len
= 0;
7759 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
7760 (unsigned long)(saved_start
- section_start
),
7761 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
7762 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7763 (unsigned long)(cie
->chunk_start
- section_start
));
7765 if (fc
->segment_size
)
7766 printf ("%04lx:", segment_selector
);
7769 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
7770 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
7772 if (! do_debug_frames_interp
&& augmentation_data_len
)
7774 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7779 /* At this point, fc is the current chunk, cie (if any) is set, and
7780 we're about to interpret instructions for the chunk. */
7781 /* ??? At present we need to do this always, since this sizes the
7782 fc->col_type and fc->col_offset arrays, which we write into always.
7783 We should probably split the interpreted and non-interpreted bits
7784 into two different routines, since there's so much that doesn't
7785 really overlap between them. */
7786 if (1 || do_debug_frames_interp
)
7788 /* Start by making a pass over the chunk, allocating storage
7789 and taking note of what registers are used. */
7790 unsigned char *tmp
= start
;
7792 while (start
< block_end
)
7794 unsigned int reg
, op
, opa
;
7796 unsigned char * new_start
;
7803 /* Warning: if you add any more cases to this switch, be
7804 sure to add them to the corresponding switch below. */
7807 case DW_CFA_advance_loc
:
7811 if (frame_need_space (fc
, opa
) >= 0)
7812 fc
->col_type
[opa
] = DW_CFA_undefined
;
7814 case DW_CFA_restore
:
7815 if (frame_need_space (fc
, opa
) >= 0)
7816 fc
->col_type
[opa
] = DW_CFA_undefined
;
7818 case DW_CFA_set_loc
:
7819 start
+= encoded_ptr_size
;
7821 case DW_CFA_advance_loc1
:
7824 case DW_CFA_advance_loc2
:
7827 case DW_CFA_advance_loc4
:
7830 case DW_CFA_offset_extended
:
7831 case DW_CFA_val_offset
:
7834 if (frame_need_space (fc
, reg
) >= 0)
7835 fc
->col_type
[reg
] = DW_CFA_undefined
;
7837 case DW_CFA_restore_extended
:
7839 if (frame_need_space (fc
, reg
) >= 0)
7840 fc
->col_type
[reg
] = DW_CFA_undefined
;
7842 case DW_CFA_undefined
:
7844 if (frame_need_space (fc
, reg
) >= 0)
7845 fc
->col_type
[reg
] = DW_CFA_undefined
;
7847 case DW_CFA_same_value
:
7849 if (frame_need_space (fc
, reg
) >= 0)
7850 fc
->col_type
[reg
] = DW_CFA_undefined
;
7852 case DW_CFA_register
:
7855 if (frame_need_space (fc
, reg
) >= 0)
7856 fc
->col_type
[reg
] = DW_CFA_undefined
;
7858 case DW_CFA_def_cfa
:
7862 case DW_CFA_def_cfa_register
:
7865 case DW_CFA_def_cfa_offset
:
7868 case DW_CFA_def_cfa_expression
:
7870 new_start
= start
+ temp
;
7871 if (new_start
< start
)
7873 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
7879 case DW_CFA_expression
:
7880 case DW_CFA_val_expression
:
7883 new_start
= start
+ temp
;
7884 if (new_start
< start
)
7886 /* PR 17512: file:306-192417-0.005. */
7887 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
7892 if (frame_need_space (fc
, reg
) >= 0)
7893 fc
->col_type
[reg
] = DW_CFA_undefined
;
7895 case DW_CFA_offset_extended_sf
:
7896 case DW_CFA_val_offset_sf
:
7899 if (frame_need_space (fc
, reg
) >= 0)
7900 fc
->col_type
[reg
] = DW_CFA_undefined
;
7902 case DW_CFA_def_cfa_sf
:
7906 case DW_CFA_def_cfa_offset_sf
:
7909 case DW_CFA_MIPS_advance_loc8
:
7912 case DW_CFA_GNU_args_size
:
7915 case DW_CFA_GNU_negative_offset_extended
:
7918 if (frame_need_space (fc
, reg
) >= 0)
7919 fc
->col_type
[reg
] = DW_CFA_undefined
;
7930 /* Now we know what registers are used, make a second pass over
7931 the chunk, this time actually printing out the info. */
7933 while (start
< block_end
)
7935 unsigned char * tmp
;
7937 unsigned long ul
, roffs
;
7938 /* Note: It is tempting to use an unsigned long for 'reg' but there
7939 are various functions, notably frame_space_needed() that assume that
7940 reg is an unsigned int. */
7945 const char *reg_prefix
= "";
7952 /* Make a note if something other than DW_CFA_nop happens. */
7953 if (op
!= DW_CFA_nop
)
7956 /* Warning: if you add any more cases to this switch, be
7957 sure to add them to the corresponding switch above. */
7960 case DW_CFA_advance_loc
:
7961 if (do_debug_frames_interp
)
7962 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7964 printf (" DW_CFA_advance_loc: %d to %s\n",
7965 opa
* fc
->code_factor
,
7966 dwarf_vmatoa_1 (NULL
,
7967 fc
->pc_begin
+ opa
* fc
->code_factor
,
7969 fc
->pc_begin
+= opa
* fc
->code_factor
;
7974 if (opa
>= (unsigned int) fc
->ncols
)
7975 reg_prefix
= bad_reg
;
7976 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7977 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
7978 reg_prefix
, regname (opa
, 0),
7979 roffs
* fc
->data_factor
);
7980 if (*reg_prefix
== '\0')
7982 fc
->col_type
[opa
] = DW_CFA_offset
;
7983 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
7987 case DW_CFA_restore
:
7988 if (opa
>= (unsigned int) fc
->ncols
)
7989 reg_prefix
= bad_reg
;
7990 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7991 printf (" DW_CFA_restore: %s%s\n",
7992 reg_prefix
, regname (opa
, 0));
7993 if (*reg_prefix
!= '\0')
7996 if (opa
>= (unsigned int) cie
->ncols
7997 || (do_debug_frames_interp
7998 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8000 fc
->col_type
[opa
] = DW_CFA_undefined
;
8001 fc
->col_offset
[opa
] = 0;
8005 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8006 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8010 case DW_CFA_set_loc
:
8011 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8012 if (do_debug_frames_interp
)
8013 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8015 printf (" DW_CFA_set_loc: %s\n",
8016 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8020 case DW_CFA_advance_loc1
:
8021 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8022 if (do_debug_frames_interp
)
8023 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8025 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8026 (unsigned long) (ofs
* fc
->code_factor
),
8027 dwarf_vmatoa_1 (NULL
,
8028 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8030 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8033 case DW_CFA_advance_loc2
:
8034 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8035 if (do_debug_frames_interp
)
8036 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8038 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8039 (unsigned long) (ofs
* fc
->code_factor
),
8040 dwarf_vmatoa_1 (NULL
,
8041 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8043 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8046 case DW_CFA_advance_loc4
:
8047 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8048 if (do_debug_frames_interp
)
8049 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8051 printf (" DW_CFA_advance_loc4: %ld to %s\n",
8052 (unsigned long) (ofs
* fc
->code_factor
),
8053 dwarf_vmatoa_1 (NULL
,
8054 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8056 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8059 case DW_CFA_offset_extended
:
8062 if (reg
>= (unsigned int) fc
->ncols
)
8063 reg_prefix
= bad_reg
;
8064 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8065 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8066 reg_prefix
, regname (reg
, 0),
8067 roffs
* fc
->data_factor
);
8068 if (*reg_prefix
== '\0')
8070 fc
->col_type
[reg
] = DW_CFA_offset
;
8071 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8075 case DW_CFA_val_offset
:
8078 if (reg
>= (unsigned int) fc
->ncols
)
8079 reg_prefix
= bad_reg
;
8080 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8081 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8082 reg_prefix
, regname (reg
, 0),
8083 roffs
* fc
->data_factor
);
8084 if (*reg_prefix
== '\0')
8086 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8087 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8091 case DW_CFA_restore_extended
:
8093 if (reg
>= (unsigned int) fc
->ncols
)
8094 reg_prefix
= bad_reg
;
8095 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8096 printf (" DW_CFA_restore_extended: %s%s\n",
8097 reg_prefix
, regname (reg
, 0));
8098 if (*reg_prefix
!= '\0')
8101 if (reg
>= (unsigned int) cie
->ncols
)
8103 fc
->col_type
[reg
] = DW_CFA_undefined
;
8104 fc
->col_offset
[reg
] = 0;
8108 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8109 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8113 case DW_CFA_undefined
:
8115 if (reg
>= (unsigned int) fc
->ncols
)
8116 reg_prefix
= bad_reg
;
8117 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8118 printf (" DW_CFA_undefined: %s%s\n",
8119 reg_prefix
, regname (reg
, 0));
8120 if (*reg_prefix
== '\0')
8122 fc
->col_type
[reg
] = DW_CFA_undefined
;
8123 fc
->col_offset
[reg
] = 0;
8127 case DW_CFA_same_value
:
8129 if (reg
>= (unsigned int) fc
->ncols
)
8130 reg_prefix
= bad_reg
;
8131 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8132 printf (" DW_CFA_same_value: %s%s\n",
8133 reg_prefix
, regname (reg
, 0));
8134 if (*reg_prefix
== '\0')
8136 fc
->col_type
[reg
] = DW_CFA_same_value
;
8137 fc
->col_offset
[reg
] = 0;
8141 case DW_CFA_register
:
8144 if (reg
>= (unsigned int) fc
->ncols
)
8145 reg_prefix
= bad_reg
;
8146 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8148 printf (" DW_CFA_register: %s%s in ",
8149 reg_prefix
, regname (reg
, 0));
8150 puts (regname (roffs
, 0));
8152 if (*reg_prefix
== '\0')
8154 fc
->col_type
[reg
] = DW_CFA_register
;
8155 fc
->col_offset
[reg
] = roffs
;
8159 case DW_CFA_remember_state
:
8160 if (! do_debug_frames_interp
)
8161 printf (" DW_CFA_remember_state\n");
8162 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8163 rs
->cfa_offset
= fc
->cfa_offset
;
8164 rs
->cfa_reg
= fc
->cfa_reg
;
8166 rs
->cfa_exp
= fc
->cfa_exp
;
8167 rs
->ncols
= fc
->ncols
;
8168 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8169 sizeof (* rs
->col_type
));
8170 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8171 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8172 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8173 rs
->next
= remembered_state
;
8174 remembered_state
= rs
;
8177 case DW_CFA_restore_state
:
8178 if (! do_debug_frames_interp
)
8179 printf (" DW_CFA_restore_state\n");
8180 rs
= remembered_state
;
8183 remembered_state
= rs
->next
;
8184 fc
->cfa_offset
= rs
->cfa_offset
;
8185 fc
->cfa_reg
= rs
->cfa_reg
;
8187 fc
->cfa_exp
= rs
->cfa_exp
;
8188 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8190 warn (_("Invalid column number in saved frame state\n"));
8194 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8195 memcpy (fc
->col_offset
, rs
->col_offset
,
8196 rs
->ncols
* sizeof (* rs
->col_offset
));
8197 free (rs
->col_type
);
8198 free (rs
->col_offset
);
8201 else if (do_debug_frames_interp
)
8202 printf ("Mismatched DW_CFA_restore_state\n");
8205 case DW_CFA_def_cfa
:
8206 READ_ULEB (fc
->cfa_reg
);
8207 READ_ULEB (fc
->cfa_offset
);
8209 if (! do_debug_frames_interp
)
8210 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8211 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8214 case DW_CFA_def_cfa_register
:
8215 READ_ULEB (fc
->cfa_reg
);
8217 if (! do_debug_frames_interp
)
8218 printf (" DW_CFA_def_cfa_register: %s\n",
8219 regname (fc
->cfa_reg
, 0));
8222 case DW_CFA_def_cfa_offset
:
8223 READ_ULEB (fc
->cfa_offset
);
8224 if (! do_debug_frames_interp
)
8225 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8229 if (! do_debug_frames_interp
)
8230 printf (" DW_CFA_nop\n");
8233 case DW_CFA_def_cfa_expression
:
8235 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8237 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8240 if (! do_debug_frames_interp
)
8242 printf (" DW_CFA_def_cfa_expression (");
8243 decode_location_expression (start
, eh_addr_size
, 0, -1,
8251 case DW_CFA_expression
:
8254 if (reg
>= (unsigned int) fc
->ncols
)
8255 reg_prefix
= bad_reg
;
8256 /* PR 17512: file: 069-133014-0.006. */
8257 /* PR 17512: file: 98c02eb4. */
8259 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8261 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8264 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8266 printf (" DW_CFA_expression: %s%s (",
8267 reg_prefix
, regname (reg
, 0));
8268 decode_location_expression (start
, eh_addr_size
, 0, -1,
8272 if (*reg_prefix
== '\0')
8273 fc
->col_type
[reg
] = DW_CFA_expression
;
8277 case DW_CFA_val_expression
:
8280 if (reg
>= (unsigned int) fc
->ncols
)
8281 reg_prefix
= bad_reg
;
8283 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8285 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8288 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8290 printf (" DW_CFA_val_expression: %s%s (",
8291 reg_prefix
, regname (reg
, 0));
8292 decode_location_expression (start
, eh_addr_size
, 0, -1,
8296 if (*reg_prefix
== '\0')
8297 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8301 case DW_CFA_offset_extended_sf
:
8304 if (frame_need_space (fc
, reg
) < 0)
8305 reg_prefix
= bad_reg
;
8306 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8307 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8308 reg_prefix
, regname (reg
, 0),
8309 (long)(l
* fc
->data_factor
));
8310 if (*reg_prefix
== '\0')
8312 fc
->col_type
[reg
] = DW_CFA_offset
;
8313 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8317 case DW_CFA_val_offset_sf
:
8320 if (frame_need_space (fc
, reg
) < 0)
8321 reg_prefix
= bad_reg
;
8322 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8323 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8324 reg_prefix
, regname (reg
, 0),
8325 (long)(l
* fc
->data_factor
));
8326 if (*reg_prefix
== '\0')
8328 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8329 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8333 case DW_CFA_def_cfa_sf
:
8334 READ_ULEB (fc
->cfa_reg
);
8335 READ_ULEB (fc
->cfa_offset
);
8336 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8338 if (! do_debug_frames_interp
)
8339 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8340 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8343 case DW_CFA_def_cfa_offset_sf
:
8344 READ_ULEB (fc
->cfa_offset
);
8345 fc
->cfa_offset
*= fc
->data_factor
;
8346 if (! do_debug_frames_interp
)
8347 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8350 case DW_CFA_MIPS_advance_loc8
:
8351 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8352 if (do_debug_frames_interp
)
8353 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8355 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8356 (unsigned long) (ofs
* fc
->code_factor
),
8357 dwarf_vmatoa_1 (NULL
,
8358 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8360 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8363 case DW_CFA_GNU_window_save
:
8364 if (! do_debug_frames_interp
)
8365 printf (" DW_CFA_GNU_window_save\n");
8368 case DW_CFA_GNU_args_size
:
8370 if (! do_debug_frames_interp
)
8371 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8374 case DW_CFA_GNU_negative_offset_extended
:
8378 if (frame_need_space (fc
, reg
) < 0)
8379 reg_prefix
= bad_reg
;
8380 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8381 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8382 reg_prefix
, regname (reg
, 0),
8383 (long)(l
* fc
->data_factor
));
8384 if (*reg_prefix
== '\0')
8386 fc
->col_type
[reg
] = DW_CFA_offset
;
8387 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8392 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8393 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8395 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8400 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8401 if (do_debug_frames_interp
&& ! all_nops
)
8402 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8405 eh_addr_size
= saved_eh_addr_size
;
8410 while (remembered_state
!= NULL
)
8412 rs
= remembered_state
;
8413 remembered_state
= rs
->next
;
8414 free (rs
->col_type
);
8415 free (rs
->col_offset
);
8416 rs
->next
= NULL
; /* Paranoia. */
8420 while (chunks
!= NULL
)
8424 free (rs
->col_type
);
8425 free (rs
->col_offset
);
8426 rs
->next
= NULL
; /* Paranoia. */
8430 while (forward_refs
!= NULL
)
8433 forward_refs
= rs
->next
;
8434 free (rs
->col_type
);
8435 free (rs
->col_offset
);
8436 rs
->next
= NULL
; /* Paranoia. */
8446 display_debug_names (struct dwarf_section
*section
, void *file
)
8448 unsigned char *hdrptr
= section
->start
;
8449 dwarf_vma unit_length
;
8450 unsigned char *unit_start
;
8451 const unsigned char *const section_end
= section
->start
+ section
->size
;
8452 unsigned char *unit_end
;
8454 introduce (section
, FALSE
);
8456 load_debug_section_with_follow (str
, file
);
8458 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8460 unsigned int offset_size
;
8461 uint16_t dwarf_version
, padding
;
8462 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8463 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8464 uint32_t augmentation_string_size
;
8466 unsigned long sec_off
;
8468 unit_start
= hdrptr
;
8470 /* Get and check the length of the block. */
8471 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8473 if (unit_length
== 0xffffffff)
8475 /* This section is 64-bit DWARF. */
8476 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8481 unit_end
= hdrptr
+ unit_length
;
8483 sec_off
= hdrptr
- section
->start
;
8484 if (sec_off
+ unit_length
< sec_off
8485 || sec_off
+ unit_length
> section
->size
)
8487 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8489 (unsigned long) (unit_start
- section
->start
),
8490 dwarf_vmatoa ("x", unit_length
));
8494 /* Get and check the version number. */
8495 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8496 printf (_("Version %ld\n"), (long) dwarf_version
);
8498 /* Prior versions did not exist, and future versions may not be
8499 backwards compatible. */
8500 if (dwarf_version
!= 5)
8502 warn (_("Only DWARF version 5 .debug_names "
8503 "is currently supported.\n"));
8507 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8509 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8512 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8513 if (comp_unit_count
== 0)
8514 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8516 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8517 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8518 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8519 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8520 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8522 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8523 if (augmentation_string_size
% 4 != 0)
8525 warn (_("Augmentation string length %u must be rounded up "
8526 "to a multiple of 4 in .debug_names.\n"),
8527 augmentation_string_size
);
8528 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8530 printf (_("Augmentation string:"));
8531 for (i
= 0; i
< augmentation_string_size
; i
++)
8535 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8536 printf (" %02x", uc
);
8541 printf (_("CU table:\n"));
8542 for (i
= 0; i
< comp_unit_count
; i
++)
8546 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8547 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8551 printf (_("TU table:\n"));
8552 for (i
= 0; i
< local_type_unit_count
; i
++)
8556 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8557 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8561 printf (_("Foreign TU table:\n"));
8562 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8566 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8567 printf (_("[%3u] "), i
);
8568 print_dwarf_vma (signature
, 8);
8573 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8574 hdrptr
+= bucket_count
* sizeof (uint32_t);
8575 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8576 hdrptr
+= name_count
* sizeof (uint32_t);
8577 unsigned char *const name_table_string_offsets
= hdrptr
;
8578 hdrptr
+= name_count
* offset_size
;
8579 unsigned char *const name_table_entry_offsets
= hdrptr
;
8580 hdrptr
+= name_count
* offset_size
;
8581 unsigned char *const abbrev_table
= hdrptr
;
8582 hdrptr
+= abbrev_table_size
;
8583 const unsigned char *const abbrev_table_end
= hdrptr
;
8584 unsigned char *const entry_pool
= hdrptr
;
8585 if (hdrptr
> unit_end
)
8587 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8588 "for unit 0x%lx in the debug_names\n"),
8589 (long) (hdrptr
- section
->start
),
8590 (long) (unit_end
- section
->start
),
8591 (long) (unit_start
- section
->start
));
8595 size_t buckets_filled
= 0;
8597 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8599 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8604 printf (ngettext ("Used %zu of %lu bucket.\n",
8605 "Used %zu of %lu buckets.\n",
8607 buckets_filled
, (unsigned long) bucket_count
);
8609 uint32_t hash_prev
= 0;
8610 size_t hash_clash_count
= 0;
8611 size_t longest_clash
= 0;
8612 size_t this_length
= 0;
8614 for (hashi
= 0; hashi
< name_count
; hashi
++)
8616 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8620 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8624 longest_clash
= MAX (longest_clash
, this_length
);
8629 hash_prev
= hash_this
;
8631 printf (_("Out of %lu items there are %zu bucket clashes"
8632 " (longest of %zu entries).\n"),
8633 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
8634 assert (name_count
== buckets_filled
+ hash_clash_count
);
8636 struct abbrev_lookup_entry
8638 dwarf_vma abbrev_tag
;
8639 unsigned char *abbrev_lookup_ptr
;
8641 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
8642 size_t abbrev_lookup_used
= 0;
8643 size_t abbrev_lookup_allocated
= 0;
8645 unsigned char *abbrevptr
= abbrev_table
;
8648 unsigned int bytes_read
;
8649 const dwarf_vma abbrev_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8651 abbrevptr
+= bytes_read
;
8652 if (abbrev_tag
== 0)
8654 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
8656 abbrev_lookup_allocated
= MAX (0x100,
8657 abbrev_lookup_allocated
* 2);
8658 abbrev_lookup
= xrealloc (abbrev_lookup
,
8659 (abbrev_lookup_allocated
8660 * sizeof (*abbrev_lookup
)));
8662 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
8663 struct abbrev_lookup_entry
*entry
;
8664 for (entry
= abbrev_lookup
;
8665 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8667 if (entry
->abbrev_tag
== abbrev_tag
)
8669 warn (_("Duplicate abbreviation tag %lu "
8670 "in unit 0x%lx in the debug_names\n"),
8671 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
8674 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
8675 entry
->abbrev_tag
= abbrev_tag
;
8676 entry
->abbrev_lookup_ptr
= abbrevptr
;
8678 /* Skip DWARF tag. */
8679 read_uleb128 (abbrevptr
, &bytes_read
, abbrev_table_end
);
8680 abbrevptr
+= bytes_read
;
8683 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8686 abbrevptr
+= bytes_read
;
8687 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8689 abbrevptr
+= bytes_read
;
8690 if (xindex
== 0 && form
== 0)
8695 printf (_("\nSymbol table:\n"));
8697 for (namei
= 0; namei
< name_count
; ++namei
)
8699 uint64_t string_offset
, entry_offset
;
8701 SAFE_BYTE_GET (string_offset
,
8702 name_table_string_offsets
+ namei
* offset_size
,
8703 offset_size
, unit_end
);
8704 SAFE_BYTE_GET (entry_offset
,
8705 name_table_entry_offsets
+ namei
* offset_size
,
8706 offset_size
, unit_end
);
8708 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
8709 fetch_indirect_string (string_offset
));
8711 unsigned char *entryptr
= entry_pool
+ entry_offset
;
8713 // We need to scan first whether there is a single or multiple
8714 // entries. TAGNO is -2 for the first entry, it is -1 for the
8715 // initial tag read of the second entry, then it becomes 0 for the
8716 // first entry for real printing etc.
8718 /* Initialize it due to a false compiler warning. */
8719 dwarf_vma second_abbrev_tag
= -1;
8722 unsigned int bytes_read
;
8723 const dwarf_vma abbrev_tag
= read_uleb128 (entryptr
, &bytes_read
,
8725 entryptr
+= bytes_read
;
8728 second_abbrev_tag
= abbrev_tag
;
8730 entryptr
= entry_pool
+ entry_offset
;
8733 if (abbrev_tag
== 0)
8737 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
8738 (unsigned long) abbrev_tag
);
8740 const struct abbrev_lookup_entry
*entry
;
8741 for (entry
= abbrev_lookup
;
8742 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8744 if (entry
->abbrev_tag
== abbrev_tag
)
8746 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
8748 warn (_("Undefined abbreviation tag %lu "
8749 "in unit 0x%lx in the debug_names\n"),
8751 (long) (unit_start
- section
->start
));
8754 abbrevptr
= entry
->abbrev_lookup_ptr
;
8755 const dwarf_vma dwarf_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8757 abbrevptr
+= bytes_read
;
8759 printf (" %s", get_TAG_name (dwarf_tag
));
8762 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8765 abbrevptr
+= bytes_read
;
8766 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8768 abbrevptr
+= bytes_read
;
8769 if (xindex
== 0 && form
== 0)
8773 printf (" %s", get_IDX_name (xindex
));
8774 entryptr
= read_and_display_attr_value (0, form
, 0, entryptr
,
8777 dwarf_version
, NULL
,
8784 printf (_(" <no entries>"));
8788 free (abbrev_lookup
);
8795 display_debug_links (struct dwarf_section
* section
,
8796 void * file ATTRIBUTE_UNUSED
)
8798 const unsigned char * filename
;
8799 unsigned int filelen
;
8801 introduce (section
, FALSE
);
8803 /* The .gnu_debuglink section is formatted as:
8804 (c-string) Filename.
8805 (padding) If needed to reach a 4 byte boundary.
8806 (uint32_t) CRC32 value.
8808 The .gun_debugaltlink section is formatted as:
8809 (c-string) Filename.
8810 (binary) Build-ID. */
8812 filename
= section
->start
;
8813 filelen
= strnlen ((const char *) filename
, section
->size
);
8814 if (filelen
== section
->size
)
8816 warn (_("The debuglink filename is corrupt/missing\n"));
8820 printf (_(" Separate debug info file: %s\n"), filename
);
8822 if (const_strneq (section
->name
, ".gnu_debuglink"))
8825 unsigned int crc_offset
;
8827 crc_offset
= filelen
+ 1;
8828 crc_offset
= (crc_offset
+ 3) & ~3;
8829 if (crc_offset
+ 4 > section
->size
)
8831 warn (_("CRC offset missing/truncated\n"));
8835 crc32
= byte_get (filename
+ crc_offset
, 4);
8837 printf (_(" CRC value: %#x\n"), crc32
);
8839 if (crc_offset
+ 4 < section
->size
)
8841 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
8842 (long)(section
->size
- (crc_offset
+ 4)));
8846 else /* const_strneq (section->name, ".gnu_debugaltlink") */
8848 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
8849 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
8850 bfd_size_type printed
;
8852 /* FIXME: Should we support smaller build-id notes ? */
8853 if (build_id_len
< 0x14)
8855 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
8859 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
8860 display_data (printed
, build_id
, build_id_len
);
8869 display_gdb_index (struct dwarf_section
*section
,
8870 void *file ATTRIBUTE_UNUSED
)
8872 unsigned char *start
= section
->start
;
8874 uint32_t cu_list_offset
, tu_list_offset
;
8875 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
8876 unsigned int cu_list_elements
, tu_list_elements
;
8877 unsigned int address_table_size
, symbol_table_slots
;
8878 unsigned char *cu_list
, *tu_list
;
8879 unsigned char *address_table
, *symbol_table
, *constant_pool
;
8882 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
8884 introduce (section
, FALSE
);
8886 if (section
->size
< 6 * sizeof (uint32_t))
8888 warn (_("Truncated header in the %s section.\n"), section
->name
);
8892 version
= byte_get_little_endian (start
, 4);
8893 printf (_("Version %ld\n"), (long) version
);
8895 /* Prior versions are obsolete, and future versions may not be
8896 backwards compatible. */
8897 if (version
< 3 || version
> 8)
8899 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
8903 warn (_("The address table data in version 3 may be wrong.\n"));
8905 warn (_("Version 4 does not support case insensitive lookups.\n"));
8907 warn (_("Version 5 does not include inlined functions.\n"));
8909 warn (_("Version 6 does not include symbol attributes.\n"));
8910 /* Version 7 indices generated by Gold have bad type unit references,
8911 PR binutils/15021. But we don't know if the index was generated by
8912 Gold or not, so to avoid worrying users with gdb-generated indices
8913 we say nothing for version 7 here. */
8915 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
8916 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
8917 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
8918 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
8919 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
8921 if (cu_list_offset
> section
->size
8922 || tu_list_offset
> section
->size
8923 || address_table_offset
> section
->size
8924 || symbol_table_offset
> section
->size
8925 || constant_pool_offset
> section
->size
)
8927 warn (_("Corrupt header in the %s section.\n"), section
->name
);
8931 /* PR 17531: file: 418d0a8a. */
8932 if (tu_list_offset
< cu_list_offset
)
8934 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
8935 tu_list_offset
, cu_list_offset
);
8939 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
8941 if (address_table_offset
< tu_list_offset
)
8943 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
8944 address_table_offset
, tu_list_offset
);
8948 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
8950 /* PR 17531: file: 18a47d3d. */
8951 if (symbol_table_offset
< address_table_offset
)
8953 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
8954 symbol_table_offset
, address_table_offset
);
8958 address_table_size
= symbol_table_offset
- address_table_offset
;
8960 if (constant_pool_offset
< symbol_table_offset
)
8962 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
8963 constant_pool_offset
, symbol_table_offset
);
8967 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
8969 cu_list
= start
+ cu_list_offset
;
8970 tu_list
= start
+ tu_list_offset
;
8971 address_table
= start
+ address_table_offset
;
8972 symbol_table
= start
+ symbol_table_offset
;
8973 constant_pool
= start
+ constant_pool_offset
;
8975 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
8977 warn (_("Address table extends beyond end of section.\n"));
8981 printf (_("\nCU table:\n"));
8982 for (i
= 0; i
< cu_list_elements
; i
+= 2)
8984 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
8985 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
8987 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
8988 (unsigned long) cu_offset
,
8989 (unsigned long) (cu_offset
+ cu_length
- 1));
8992 printf (_("\nTU table:\n"));
8993 for (i
= 0; i
< tu_list_elements
; i
+= 3)
8995 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
8996 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
8997 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
8999 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9000 (unsigned long) tu_offset
,
9001 (unsigned long) type_offset
);
9002 print_dwarf_vma (signature
, 8);
9006 printf (_("\nAddress table:\n"));
9007 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9010 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9011 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9012 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9014 print_dwarf_vma (low
, 8);
9015 print_dwarf_vma (high
, 8);
9016 printf (_("%lu\n"), (unsigned long) cu_index
);
9019 printf (_("\nSymbol table:\n"));
9020 for (i
= 0; i
< symbol_table_slots
; ++i
)
9022 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9023 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9024 uint32_t num_cus
, cu
;
9026 if (name_offset
!= 0
9027 || cu_vector_offset
!= 0)
9030 unsigned char * adr
;
9032 adr
= constant_pool
+ name_offset
;
9033 /* PR 17531: file: 5b7b07ad. */
9034 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
9036 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
9037 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
9041 printf ("[%3u] %.*s:", i
,
9042 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
9043 constant_pool
+ name_offset
);
9045 adr
= constant_pool
+ cu_vector_offset
;
9046 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
9048 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
9049 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
9050 cu_vector_offset
, i
);
9054 num_cus
= byte_get_little_endian (adr
, 4);
9056 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
9057 if (num_cus
* 4 < num_cus
9058 || adr
>= section
->start
+ section
->size
9059 || adr
< constant_pool
)
9061 printf ("<invalid number of CUs: %d>\n", num_cus
);
9062 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
9070 for (j
= 0; j
< num_cus
; ++j
)
9073 gdb_index_symbol_kind kind
;
9075 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
9076 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
9077 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
9078 cu
= GDB_INDEX_CU_VALUE (cu
);
9079 /* Convert to TU number if it's for a type unit. */
9080 if (cu
>= cu_list_elements
/ 2)
9081 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
9082 (unsigned long) (cu
- cu_list_elements
/ 2));
9084 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
9086 printf (" [%s, %s]",
9087 is_static
? _("static") : _("global"),
9088 get_gdb_index_symbol_kind_name (kind
));
9100 /* Pre-allocate enough space for the CU/TU sets needed. */
9103 prealloc_cu_tu_list (unsigned int nshndx
)
9105 if (shndx_pool
== NULL
)
9107 shndx_pool_size
= nshndx
;
9108 shndx_pool_used
= 0;
9109 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9110 sizeof (unsigned int));
9114 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9115 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9116 sizeof (unsigned int));
9121 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9123 if (shndx_pool_used
>= shndx_pool_size
)
9125 error (_("Internal error: out of space in the shndx pool.\n"));
9128 shndx_pool
[shndx_pool_used
++] = shndx
;
9132 end_cu_tu_entry (void)
9134 if (shndx_pool_used
>= shndx_pool_size
)
9136 error (_("Internal error: out of space in the shndx pool.\n"));
9139 shndx_pool
[shndx_pool_used
++] = 0;
9142 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9145 get_DW_SECT_short_name (unsigned int dw_sect
)
9147 static char buf
[16];
9155 case DW_SECT_ABBREV
:
9161 case DW_SECT_STR_OFFSETS
:
9163 case DW_SECT_MACINFO
:
9171 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9175 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9176 These sections are extensions for Fission.
9177 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9180 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9182 unsigned char *phdr
= section
->start
;
9183 unsigned char *limit
= phdr
+ section
->size
;
9184 unsigned char *phash
;
9185 unsigned char *pindex
;
9186 unsigned char *ppool
;
9187 unsigned int version
;
9188 unsigned int ncols
= 0;
9190 unsigned int nslots
;
9193 dwarf_vma signature_high
;
9194 dwarf_vma signature_low
;
9197 /* PR 17512: file: 002-168123-0.004. */
9200 warn (_("Section %s is empty\n"), section
->name
);
9203 /* PR 17512: file: 002-376-0.004. */
9204 if (section
->size
< 24)
9206 warn (_("Section %s is too small to contain a CU/TU header\n"),
9211 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9213 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9214 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9215 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9218 pindex
= phash
+ nslots
* 8;
9219 ppool
= pindex
+ nslots
* 4;
9221 /* PR 17531: file: 45d69832. */
9222 if (pindex
< phash
|| ppool
< phdr
|| (pindex
== phash
&& nslots
!= 0))
9224 warn (ngettext ("Section %s is too small for %d slot\n",
9225 "Section %s is too small for %d slots\n",
9227 section
->name
, nslots
);
9233 introduce (section
, FALSE
);
9235 printf (_(" Version: %d\n"), version
);
9237 printf (_(" Number of columns: %d\n"), ncols
);
9238 printf (_(" Number of used entries: %d\n"), nused
);
9239 printf (_(" Number of slots: %d\n\n"), nslots
);
9242 if (ppool
> limit
|| ppool
< phdr
)
9244 warn (_("Section %s too small for %d hash table entries\n"),
9245 section
->name
, nslots
);
9252 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9253 for (i
= 0; i
< nslots
; i
++)
9255 unsigned char *shndx_list
;
9258 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9259 if (signature_high
!= 0 || signature_low
!= 0)
9261 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9262 shndx_list
= ppool
+ j
* 4;
9263 /* PR 17531: file: 705e010d. */
9264 if (shndx_list
< ppool
)
9266 warn (_("Section index pool located before start of section\n"));
9271 printf (_(" [%3d] Signature: 0x%s Sections: "),
9272 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9273 buf
, sizeof (buf
)));
9276 if (shndx_list
>= limit
)
9278 warn (_("Section %s too small for shndx pool\n"),
9282 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9286 printf (" %d", shndx
);
9288 add_shndx_to_cu_tu_entry (shndx
);
9300 else if (version
== 2)
9303 unsigned int dw_sect
;
9304 unsigned char *ph
= phash
;
9305 unsigned char *pi
= pindex
;
9306 unsigned char *poffsets
= ppool
+ ncols
* 4;
9307 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
9308 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
9309 bfd_boolean is_tu_index
;
9310 struct cu_tu_set
*this_set
= NULL
;
9312 unsigned char *prow
;
9314 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9316 /* PR 17531: file: 0dd159bf.
9317 Check for wraparound with an overlarge ncols value. */
9318 if (poffsets
< ppool
|| (unsigned int) ((poffsets
- ppool
) / 4) != ncols
)
9320 warn (_("Overlarge number of columns: %x\n"), ncols
);
9326 warn (_("Section %s too small for offset and size tables\n"),
9333 printf (_(" Offset table\n"));
9334 printf (" slot %-16s ",
9335 is_tu_index
? _("signature") : _("dwo_id"));
9342 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9348 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9355 for (j
= 0; j
< ncols
; j
++)
9357 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9358 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9363 for (i
= 0; i
< nslots
; i
++)
9365 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9367 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9370 /* PR 17531: file: a05f6ab3. */
9373 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9380 size_t num_copy
= sizeof (uint64_t);
9382 /* PR 23064: Beware of buffer overflow. */
9383 if (ph
+ num_copy
< limit
)
9384 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
9387 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
9392 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9393 /* PR 17531: file: b8ce60a8. */
9394 if (prow
< poffsets
|| prow
> limit
)
9396 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9402 printf (_(" [%3d] 0x%s"),
9403 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9404 buf
, sizeof (buf
)));
9405 for (j
= 0; j
< ncols
; j
++)
9407 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9409 printf (" %8d", val
);
9412 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9414 /* PR 17531: file: 10796eb3. */
9415 if (dw_sect
>= DW_SECT_MAX
)
9416 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9418 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9434 printf (_(" Size table\n"));
9435 printf (" slot %-16s ",
9436 is_tu_index
? _("signature") : _("dwo_id"));
9439 for (j
= 0; j
< ncols
; j
++)
9441 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9443 printf (" %8s", get_DW_SECT_short_name (val
));
9449 for (i
= 0; i
< nslots
; i
++)
9451 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9453 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9456 prow
= psizes
+ (row
- 1) * ncols
* 4;
9459 printf (_(" [%3d] 0x%s"),
9460 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9461 buf
, sizeof (buf
)));
9463 for (j
= 0; j
< ncols
; j
++)
9465 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9467 printf (" %8d", val
);
9470 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9471 if (dw_sect
>= DW_SECT_MAX
)
9472 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9474 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9486 else if (do_display
)
9487 printf (_(" Unsupported version (%d)\n"), version
);
9495 /* Load the CU and TU indexes if present. This will build a list of
9496 section sets that we can use to associate a .debug_info.dwo section
9497 with its associated .debug_abbrev.dwo section in a .dwp file. */
9500 load_cu_tu_indexes (void *file
)
9502 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
9504 /* If we have already loaded (or tried to load) the CU and TU indexes
9505 then do not bother to repeat the task. */
9506 if (cu_tu_indexes_read
== -1)
9508 cu_tu_indexes_read
= TRUE
;
9510 if (load_debug_section_with_follow (dwp_cu_index
, file
))
9511 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
9512 cu_tu_indexes_read
= FALSE
;
9514 if (load_debug_section_with_follow (dwp_tu_index
, file
))
9515 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
9516 cu_tu_indexes_read
= FALSE
;
9519 return (bfd_boolean
) cu_tu_indexes_read
;
9522 /* Find the set of sections that includes section SHNDX. */
9525 find_cu_tu_set (void *file
, unsigned int shndx
)
9529 if (! load_cu_tu_indexes (file
))
9532 /* Find SHNDX in the shndx pool. */
9533 for (i
= 0; i
< shndx_pool_used
; i
++)
9534 if (shndx_pool
[i
] == shndx
)
9537 if (i
>= shndx_pool_used
)
9540 /* Now backup to find the first entry in the set. */
9541 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9544 return shndx_pool
+ i
;
9547 /* Display a .debug_cu_index or .debug_tu_index section. */
9550 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9552 return process_cu_tu_index (section
, 1);
9556 display_debug_not_supported (struct dwarf_section
*section
,
9557 void *file ATTRIBUTE_UNUSED
)
9559 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9565 /* Like malloc, but takes two parameters like calloc.
9566 Verifies that the first parameter is not too large.
9567 Note: does *not* initialise the allocated memory to zero. */
9570 cmalloc (size_t nmemb
, size_t size
)
9572 /* Check for overflow. */
9573 if (nmemb
>= ~(size_t) 0 / size
)
9576 return xmalloc (nmemb
* size
);
9579 /* Like xmalloc, but takes two parameters like calloc.
9580 Verifies that the first parameter is not too large.
9581 Note: does *not* initialise the allocated memory to zero. */
9584 xcmalloc (size_t nmemb
, size_t size
)
9586 /* Check for overflow. */
9587 if (nmemb
>= ~(size_t) 0 / size
)
9590 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9595 return xmalloc (nmemb
* size
);
9598 /* Like xrealloc, but takes three parameters.
9599 Verifies that the second parameter is not too large.
9600 Note: does *not* initialise any new memory to zero. */
9603 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9605 /* Check for overflow. */
9606 if (nmemb
>= ~(size_t) 0 / size
)
9608 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9613 return xrealloc (ptr
, nmemb
* size
);
9616 /* Like xcalloc, but verifies that the first parameter is not too large. */
9619 xcalloc2 (size_t nmemb
, size_t size
)
9621 /* Check for overflow. */
9622 if (nmemb
>= ~(size_t) 0 / size
)
9624 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9629 return xcalloc (nmemb
, size
);
9632 static unsigned long
9633 calc_gnu_debuglink_crc32 (unsigned long crc
,
9634 const unsigned char * buf
,
9637 static const unsigned long crc32_table
[256] =
9639 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
9640 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
9641 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
9642 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
9643 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
9644 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
9645 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
9646 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
9647 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
9648 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
9649 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
9650 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
9651 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
9652 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
9653 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
9654 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
9655 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
9656 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
9657 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
9658 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
9659 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
9660 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
9661 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
9662 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
9663 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
9664 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
9665 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
9666 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
9667 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
9668 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
9669 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
9670 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
9671 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
9672 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
9673 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
9674 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
9675 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
9676 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
9677 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
9678 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
9679 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
9680 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
9681 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
9682 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
9683 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
9684 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
9685 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
9686 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
9687 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
9688 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
9689 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
9692 const unsigned char *end
;
9694 crc
= ~crc
& 0xffffffff;
9695 for (end
= buf
+ len
; buf
< end
; ++ buf
)
9696 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
9697 return ~crc
& 0xffffffff;
9700 typedef bfd_boolean (* check_func_type
) (const char *, void *);
9701 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
9704 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
9706 static unsigned char buffer
[8 * 1024];
9708 bfd_size_type count
;
9709 unsigned long crc
= 0;
9712 sep_data
= open_debug_file (pathname
);
9713 if (sep_data
== NULL
)
9716 /* Yes - we are opening the file twice... */
9717 f
= fopen (pathname
, "rb");
9720 /* Paranoia: This should never happen. */
9721 close_debug_file (sep_data
);
9722 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
9726 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
9727 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
9731 if (crc
!= * (unsigned long *) crc_pointer
)
9733 close_debug_file (sep_data
);
9734 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
9743 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
9746 unsigned int crc_offset
;
9747 unsigned long * crc32
= (unsigned long *) data
;
9749 /* The name is first.
9750 The CRC value is stored after the filename, aligned up to 4 bytes. */
9751 name
= (const char *) section
->start
;
9753 crc_offset
= strnlen (name
, section
->size
) + 1;
9754 crc_offset
= (crc_offset
+ 3) & ~3;
9755 if (crc_offset
+ 4 > section
->size
)
9758 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
9763 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
9765 void * sep_data
= open_debug_file (filename
);
9767 if (sep_data
== NULL
)
9770 /* FIXME: We should now extract the build-id in the separate file
9776 typedef struct build_id_data
9779 const unsigned char * data
;
9783 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
9786 bfd_size_type namelen
;
9787 bfd_size_type id_len
;
9788 Build_id_data
* build_id_data
;
9790 /* The name is first.
9791 The build-id follows immediately, with no padding, up to the section's end. */
9793 name
= (const char *) section
->start
;
9794 namelen
= strnlen (name
, section
->size
) + 1;
9795 if (namelen
>= section
->size
)
9798 id_len
= section
->size
- namelen
;
9802 build_id_data
= calloc (1, sizeof * build_id_data
);
9803 if (build_id_data
== NULL
)
9806 build_id_data
->len
= id_len
;
9807 build_id_data
->data
= section
->start
+ namelen
;
9809 * (Build_id_data
**) data
= build_id_data
;
9815 load_separate_debug_info (const char * main_filename
,
9816 struct dwarf_section
* xlink
,
9817 parse_func_type parse_func
,
9818 check_func_type check_func
,
9821 const char * separate_filename
;
9824 size_t canon_dirlen
;
9827 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
9829 warn (_("Corrupt debuglink section: %s\n"),
9830 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
9834 /* Attempt to locate the separate file.
9835 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
9837 canon_dir
= lrealpath (main_filename
);
9839 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
9840 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
9842 canon_dir
[canon_dirlen
] = '\0';
9845 #define DEBUGDIR "/lib/debug"
9847 #ifndef EXTRA_DEBUG_ROOT1
9848 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
9850 #ifndef EXTRA_DEBUG_ROOT2
9851 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
9854 debugfile
= (char *) malloc (strlen (DEBUGDIR
) + 1
9856 + strlen (".debug/")
9857 #ifdef EXTRA_DEBUG_ROOT1
9858 + strlen (EXTRA_DEBUG_ROOT1
)
9860 #ifdef EXTRA_DEBUG_ROOT2
9861 + strlen (EXTRA_DEBUG_ROOT2
)
9863 + strlen (separate_filename
)
9865 if (debugfile
== NULL
)
9867 warn (_("Out of memory"));
9872 /* First try in the current directory. */
9873 sprintf (debugfile
, "%s", separate_filename
);
9874 if (check_func (debugfile
, func_data
))
9877 /* Then try in a subdirectory called .debug. */
9878 sprintf (debugfile
, ".debug/%s", separate_filename
);
9879 if (check_func (debugfile
, func_data
))
9882 /* Then try in the same directory as the original file. */
9883 sprintf (debugfile
, "%s%s", canon_dir
, separate_filename
);
9884 if (check_func (debugfile
, func_data
))
9887 /* And the .debug subdirectory of that directory. */
9888 sprintf (debugfile
, "%s.debug/%s", canon_dir
, separate_filename
);
9889 if (check_func (debugfile
, func_data
))
9892 #ifdef EXTRA_DEBUG_ROOT1
9893 /* Try the first extra debug file root. */
9894 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
9895 if (check_func (debugfile
, func_data
))
9899 #ifdef EXTRA_DEBUG_ROOT2
9900 /* Try the second extra debug file root. */
9901 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
9902 if (check_func (debugfile
, func_data
))
9906 /* Then try in the global debugfile directory. */
9907 strcpy (debugfile
, DEBUGDIR
);
9908 dirlen
= strlen (DEBUGDIR
) - 1;
9909 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
9910 strcat (debugfile
, "/");
9911 strcat (debugfile
, (const char *) separate_filename
);
9913 if (check_func (debugfile
, func_data
))
9916 /* Failed to find the file. */
9917 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
9918 warn (_("tried: %s\n"), debugfile
);
9920 #ifdef EXTRA_DEBUG_ROOT2
9921 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
9922 warn (_("tried: %s\n"), debugfile
);
9925 #ifdef EXTRA_DEBUG_ROOT1
9926 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
9927 warn (_("tried: %s\n"), debugfile
);
9930 sprintf (debugfile
, "%s.debug/%s", canon_dir
, separate_filename
);
9931 warn (_("tried: %s\n"), debugfile
);
9933 sprintf (debugfile
, "%s%s", canon_dir
, separate_filename
);
9934 warn (_("tried: %s\n"), debugfile
);
9936 sprintf (debugfile
, ".debug/%s", separate_filename
);
9937 warn (_("tried: %s\n"), debugfile
);
9939 sprintf (debugfile
, "%s", separate_filename
);
9940 warn (_("tried: %s\n"), debugfile
);
9949 /* Now open the file.... */
9950 if ((separate_debug_file
= open_debug_file (debugfile
)) == NULL
)
9952 warn (_("failed to open separate debug file: %s\n"), debugfile
);
9957 /* FIXME: We do not check to see if there are any other separate debug info
9958 files that would also match. */
9960 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debugfile
);
9961 separate_debug_filename
= debugfile
;
9963 /* Do not free debugfile - it might be referenced inside
9964 the structure returned by open_debug_file(). */
9965 return separate_debug_file
;
9968 /* Attempt to load a separate dwarf object file. */
9971 load_dwo_file (const char * main_filename
)
9975 /* FIXME: Skip adding / if dwo_dir ends in /. */
9976 filename
= concat (dwo_dir
, "/", dwo_name
, NULL
);
9977 if (filename
== NULL
)
9979 warn (_("Out of memory allocating dwo filename\n"));
9983 if ((separate_debug_file
= open_debug_file (filename
)) == NULL
)
9985 warn (_("Unable to load dwo file: %s\n"), filename
);
9990 /* FIXME: We should check the dwo_id. */
9992 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, filename
);
9993 separate_debug_filename
= filename
;
9994 return separate_debug_file
;
9997 /* Load a separate debug info file, if it exists.
9998 Returns the data pointer that is the result of calling open_debug_file
9999 on the separate debug info file, or NULL if there were problems or there
10000 is no such file. */
10003 load_separate_debug_file (void * file
, const char * filename
)
10005 /* Skip this operation if we are not interested in debug links. */
10006 if (! do_follow_links
&& ! do_debug_links
)
10009 /* See if there is a dwo link. */
10010 if (load_debug_section (str
, file
)
10011 && load_debug_section (abbrev
, file
)
10012 && load_debug_section (info
, file
))
10014 dwo_name
= dwo_dir
= NULL
;
10018 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
10020 if (dwo_name
!= NULL
)
10022 if (do_debug_links
)
10024 printf (_("The %s section contains a link to a dwo file:\n"),
10025 debug_displays
[info
].section
.uncompressed_name
);
10026 printf (_(" Name: %s\n"), dwo_name
);
10027 printf (_(" Directory: %s\n"), dwo_dir
? dwo_dir
: _("<not-found>"));
10028 if (dwo_id
!= NULL
)
10029 display_data (printf (_(" ID: ")), dwo_id
, dwo_id_len
);
10031 printf (_(" ID: <unknown>\n"));
10035 /* FIXME: We do not check to see if there are any more dwo links in the file... */
10036 if (do_follow_links
)
10037 return load_dwo_file (filename
);
10042 if (! do_follow_links
)
10043 /* The other debug links will be displayed by display_debug_links()
10044 so we do not need to do any further processing here. */
10047 /* FIXME: We do not check for the presence of both link sections in the same file. */
10048 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
10049 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
10050 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
10052 if (load_debug_section (gnu_debugaltlink
, file
))
10054 Build_id_data
* build_id_data
;
10056 return load_separate_debug_info (filename
,
10057 & debug_displays
[gnu_debugaltlink
].section
,
10058 parse_gnu_debugaltlink
,
10059 check_gnu_debugaltlink
,
10063 if (load_debug_section (gnu_debuglink
, file
))
10065 unsigned long crc32
;
10067 return load_separate_debug_info (filename
,
10068 & debug_displays
[gnu_debuglink
].section
,
10069 parse_gnu_debuglink
,
10070 check_gnu_debuglink
,
10074 do_follow_links
= 0;
10079 free_debug_memory (void)
10085 for (i
= 0; i
< max
; i
++)
10086 free_debug_section ((enum dwarf_section_display_enum
) i
);
10088 if (debug_information
!= NULL
)
10090 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
10092 for (i
= 0; i
< num_debug_info_entries
; i
++)
10094 if (!debug_information
[i
].max_loc_offsets
)
10096 free (debug_information
[i
].loc_offsets
);
10097 free (debug_information
[i
].have_frame_base
);
10099 if (!debug_information
[i
].max_range_lists
)
10100 free (debug_information
[i
].range_lists
);
10103 free (debug_information
);
10104 debug_information
= NULL
;
10105 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10108 if (separate_debug_file
!= NULL
)
10110 close_debug_file (separate_debug_file
);
10111 separate_debug_file
= NULL
;
10113 free ((void *) separate_debug_filename
);
10114 separate_debug_filename
= NULL
;
10119 dwarf_select_sections_by_names (const char *names
)
10123 const char * option
;
10127 debug_dump_long_opts
;
10129 static const debug_dump_long_opts opts_table
[] =
10131 /* Please keep this table alpha- sorted. */
10132 { "Ranges", & do_debug_ranges
, 1 },
10133 { "abbrev", & do_debug_abbrevs
, 1 },
10134 { "addr", & do_debug_addr
, 1 },
10135 { "aranges", & do_debug_aranges
, 1 },
10136 { "cu_index", & do_debug_cu_index
, 1 },
10137 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10138 { "follow-links", & do_follow_links
, 1 },
10139 { "frames", & do_debug_frames
, 1 },
10140 { "frames-interp", & do_debug_frames_interp
, 1 },
10141 /* The special .gdb_index section. */
10142 { "gdb_index", & do_gdb_index
, 1 },
10143 { "info", & do_debug_info
, 1 },
10144 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10145 { "links", & do_debug_links
, 1 },
10146 { "loc", & do_debug_loc
, 1 },
10147 { "macro", & do_debug_macinfo
, 1 },
10148 { "pubnames", & do_debug_pubnames
, 1 },
10149 { "pubtypes", & do_debug_pubtypes
, 1 },
10150 /* This entry is for compatibility
10151 with earlier versions of readelf. */
10152 { "ranges", & do_debug_aranges
, 1 },
10153 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10154 { "str", & do_debug_str
, 1 },
10155 /* These trace_* sections are used by Itanium VMS. */
10156 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10157 { "trace_aranges", & do_trace_aranges
, 1 },
10158 { "trace_info", & do_trace_info
, 1 },
10167 const debug_dump_long_opts
* entry
;
10169 for (entry
= opts_table
; entry
->option
; entry
++)
10171 size_t len
= strlen (entry
->option
);
10173 if (strncmp (p
, entry
->option
, len
) == 0
10174 && (p
[len
] == ',' || p
[len
] == '\0'))
10176 * entry
->variable
|= entry
->val
;
10178 /* The --debug-dump=frames-interp option also
10179 enables the --debug-dump=frames option. */
10180 if (do_debug_frames_interp
)
10181 do_debug_frames
= 1;
10188 if (entry
->option
== NULL
)
10190 warn (_("Unrecognized debug option '%s'\n"), p
);
10191 p
= strchr (p
, ',');
10202 dwarf_select_sections_by_letters (const char *letters
)
10204 unsigned int lindex
= 0;
10206 while (letters
[lindex
])
10207 switch (letters
[lindex
++])
10209 case 'A': do_debug_addr
= 1; break;
10210 case 'a': do_debug_abbrevs
= 1; break;
10211 case 'c': do_debug_cu_index
= 1; break;
10212 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10213 case 'f': do_debug_frames
= 1; break;
10214 case 'g': do_gdb_index
= 1; break;
10215 case 'i': do_debug_info
= 1; break;
10216 case 'K': do_follow_links
= 1; break;
10217 case 'k': do_debug_links
= 1; break;
10218 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10219 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10220 case 'm': do_debug_macinfo
= 1; break;
10221 case 'o': do_debug_loc
= 1; break;
10222 case 'p': do_debug_pubnames
= 1; break;
10223 case 'R': do_debug_ranges
= 1; break;
10224 case 'r': do_debug_aranges
= 1; break;
10225 case 's': do_debug_str
= 1; break;
10226 case 'T': do_trace_aranges
= 1; break;
10227 case 't': do_debug_pubtypes
= 1; break;
10228 case 'U': do_trace_info
= 1; break;
10229 case 'u': do_trace_abbrevs
= 1; break;
10232 warn (_("Unrecognized debug option '%s'\n"), letters
);
10238 dwarf_select_sections_all (void)
10241 do_debug_abbrevs
= 1;
10242 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10243 do_debug_pubnames
= 1;
10244 do_debug_pubtypes
= 1;
10245 do_debug_aranges
= 1;
10246 do_debug_ranges
= 1;
10247 do_debug_frames
= 1;
10248 do_debug_macinfo
= 1;
10253 do_trace_abbrevs
= 1;
10254 do_trace_aranges
= 1;
10256 do_debug_cu_index
= 1;
10257 do_follow_links
= 1;
10258 do_debug_links
= 1;
10261 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10262 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10264 /* N.B. The order here must match the order in section_display_enum. */
10266 struct dwarf_section_display debug_displays
[] =
10268 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10269 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10270 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10271 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10272 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10273 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10274 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10275 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10276 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10277 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10278 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10279 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10280 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10281 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10282 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10283 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10284 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10285 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10286 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10287 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10288 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10289 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10290 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10291 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10292 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10293 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10294 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10295 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10296 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10297 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10298 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10299 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10300 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10301 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10302 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10303 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10304 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10305 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10306 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10307 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10308 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10309 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10310 /* Separate debug info files can containt their own .debug_str section,
10311 and this might be in *addition* to a .debug_str section already present
10312 in the main file. Hence we need to have two entries for .debug_str. */
10313 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10316 /* A static assertion. */
10317 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];