1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2018 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
));
1579 /* HP extensions. */
1580 case DW_OP_HP_is_value
:
1581 printf ("DW_OP_HP_is_value");
1582 /* FIXME: Is there data associated with this OP ? */
1584 case DW_OP_HP_fltconst4
:
1585 printf ("DW_OP_HP_fltconst4");
1586 /* FIXME: Is there data associated with this OP ? */
1588 case DW_OP_HP_fltconst8
:
1589 printf ("DW_OP_HP_fltconst8");
1590 /* FIXME: Is there data associated with this OP ? */
1592 case DW_OP_HP_mod_range
:
1593 printf ("DW_OP_HP_mod_range");
1594 /* FIXME: Is there data associated with this OP ? */
1596 case DW_OP_HP_unmod_range
:
1597 printf ("DW_OP_HP_unmod_range");
1598 /* FIXME: Is there data associated with this OP ? */
1601 printf ("DW_OP_HP_tls");
1602 /* FIXME: Is there data associated with this OP ? */
1605 /* PGI (STMicroelectronics) extensions. */
1606 case DW_OP_PGI_omp_thread_num
:
1607 /* Pushes the thread number for the current thread as it would be
1608 returned by the standard OpenMP library function:
1609 omp_get_thread_num(). The "current thread" is the thread for
1610 which the expression is being evaluated. */
1611 printf ("DW_OP_PGI_omp_thread_num");
1615 if (op
>= DW_OP_lo_user
1616 && op
<= DW_OP_hi_user
)
1617 printf (_("(User defined location op 0x%x)"), op
);
1619 printf (_("(Unknown location op 0x%x)"), op
);
1620 /* No way to tell where the next op is, so just bail. */
1621 return need_frame_base
;
1624 /* Separate the ops. */
1629 return need_frame_base
;
1632 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1633 This is used for DWARF package files. */
1635 static struct cu_tu_set
*
1636 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1638 struct cu_tu_set
*p
;
1640 unsigned int dw_sect
;
1646 dw_sect
= DW_SECT_TYPES
;
1652 dw_sect
= DW_SECT_INFO
;
1656 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1664 /* Add INC to HIGH_BITS:LOW_BITS. */
1666 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1668 dwarf_vma tmp
= * low_bits
;
1672 /* FIXME: There is probably a better way of handling this:
1674 We need to cope with dwarf_vma being a 32-bit or 64-bit
1675 type. Plus regardless of its size LOW_BITS is meant to
1676 only hold 32-bits, so if there is overflow or wrap around
1677 we must propagate into HIGH_BITS. */
1678 if (tmp
< * low_bits
)
1682 else if (sizeof (tmp
) > 8
1693 fetch_alt_indirect_string (dwarf_vma offset
)
1695 struct dwarf_section
* section
;
1698 if (! do_follow_links
)
1701 if (separate_debug_file
== NULL
)
1702 return _("<following link not possible>");
1704 if (! load_debug_section (separate_debug_str
, separate_debug_file
))
1705 return _("<could not load separate string section>");
1707 section
= &debug_displays
[separate_debug_str
].section
;
1708 if (section
->start
== NULL
)
1709 return _("<no .debug_str section>");
1711 if (offset
>= section
->size
)
1713 warn (_("DW_FORM_GNU_strp_alt offset too big: %s\n"), dwarf_vmatoa ("x", offset
));
1714 return _("<offset is too big>");
1717 ret
= (const char *) (section
->start
+ offset
);
1718 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1719 NUL byte. Since our caller is expecting to receive a well formed C
1720 string we test for the lack of a terminating byte here. */
1721 if (strnlen ((const char *) ret
, section
->size
- offset
)
1722 == section
->size
- offset
)
1723 return _("<no NUL byte at end of .debug_str section>");
1729 get_AT_name (unsigned long attribute
)
1734 return "DW_AT value: 0";
1736 /* One value is shared by the MIPS and HP extensions: */
1737 if (attribute
== DW_AT_MIPS_fde
)
1738 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1740 name
= get_DW_AT_name (attribute
);
1744 static char buffer
[100];
1746 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1754 static unsigned char *
1755 read_and_display_attr_value (unsigned long attribute
,
1757 dwarf_signed_vma implicit_const
,
1758 unsigned char * data
,
1759 unsigned char * end
,
1760 dwarf_vma cu_offset
,
1761 dwarf_vma pointer_size
,
1762 dwarf_vma offset_size
,
1764 debug_info
* debug_info_p
,
1766 struct dwarf_section
* section
,
1767 struct cu_tu_set
* this_set
,
1770 dwarf_vma uvalue
= 0;
1771 unsigned char *block_start
= NULL
;
1772 unsigned char * orig_data
= data
;
1773 unsigned int bytes_read
;
1775 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
1777 warn (_("Corrupt attribute\n"));
1786 case DW_FORM_ref_addr
:
1787 if (dwarf_version
== 2)
1788 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1789 else if (dwarf_version
== 3 || dwarf_version
== 4)
1790 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1792 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1797 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1801 case DW_FORM_line_strp
:
1802 case DW_FORM_sec_offset
:
1803 case DW_FORM_GNU_ref_alt
:
1804 case DW_FORM_GNU_strp_alt
:
1805 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1808 case DW_FORM_flag_present
:
1815 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1820 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1825 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1829 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1833 case DW_FORM_GNU_str_index
:
1834 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1838 case DW_FORM_ref_udata
:
1840 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1844 case DW_FORM_indirect
:
1845 form
= read_uleb128 (data
, & bytes_read
, end
);
1848 printf ("%c%s", delimiter
, get_FORM_name (form
));
1849 if (form
== DW_FORM_implicit_const
)
1851 implicit_const
= read_sleb128 (data
, & bytes_read
, end
);
1854 return read_and_display_attr_value (attribute
, form
, implicit_const
, data
,
1855 end
, cu_offset
, pointer_size
,
1856 offset_size
, dwarf_version
,
1857 debug_info_p
, do_loc
,
1858 section
, this_set
, delimiter
);
1859 case DW_FORM_GNU_addr_index
:
1860 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1867 case DW_FORM_ref_addr
:
1869 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
1872 case DW_FORM_GNU_ref_alt
:
1874 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
1875 /* FIXME: Follow the reference... */
1881 case DW_FORM_ref_udata
:
1883 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1888 case DW_FORM_sec_offset
:
1890 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
1893 case DW_FORM_flag_present
:
1900 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
1903 case DW_FORM_implicit_const
:
1905 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
1912 dwarf_vma high_bits
;
1916 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1918 if (form
== DW_FORM_ref8
)
1919 add64 (& high_bits
, & utmp
, cu_offset
);
1920 printf ("%c0x%s", delimiter
,
1921 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1924 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1925 && num_debug_info_entries
== 0)
1927 if (sizeof (uvalue
) == 8)
1928 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1930 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1936 case DW_FORM_data16
:
1939 dwarf_vma left_high_bits
, left_low_bits
;
1940 dwarf_vma right_high_bits
, right_low_bits
;
1942 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
1943 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
1944 if (byte_get
== byte_get_little_endian
)
1947 left_high_bits
^= right_high_bits
;
1948 right_high_bits
^= left_high_bits
;
1949 left_high_bits
^= right_high_bits
;
1950 left_low_bits
^= right_low_bits
;
1951 right_low_bits
^= left_low_bits
;
1952 left_low_bits
^= right_low_bits
;
1954 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
1955 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
1956 left_high_bits
, left_low_bits
, right_high_bits
,
1962 case DW_FORM_string
:
1964 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
1965 data
+= strnlen ((char *) data
, end
- data
) + 1;
1969 case DW_FORM_exprloc
:
1970 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1971 block_start
= data
+ bytes_read
;
1972 if (block_start
>= end
)
1974 warn (_("Block ends prematurely\n"));
1978 /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1979 gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute
1980 block_start + uvalue here. */
1981 data
= block_start
+ uvalue
;
1982 /* PR 17512: file: 008-103549-0.001:0.1. */
1983 if (block_start
+ uvalue
> end
|| data
< block_start
)
1985 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1986 uvalue
= end
- block_start
;
1989 data
= block_start
+ uvalue
;
1991 data
= display_block (block_start
, uvalue
, end
, delimiter
);
1994 case DW_FORM_block1
:
1995 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1996 block_start
= data
+ 1;
1997 if (block_start
>= end
)
1999 warn (_("Block ends prematurely\n"));
2003 data
= block_start
+ uvalue
;
2004 if (block_start
+ uvalue
> end
|| data
< block_start
)
2006 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
2007 uvalue
= end
- block_start
;
2010 data
= block_start
+ uvalue
;
2012 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2015 case DW_FORM_block2
:
2016 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
2017 block_start
= data
+ 2;
2018 if (block_start
>= end
)
2020 warn (_("Block ends prematurely\n"));
2024 data
= block_start
+ uvalue
;
2025 if (block_start
+ uvalue
> end
|| data
< block_start
)
2027 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
2028 uvalue
= end
- block_start
;
2031 data
= block_start
+ uvalue
;
2033 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2036 case DW_FORM_block4
:
2037 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
2038 block_start
= data
+ 4;
2039 /* PR 17512: file: 3371-3907-0.004. */
2040 if (block_start
>= end
)
2042 warn (_("Block ends prematurely\n"));
2046 data
= block_start
+ uvalue
;
2047 if (block_start
+ uvalue
> end
2048 /* PR 17531: file: 5b5f0592. */
2049 || data
< block_start
)
2051 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
2052 uvalue
= end
- block_start
;
2055 data
= block_start
+ uvalue
;
2057 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2062 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2063 dwarf_vmatoa ("x", uvalue
),
2064 fetch_indirect_string (uvalue
));
2067 case DW_FORM_line_strp
:
2069 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2070 dwarf_vmatoa ("x", uvalue
),
2071 fetch_indirect_line_string (uvalue
));
2074 case DW_FORM_GNU_str_index
:
2077 const char * suffix
= strrchr (section
->name
, '.');
2078 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
2080 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2081 dwarf_vmatoa ("x", uvalue
),
2082 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2086 case DW_FORM_GNU_strp_alt
:
2089 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2090 dwarf_vmatoa ("x", uvalue
),
2091 fetch_alt_indirect_string (uvalue
));
2095 case DW_FORM_indirect
:
2096 /* Handled above. */
2099 case DW_FORM_ref_sig8
:
2102 dwarf_vma high_bits
;
2105 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2106 printf ("%csignature: 0x%s", delimiter
,
2107 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2112 case DW_FORM_GNU_addr_index
:
2114 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2115 dwarf_vmatoa ("x", uvalue
),
2116 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2120 warn (_("Unrecognized form: %lu\n"), form
);
2124 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2125 && num_debug_info_entries
== 0
2126 && debug_info_p
!= NULL
)
2130 case DW_AT_frame_base
:
2131 have_frame_base
= 1;
2133 case DW_AT_location
:
2134 case DW_AT_GNU_locviews
:
2135 case DW_AT_string_length
:
2136 case DW_AT_return_addr
:
2137 case DW_AT_data_member_location
:
2138 case DW_AT_vtable_elem_location
:
2140 case DW_AT_static_link
:
2141 case DW_AT_use_location
:
2142 case DW_AT_call_value
:
2143 case DW_AT_GNU_call_site_value
:
2144 case DW_AT_call_data_value
:
2145 case DW_AT_GNU_call_site_data_value
:
2146 case DW_AT_call_target
:
2147 case DW_AT_GNU_call_site_target
:
2148 case DW_AT_call_target_clobbered
:
2149 case DW_AT_GNU_call_site_target_clobbered
:
2150 if ((dwarf_version
< 4
2151 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2152 || form
== DW_FORM_sec_offset
)
2154 /* Process location list. */
2155 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2156 unsigned int num
= debug_info_p
->num_loc_offsets
;
2158 if (lmax
== 0 || num
>= lmax
)
2161 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2162 xcrealloc (debug_info_p
->loc_offsets
,
2163 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2164 debug_info_p
->loc_views
= (dwarf_vma
*)
2165 xcrealloc (debug_info_p
->loc_views
,
2166 lmax
, sizeof (*debug_info_p
->loc_views
));
2167 debug_info_p
->have_frame_base
= (int *)
2168 xcrealloc (debug_info_p
->have_frame_base
,
2169 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2170 debug_info_p
->max_loc_offsets
= lmax
;
2172 if (this_set
!= NULL
)
2173 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2174 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2175 if (attribute
!= DW_AT_GNU_locviews
)
2177 debug_info_p
->loc_offsets
[num
] = uvalue
;
2178 debug_info_p
->num_loc_offsets
++;
2179 assert (debug_info_p
->num_loc_offsets
2180 - debug_info_p
->num_loc_views
<= 1);
2184 assert (debug_info_p
->num_loc_views
<= num
);
2185 num
= debug_info_p
->num_loc_views
;
2186 debug_info_p
->loc_views
[num
] = uvalue
;
2187 debug_info_p
->num_loc_views
++;
2188 assert (debug_info_p
->num_loc_views
2189 - debug_info_p
->num_loc_offsets
<= 1);
2195 if (need_base_address
)
2196 debug_info_p
->base_address
= uvalue
;
2199 case DW_AT_GNU_addr_base
:
2200 debug_info_p
->addr_base
= uvalue
;
2203 case DW_AT_GNU_ranges_base
:
2204 debug_info_p
->ranges_base
= uvalue
;
2208 if ((dwarf_version
< 4
2209 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2210 || form
== DW_FORM_sec_offset
)
2212 /* Process range list. */
2213 unsigned int lmax
= debug_info_p
->max_range_lists
;
2214 unsigned int num
= debug_info_p
->num_range_lists
;
2216 if (lmax
== 0 || num
>= lmax
)
2219 debug_info_p
->range_lists
= (dwarf_vma
*)
2220 xcrealloc (debug_info_p
->range_lists
,
2221 lmax
, sizeof (*debug_info_p
->range_lists
));
2222 debug_info_p
->max_range_lists
= lmax
;
2224 debug_info_p
->range_lists
[num
] = uvalue
;
2225 debug_info_p
->num_range_lists
++;
2229 case DW_AT_GNU_dwo_name
:
2230 case DW_AT_dwo_name
:
2235 dwo_name
= (const char *) fetch_indirect_string (uvalue
);
2237 case DW_FORM_GNU_str_index
:
2238 dwo_name
= fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
);
2240 case DW_FORM_string
:
2241 dwo_name
= (const char *) orig_data
;
2244 warn (_("Unsupported form (%s) for attribute %s\n"),
2245 get_FORM_name (form
), get_AT_name (attribute
));
2246 dwo_name
= _("<unknown>");
2251 case DW_AT_comp_dir
:
2252 /* FIXME: Also extract a build-id in a CU/TU. */
2257 dwo_dir
= (const char *) fetch_indirect_string (uvalue
);
2259 case DW_FORM_line_strp
:
2260 dwo_dir
= (const char *) fetch_indirect_line_string (uvalue
);
2262 case DW_FORM_GNU_str_index
:
2263 dwo_dir
= fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
);
2265 case DW_FORM_string
:
2266 dwo_dir
= (const char *) orig_data
;
2269 warn (_("Unsupported form (%s) for attribute %s\n"),
2270 get_FORM_name (form
), get_AT_name (attribute
));
2271 dwo_dir
= _("<unknown>");
2276 case DW_AT_GNU_dwo_id
:
2285 warn (_("Unsupported form (%s) for attribute %s\n"),
2286 get_FORM_name (form
), get_AT_name (attribute
));
2297 if (do_loc
|| attribute
== 0)
2300 /* For some attributes we can display further information. */
2307 case DW_INL_not_inlined
:
2308 printf (_("(not inlined)"));
2310 case DW_INL_inlined
:
2311 printf (_("(inlined)"));
2313 case DW_INL_declared_not_inlined
:
2314 printf (_("(declared as inline but ignored)"));
2316 case DW_INL_declared_inlined
:
2317 printf (_("(declared as inline and inlined)"));
2320 printf (_(" (Unknown inline attribute value: %s)"),
2321 dwarf_vmatoa ("x", uvalue
));
2326 case DW_AT_language
:
2330 /* Ordered by the numeric value of these constants. */
2331 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2332 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2333 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2334 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2335 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2336 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2337 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2338 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2339 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2340 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2341 /* DWARF 2.1 values. */
2342 case DW_LANG_Java
: printf ("(Java)"); break;
2343 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2344 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2345 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2346 /* DWARF 3 values. */
2347 case DW_LANG_PLI
: printf ("(PLI)"); break;
2348 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2349 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2350 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2351 case DW_LANG_D
: printf ("(D)"); break;
2352 /* DWARF 4 values. */
2353 case DW_LANG_Python
: printf ("(Python)"); break;
2354 /* DWARF 5 values. */
2355 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
2356 case DW_LANG_Go
: printf ("(Go)"); break;
2357 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
2358 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
2359 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
2360 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2361 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
2362 case DW_LANG_Rust
: printf ("(Rust)"); break;
2363 case DW_LANG_C11
: printf ("(C11)"); break;
2364 case DW_LANG_Swift
: printf ("(Swift)"); break;
2365 case DW_LANG_Julia
: printf ("(Julia)"); break;
2366 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
2367 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2368 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2369 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2370 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
2371 /* MIPS extension. */
2372 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2373 /* UPC extension. */
2374 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2376 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2377 printf (_("(implementation defined: %s)"),
2378 dwarf_vmatoa ("x", uvalue
));
2380 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2385 case DW_AT_encoding
:
2389 case DW_ATE_void
: printf ("(void)"); break;
2390 case DW_ATE_address
: printf ("(machine address)"); break;
2391 case DW_ATE_boolean
: printf ("(boolean)"); break;
2392 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2393 case DW_ATE_float
: printf ("(float)"); break;
2394 case DW_ATE_signed
: printf ("(signed)"); break;
2395 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2396 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2397 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2398 /* DWARF 2.1 values: */
2399 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2400 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2401 /* DWARF 3 values: */
2402 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2403 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2404 case DW_ATE_edited
: printf ("(edited)"); break;
2405 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2406 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2407 /* DWARF 4 values: */
2408 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2409 /* DWARF 5 values: */
2410 case DW_ATE_UCS
: printf ("(UCS)"); break;
2411 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2413 /* HP extensions: */
2414 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2415 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2416 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2417 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2418 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2419 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2420 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2423 if (uvalue
>= DW_ATE_lo_user
2424 && uvalue
<= DW_ATE_hi_user
)
2425 printf (_("(user defined type)"));
2427 printf (_("(unknown type)"));
2432 case DW_AT_accessibility
:
2436 case DW_ACCESS_public
: printf ("(public)"); break;
2437 case DW_ACCESS_protected
: printf ("(protected)"); break;
2438 case DW_ACCESS_private
: printf ("(private)"); break;
2440 printf (_("(unknown accessibility)"));
2445 case DW_AT_visibility
:
2449 case DW_VIS_local
: printf ("(local)"); break;
2450 case DW_VIS_exported
: printf ("(exported)"); break;
2451 case DW_VIS_qualified
: printf ("(qualified)"); break;
2452 default: printf (_("(unknown visibility)")); break;
2456 case DW_AT_endianity
:
2460 case DW_END_default
: printf ("(default)"); break;
2461 case DW_END_big
: printf ("(big)"); break;
2462 case DW_END_little
: printf ("(little)"); break;
2464 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2465 printf (_("(user specified)"));
2467 printf (_("(unknown endianity)"));
2472 case DW_AT_virtuality
:
2476 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2477 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2478 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2479 default: printf (_("(unknown virtuality)")); break;
2483 case DW_AT_identifier_case
:
2487 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2488 case DW_ID_up_case
: printf ("(up_case)"); break;
2489 case DW_ID_down_case
: printf ("(down_case)"); break;
2490 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2491 default: printf (_("(unknown case)")); break;
2495 case DW_AT_calling_convention
:
2499 case DW_CC_normal
: printf ("(normal)"); break;
2500 case DW_CC_program
: printf ("(program)"); break;
2501 case DW_CC_nocall
: printf ("(nocall)"); break;
2502 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2503 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2504 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2505 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2507 if (uvalue
>= DW_CC_lo_user
2508 && uvalue
<= DW_CC_hi_user
)
2509 printf (_("(user defined)"));
2511 printf (_("(unknown convention)"));
2515 case DW_AT_ordering
:
2520 case -1: printf (_("(undefined)")); break;
2521 case 0: printf ("(row major)"); break;
2522 case 1: printf ("(column major)"); break;
2526 case DW_AT_decimal_sign
:
2530 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2531 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2532 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2533 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2534 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2535 default: printf (_("(unrecognised)")); break;
2539 case DW_AT_defaulted
:
2543 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2544 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2545 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2546 default: printf (_("(unrecognised)")); break;
2550 case DW_AT_discr_list
:
2554 case DW_DSC_label
: printf (_("(label)")); break;
2555 case DW_DSC_range
: printf (_("(range)")); break;
2556 default: printf (_("(unrecognised)")); break;
2560 case DW_AT_frame_base
:
2561 have_frame_base
= 1;
2563 case DW_AT_location
:
2564 case DW_AT_string_length
:
2565 case DW_AT_return_addr
:
2566 case DW_AT_data_member_location
:
2567 case DW_AT_vtable_elem_location
:
2569 case DW_AT_static_link
:
2570 case DW_AT_use_location
:
2571 case DW_AT_call_value
:
2572 case DW_AT_GNU_call_site_value
:
2573 case DW_AT_call_data_value
:
2574 case DW_AT_GNU_call_site_data_value
:
2575 case DW_AT_call_target
:
2576 case DW_AT_GNU_call_site_target
:
2577 case DW_AT_call_target_clobbered
:
2578 case DW_AT_GNU_call_site_target_clobbered
:
2579 if ((dwarf_version
< 4
2580 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2581 || form
== DW_FORM_sec_offset
)
2582 printf (_(" (location list)"));
2584 case DW_AT_allocated
:
2585 case DW_AT_associated
:
2586 case DW_AT_data_location
:
2588 case DW_AT_upper_bound
:
2589 case DW_AT_lower_bound
:
2592 int need_frame_base
;
2595 need_frame_base
= decode_location_expression (block_start
,
2600 cu_offset
, section
);
2602 if (need_frame_base
&& !have_frame_base
)
2603 printf (_(" [without DW_AT_frame_base]"));
2607 case DW_AT_data_bit_offset
:
2608 case DW_AT_byte_size
:
2609 case DW_AT_bit_size
:
2610 case DW_AT_string_length_byte_size
:
2611 case DW_AT_string_length_bit_size
:
2612 case DW_AT_bit_stride
:
2613 if (form
== DW_FORM_exprloc
)
2616 (void) decode_location_expression (block_start
, pointer_size
,
2617 offset_size
, dwarf_version
,
2618 uvalue
, cu_offset
, section
);
2625 if (form
== DW_FORM_ref_sig8
2626 || form
== DW_FORM_GNU_ref_alt
)
2629 if (form
== DW_FORM_ref1
2630 || form
== DW_FORM_ref2
2631 || form
== DW_FORM_ref4
2632 || form
== DW_FORM_ref_udata
)
2633 uvalue
+= cu_offset
;
2635 if (uvalue
>= section
->size
)
2636 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2637 dwarf_vmatoa ("x", uvalue
),
2638 (unsigned long) (orig_data
- section
->start
));
2641 unsigned long abbrev_number
;
2642 abbrev_entry
* entry
;
2644 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2646 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2647 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2648 use different abbrev table, and we don't track .debug_info chunks
2650 if (form
!= DW_FORM_ref_addr
)
2652 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2653 if (entry
->entry
== abbrev_number
)
2656 printf (" (%s)", get_TAG_name (entry
->tag
));
2670 static unsigned char *
2671 read_and_display_attr (unsigned long attribute
,
2673 dwarf_signed_vma implicit_const
,
2674 unsigned char * data
,
2675 unsigned char * end
,
2676 dwarf_vma cu_offset
,
2677 dwarf_vma pointer_size
,
2678 dwarf_vma offset_size
,
2680 debug_info
* debug_info_p
,
2682 struct dwarf_section
* section
,
2683 struct cu_tu_set
* this_set
)
2686 printf (" %-18s:", get_AT_name (attribute
));
2687 data
= read_and_display_attr_value (attribute
, form
, implicit_const
, data
, end
,
2688 cu_offset
, pointer_size
, offset_size
,
2689 dwarf_version
, debug_info_p
,
2690 do_loc
, section
, this_set
, ' ');
2696 /* Like load_debug_section, but if the ordinary call fails, and we are
2697 following debug links, and we have been able to load a separate debug
2698 info file, then attempt to load the requested section from the separate
2702 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
2705 if (load_debug_section (sec_enum
, data
))
2707 if (data
== separate_debug_file
)
2708 debug_displays
[sec_enum
].section
.filename
= separate_debug_filename
;
2710 /* FIXME: We should check to see if there is a separate debug info file
2711 that also contains this section, and if so, issue a warning. */
2715 if (do_follow_links
&& separate_debug_file
!= NULL
)
2716 if (load_debug_section (sec_enum
, separate_debug_file
))
2718 debug_displays
[sec_enum
].section
.filename
= separate_debug_filename
;
2726 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
2730 if (do_follow_links
&& section
->filename
)
2731 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
2732 section
->name
, section
->filename
);
2734 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
2738 if (do_follow_links
&& section
->filename
)
2739 printf (_("Contents of the %s section (loaded from %s):\n\n"),
2740 section
->name
, section
->filename
);
2742 printf (_("Contents of the %s section:\n\n"), section
->name
);
2746 /* Process the contents of a .debug_info section.
2747 If do_loc is TRUE then we are scanning for location lists and dwo tags
2748 and we do not want to display anything to the user.
2749 If do_types is TRUE, we are processing a .debug_types section instead of
2750 a .debug_info section.
2751 The information displayed is restricted by the values in DWARF_START_DIE
2752 and DWARF_CUTOFF_LEVEL.
2753 Returns TRUE upon success. Otherwise an error or warning message is
2754 printed and FALSE is returned. */
2757 process_debug_info (struct dwarf_section
* section
,
2759 enum dwarf_section_display_enum abbrev_sec
,
2761 bfd_boolean do_types
)
2763 unsigned char *start
= section
->start
;
2764 unsigned char *end
= start
+ section
->size
;
2765 unsigned char *section_begin
;
2767 unsigned int num_units
= 0;
2769 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2770 && num_debug_info_entries
== 0
2775 /* First scan the section to get the number of comp units. */
2776 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2779 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2780 will be the length. For a 64-bit DWARF section, it'll be
2781 the escape code 0xffffffff followed by an 8 byte length. */
2782 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2784 if (length
== 0xffffffff)
2786 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2787 section_begin
+= length
+ 12;
2789 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2791 warn (_("Reserved length value (0x%s) found in section %s\n"),
2792 dwarf_vmatoa ("x", length
), section
->name
);
2796 section_begin
+= length
+ 4;
2798 /* Negative values are illegal, they may even cause infinite
2799 looping. This can happen if we can't accurately apply
2800 relocations to an object file, or if the file is corrupt. */
2801 if ((signed long) length
<= 0 || section_begin
< start
)
2803 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2804 dwarf_vmatoa ("x", length
), section
->name
);
2811 error (_("No comp units in %s section ?\n"), section
->name
);
2815 /* Then allocate an array to hold the information. */
2816 debug_information
= (debug_info
*) cmalloc (num_units
,
2817 sizeof (* debug_information
));
2818 if (debug_information
== NULL
)
2820 error (_("Not enough memory for a debug info array of %u entries\n"),
2822 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
2826 /* PR 17531: file: 92ca3797.
2827 We cannot rely upon the debug_information array being initialised
2828 before it is used. A corrupt file could easily contain references
2829 to a unit for which information has not been made available. So
2830 we ensure that the array is zeroed here. */
2831 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
2833 alloc_num_debug_info_entries
= num_units
;
2838 load_debug_section_with_follow (str
, file
);
2839 load_debug_section_with_follow (line_str
, file
);
2840 load_debug_section_with_follow (str_dwo
, file
);
2841 load_debug_section_with_follow (str_index
, file
);
2842 load_debug_section_with_follow (str_index_dwo
, file
);
2843 load_debug_section_with_follow (debug_addr
, file
);
2846 load_debug_section_with_follow (abbrev_sec
, file
);
2847 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2849 warn (_("Unable to locate %s section!\n"),
2850 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
2854 if (!do_loc
&& dwarf_start_die
== 0)
2855 introduce (section
, FALSE
);
2857 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2859 DWARF2_Internal_CompUnit compunit
;
2860 unsigned char *hdrptr
;
2861 unsigned char *tags
;
2862 int level
, last_level
, saved_level
;
2863 dwarf_vma cu_offset
;
2864 unsigned long sec_off
;
2865 unsigned int offset_size
;
2866 unsigned int initial_length_size
;
2867 dwarf_vma signature_high
= 0;
2868 dwarf_vma signature_low
= 0;
2869 dwarf_vma type_offset
= 0;
2870 struct cu_tu_set
*this_set
;
2871 dwarf_vma abbrev_base
;
2876 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2878 if (compunit
.cu_length
== 0xffffffff)
2880 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2882 initial_length_size
= 12;
2887 initial_length_size
= 4;
2890 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2892 cu_offset
= start
- section_begin
;
2894 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2896 if (compunit
.cu_version
< 5)
2898 compunit
.cu_unit_type
= DW_UT_compile
;
2899 /* Initialize it due to a false compiler warning. */
2900 compunit
.cu_pointer_size
= -1;
2904 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
2905 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
2907 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2910 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2912 if (this_set
== NULL
)
2915 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2919 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2920 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2923 if (compunit
.cu_version
< 5)
2924 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2926 /* PR 17512: file: 001-108546-0.001:0.1. */
2927 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2929 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2930 compunit
.cu_pointer_size
, offset_size
);
2931 compunit
.cu_pointer_size
= offset_size
;
2936 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2938 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2941 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
2942 + initial_length_size
))
2944 start
= section_begin
+ cu_offset
+ compunit
.cu_length
2945 + initial_length_size
;
2949 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2950 && num_debug_info_entries
== 0
2953 debug_information
[unit
].cu_offset
= cu_offset
;
2954 debug_information
[unit
].pointer_size
2955 = compunit
.cu_pointer_size
;
2956 debug_information
[unit
].offset_size
= offset_size
;
2957 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2958 debug_information
[unit
].base_address
= 0;
2959 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2960 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2961 debug_information
[unit
].loc_offsets
= NULL
;
2962 debug_information
[unit
].have_frame_base
= NULL
;
2963 debug_information
[unit
].max_loc_offsets
= 0;
2964 debug_information
[unit
].num_loc_offsets
= 0;
2965 debug_information
[unit
].range_lists
= NULL
;
2966 debug_information
[unit
].max_range_lists
= 0;
2967 debug_information
[unit
].num_range_lists
= 0;
2970 if (!do_loc
&& dwarf_start_die
== 0)
2972 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2973 dwarf_vmatoa ("x", cu_offset
));
2974 printf (_(" Length: 0x%s (%s)\n"),
2975 dwarf_vmatoa ("x", compunit
.cu_length
),
2976 offset_size
== 8 ? "64-bit" : "32-bit");
2977 printf (_(" Version: %d\n"), compunit
.cu_version
);
2978 printf (_(" Abbrev Offset: 0x%s\n"),
2979 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2980 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2985 printf (_(" Signature: 0x%s\n"),
2986 dwarf_vmatoa64 (signature_high
, signature_low
,
2987 buf
, sizeof (buf
)));
2988 printf (_(" Type Offset: 0x%s\n"),
2989 dwarf_vmatoa ("x", type_offset
));
2991 if (this_set
!= NULL
)
2993 dwarf_vma
*offsets
= this_set
->section_offsets
;
2994 size_t *sizes
= this_set
->section_sizes
;
2996 printf (_(" Section contributions:\n"));
2997 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2998 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2999 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3000 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3001 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3002 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3003 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3004 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3005 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3006 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3007 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3008 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3012 sec_off
= cu_offset
+ initial_length_size
;
3013 if (sec_off
+ compunit
.cu_length
< sec_off
3014 || sec_off
+ compunit
.cu_length
> section
->size
)
3016 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3018 (unsigned long) cu_offset
,
3019 dwarf_vmatoa ("x", compunit
.cu_length
));
3025 start
+= compunit
.cu_length
+ initial_length_size
;
3027 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3029 warn (_("CU at offset %s contains corrupt or "
3030 "unsupported version number: %d.\n"),
3031 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3035 if (compunit
.cu_unit_type
!= DW_UT_compile
3036 && compunit
.cu_unit_type
!= DW_UT_type
)
3038 warn (_("CU at offset %s contains corrupt or "
3039 "unsupported unit type: %d.\n"),
3040 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3046 /* Process the abbrevs used by this compilation unit. */
3047 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3048 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3049 (unsigned long) compunit
.cu_abbrev_offset
,
3050 (unsigned long) abbrev_size
);
3051 /* PR 17531: file:4bcd9ce9. */
3052 else if ((abbrev_base
+ abbrev_size
)
3053 > debug_displays
[abbrev_sec
].section
.size
)
3054 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3055 (unsigned long) abbrev_base
+ abbrev_size
,
3056 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3058 process_abbrev_section
3059 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3060 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3061 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3062 + abbrev_base
+ abbrev_size
));
3067 while (tags
< start
)
3069 unsigned int bytes_read
;
3070 unsigned long abbrev_number
;
3071 unsigned long die_offset
;
3072 abbrev_entry
*entry
;
3074 int do_printing
= 1;
3076 die_offset
= tags
- section_begin
;
3078 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
3081 /* A null DIE marks the end of a list of siblings or it may also be
3082 a section padding. */
3083 if (abbrev_number
== 0)
3085 /* Check if it can be a section padding for the last CU. */
3086 if (level
== 0 && start
== end
)
3090 for (chk
= tags
; chk
< start
; chk
++)
3097 if (!do_loc
&& die_offset
>= dwarf_start_die
3098 && (dwarf_cutoff_level
== -1
3099 || level
< dwarf_cutoff_level
))
3100 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3106 static unsigned num_bogus_warns
= 0;
3108 if (num_bogus_warns
< 3)
3110 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3111 die_offset
, section
->name
);
3113 if (num_bogus_warns
== 3)
3114 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3117 if (dwarf_start_die
!= 0 && level
< saved_level
)
3124 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3128 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3129 saved_level
= level
;
3130 do_printing
= (dwarf_cutoff_level
== -1
3131 || level
< dwarf_cutoff_level
);
3133 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3134 level
, die_offset
, abbrev_number
);
3135 else if (dwarf_cutoff_level
== -1
3136 || last_level
< dwarf_cutoff_level
)
3137 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3142 /* Scan through the abbreviation list until we reach the
3144 for (entry
= first_abbrev
;
3145 entry
&& entry
->entry
!= abbrev_number
;
3146 entry
= entry
->next
)
3151 if (!do_loc
&& do_printing
)
3156 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3157 die_offset
, abbrev_number
);
3161 if (!do_loc
&& do_printing
)
3162 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3167 need_base_address
= 0;
3169 case DW_TAG_compile_unit
:
3170 need_base_address
= 1;
3171 need_dwo_info
= do_loc
;
3173 case DW_TAG_entry_point
:
3174 case DW_TAG_subprogram
:
3175 need_base_address
= 0;
3176 /* Assuming that there is no DW_AT_frame_base. */
3177 have_frame_base
= 0;
3181 debug_info
*debug_info_p
=
3182 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3183 ? debug_information
+ unit
: NULL
;
3185 assert (!debug_info_p
3186 || (debug_info_p
->num_loc_offsets
3187 == debug_info_p
->num_loc_views
));
3189 for (attr
= entry
->first_attr
;
3190 attr
&& attr
->attribute
;
3193 if (! do_loc
&& do_printing
)
3194 /* Show the offset from where the tag was extracted. */
3195 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3197 tags
= read_and_display_attr (attr
->attribute
,
3199 attr
->implicit_const
,
3203 compunit
.cu_pointer_size
,
3205 compunit
.cu_version
,
3207 do_loc
|| ! do_printing
,
3212 /* If a locview attribute appears before a location one,
3213 make sure we don't associate it with an earlier
3216 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3219 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3220 debug_info_p
->num_loc_views
++;
3221 assert (debug_info_p
->num_loc_views
3222 == debug_info_p
->num_loc_offsets
);
3229 warn(_("DIE has locviews without loclist\n"));
3230 debug_info_p
->num_loc_views
--;
3237 if (entry
->children
)
3242 /* Set num_debug_info_entries here so that it can be used to check if
3243 we need to process .debug_loc and .debug_ranges sections. */
3244 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3245 && num_debug_info_entries
== 0
3248 if (num_units
> alloc_num_debug_info_entries
)
3249 num_debug_info_entries
= alloc_num_debug_info_entries
;
3251 num_debug_info_entries
= num_units
;
3260 /* Locate and scan the .debug_info section in the file and record the pointer
3261 sizes and offsets for the compilation units in it. Usually an executable
3262 will have just one pointer size, but this is not guaranteed, and so we try
3263 not to make any assumptions. Returns zero upon failure, or the number of
3264 compilation units upon success. */
3267 load_debug_info (void * file
)
3269 /* If we have already tried and failed to load the .debug_info
3270 section then do not bother to repeat the task. */
3271 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3274 /* If we already have the information there is nothing else to do. */
3275 if (num_debug_info_entries
> 0)
3276 return num_debug_info_entries
;
3278 /* If this is a DWARF package file, load the CU and TU indexes. */
3279 (void) load_cu_tu_indexes (file
);
3281 if (load_debug_section_with_follow (info
, file
)
3282 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3283 return num_debug_info_entries
;
3285 if (load_debug_section_with_follow (info_dwo
, file
)
3286 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3287 abbrev_dwo
, TRUE
, FALSE
))
3288 return num_debug_info_entries
;
3290 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3294 /* Read a DWARF .debug_line section header starting at DATA.
3295 Upon success returns an updated DATA pointer and the LINFO
3296 structure and the END_OF_SEQUENCE pointer will be filled in.
3297 Otherwise returns NULL. */
3299 static unsigned char *
3300 read_debug_line_header (struct dwarf_section
* section
,
3301 unsigned char * data
,
3302 unsigned char * end
,
3303 DWARF2_Internal_LineInfo
* linfo
,
3304 unsigned char ** end_of_sequence
)
3306 unsigned char *hdrptr
;
3307 unsigned int initial_length_size
;
3308 unsigned char address_size
, segment_selector_size
;
3310 /* Extract information from the Line Number Program Header.
3311 (section 6.2.4 in the Dwarf3 doc). */
3314 /* Get and check the length of the block. */
3315 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3317 if (linfo
->li_length
== 0xffffffff)
3319 /* This section is 64-bit DWARF 3. */
3320 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3321 linfo
->li_offset_size
= 8;
3322 initial_length_size
= 12;
3326 linfo
->li_offset_size
= 4;
3327 initial_length_size
= 4;
3330 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3332 /* If the length field has a relocation against it, then we should
3333 not complain if it is inaccurate (and probably negative). This
3334 happens in object files when the .debug_line section is actually
3335 comprised of several different .debug_line.* sections, (some of
3336 which may be removed by linker garbage collection), and a relocation
3337 is used to compute the correct length once that is done. */
3338 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3340 linfo
->li_length
= (end
- data
) - initial_length_size
;
3344 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3345 (long) linfo
->li_length
);
3350 /* Get and check the version number. */
3351 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3353 if (linfo
->li_version
!= 2
3354 && linfo
->li_version
!= 3
3355 && linfo
->li_version
!= 4
3356 && linfo
->li_version
!= 5)
3358 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3359 "is currently supported.\n"));
3363 if (linfo
->li_version
>= 5)
3365 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
3367 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
3368 if (segment_selector_size
!= 0)
3370 warn (_("The %s section contains "
3371 "unsupported segment selector size: %d.\n"),
3372 section
->name
, segment_selector_size
);
3377 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3378 linfo
->li_offset_size
, end
);
3379 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3381 if (linfo
->li_version
>= 4)
3383 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3385 if (linfo
->li_max_ops_per_insn
== 0)
3387 warn (_("Invalid maximum operations per insn.\n"));
3392 linfo
->li_max_ops_per_insn
= 1;
3394 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3395 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3396 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3397 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3399 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3400 /* PR 17512: file:002-117414-0.004. */
3401 if (* end_of_sequence
> end
)
3403 warn (_("Line length %s extends beyond end of section\n"),
3404 dwarf_vmatoa ("u", linfo
->li_length
));
3405 * end_of_sequence
= end
;
3412 static unsigned char *
3413 display_formatted_table (unsigned char * data
,
3414 unsigned char * start
,
3415 unsigned char * end
,
3416 const DWARF2_Internal_LineInfo
* linfo
,
3417 struct dwarf_section
* section
,
3420 unsigned char *format_start
, format_count
, *format
, formati
;
3421 dwarf_vma data_count
, datai
;
3422 unsigned int bytes_read
, namepass
, last_entry
= 0;
3424 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3425 format_start
= data
;
3426 for (formati
= 0; formati
< format_count
; formati
++)
3428 read_uleb128 (data
, & bytes_read
, end
);
3430 read_uleb128 (data
, & bytes_read
, end
);
3434 warn (_("Corrupt %s format table entry\n"), what
);
3439 data_count
= read_uleb128 (data
, & bytes_read
, end
);
3443 warn (_("Corrupt %s list\n"), what
);
3447 if (data_count
== 0)
3449 printf (_("\n The %s Table is empty.\n"), what
);
3453 printf (_("\n The %s Table (offset 0x%lx):\n"), what
,
3454 (long)(data
- start
));
3456 printf (_(" Entry"));
3457 /* Delay displaying name as the last entry for better screen layout. */
3458 for (namepass
= 0; namepass
< 2; namepass
++)
3460 format
= format_start
;
3461 for (formati
= 0; formati
< format_count
; formati
++)
3463 dwarf_vma content_type
;
3465 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3466 format
+= bytes_read
;
3467 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3468 switch (content_type
)
3471 printf (_("\tName"));
3473 case DW_LNCT_directory_index
:
3474 printf (_("\tDir"));
3476 case DW_LNCT_timestamp
:
3477 printf (_("\tTime"));
3480 printf (_("\tSize"));
3483 printf (_("\tMD5"));
3486 printf (_("\t(Unknown format content type %s)"),
3487 dwarf_vmatoa ("u", content_type
));
3489 read_uleb128 (format
, & bytes_read
, end
);
3490 format
+= bytes_read
;
3495 for (datai
= 0; datai
< data_count
; datai
++)
3497 unsigned char *datapass
= data
;
3499 printf (" %d", last_entry
++);
3500 /* Delay displaying name as the last entry for better screen layout. */
3501 for (namepass
= 0; namepass
< 2; namepass
++)
3503 format
= format_start
;
3505 for (formati
= 0; formati
< format_count
; formati
++)
3507 dwarf_vma content_type
, form
;
3509 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3510 format
+= bytes_read
;
3511 form
= read_uleb128 (format
, & bytes_read
, end
);
3512 format
+= bytes_read
;
3513 data
= read_and_display_attr_value (0, form
, 0, data
, end
, 0, 0,
3514 linfo
->li_offset_size
,
3515 linfo
->li_version
, NULL
,
3516 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3517 section
, NULL
, '\t');
3522 warn (_("Corrupt %s entries list\n"), what
);
3531 display_debug_lines_raw (struct dwarf_section
* section
,
3532 unsigned char * data
,
3533 unsigned char * end
,
3536 unsigned char *start
= section
->start
;
3537 int verbose_view
= 0;
3539 introduce (section
, TRUE
);
3543 static DWARF2_Internal_LineInfo saved_linfo
;
3544 DWARF2_Internal_LineInfo linfo
;
3545 unsigned char *standard_opcodes
;
3546 unsigned char *end_of_sequence
;
3549 if (const_strneq (section
->name
, ".debug_line.")
3550 /* Note: the following does not apply to .debug_line.dwo sections.
3551 These are full debug_line sections. */
3552 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3554 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3555 section containing just the Line Number Statements. They are
3556 created by the assembler and intended to be used alongside gcc's
3557 -ffunction-sections command line option. When the linker's
3558 garbage collection decides to discard a .text.<foo> section it
3559 can then also discard the line number information in .debug_line.<foo>.
3561 Since the section is a fragment it does not have the details
3562 needed to fill out a LineInfo structure, so instead we use the
3563 details from the last full debug_line section that we processed. */
3564 end_of_sequence
= end
;
3565 standard_opcodes
= NULL
;
3566 linfo
= saved_linfo
;
3567 /* PR 17531: file: 0522b371. */
3568 if (linfo
.li_line_range
== 0)
3570 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3573 reset_state_machine (linfo
.li_default_is_stmt
);
3577 unsigned char * hdrptr
;
3579 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3580 & end_of_sequence
)) == NULL
)
3583 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3584 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3585 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3586 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3587 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3588 if (linfo
.li_version
>= 4)
3589 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3590 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3591 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3592 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3593 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3595 /* PR 17512: file: 1665-6428-0.004. */
3596 if (linfo
.li_line_range
== 0)
3598 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3599 linfo
.li_line_range
= 1;
3602 reset_state_machine (linfo
.li_default_is_stmt
);
3604 /* Display the contents of the Opcodes table. */
3605 standard_opcodes
= hdrptr
;
3607 /* PR 17512: file: 002-417945-0.004. */
3608 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3610 warn (_("Line Base extends beyond end of section\n"));
3614 printf (_("\n Opcodes:\n"));
3616 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3617 printf (ngettext (" Opcode %d has %d arg\n",
3618 " Opcode %d has %d args\n",
3619 standard_opcodes
[i
- 1]),
3620 i
, standard_opcodes
[i
- 1]);
3622 /* Display the contents of the Directory table. */
3623 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3625 if (linfo
.li_version
>= 5)
3627 load_debug_section_with_follow (line_str
, file
);
3629 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3631 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3637 printf (_("\n The Directory Table is empty.\n"));
3640 unsigned int last_dir_entry
= 0;
3642 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3643 (long)(data
- start
));
3645 while (data
< end
&& *data
!= 0)
3647 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
3649 data
+= strnlen ((char *) data
, end
- data
) + 1;
3652 /* PR 17512: file: 002-132094-0.004. */
3653 if (data
>= end
- 1)
3657 /* Skip the NUL at the end of the table. */
3660 /* Display the contents of the File Name table. */
3662 printf (_("\n The File Name Table is empty.\n"));
3665 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3666 (long)(data
- start
));
3667 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3669 while (data
< end
&& *data
!= 0)
3671 unsigned char *name
;
3672 unsigned int bytes_read
;
3674 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
3676 data
+= strnlen ((char *) data
, end
- data
) + 1;
3679 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3682 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3685 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3687 printf ("%.*s\n", (int)(end
- name
), name
);
3691 warn (_("Corrupt file name table entry\n"));
3697 /* Skip the NUL at the end of the table. */
3702 saved_linfo
= linfo
;
3705 /* Now display the statements. */
3706 if (data
>= end_of_sequence
)
3707 printf (_(" No Line Number Statements.\n"));
3710 printf (_(" Line Number Statements:\n"));
3712 while (data
< end_of_sequence
)
3714 unsigned char op_code
;
3715 dwarf_signed_vma adv
;
3717 unsigned int bytes_read
;
3719 printf (" [0x%08lx]", (long)(data
- start
));
3723 if (op_code
>= linfo
.li_opcode_base
)
3725 op_code
-= linfo
.li_opcode_base
;
3726 uladv
= (op_code
/ linfo
.li_line_range
);
3727 if (linfo
.li_max_ops_per_insn
== 1)
3729 uladv
*= linfo
.li_min_insn_length
;
3730 state_machine_regs
.address
+= uladv
;
3732 state_machine_regs
.view
= 0;
3733 printf (_(" Special opcode %d: "
3734 "advance Address by %s to 0x%s%s"),
3735 op_code
, dwarf_vmatoa ("u", uladv
),
3736 dwarf_vmatoa ("x", state_machine_regs
.address
),
3737 verbose_view
&& uladv
3738 ? _(" (reset view)") : "");
3743 = ((state_machine_regs
.op_index
+ uladv
)
3744 / linfo
.li_max_ops_per_insn
)
3745 * linfo
.li_min_insn_length
;
3747 state_machine_regs
.address
+= addrdelta
;
3748 state_machine_regs
.op_index
3749 = (state_machine_regs
.op_index
+ uladv
)
3750 % linfo
.li_max_ops_per_insn
;
3752 state_machine_regs
.view
= 0;
3753 printf (_(" Special opcode %d: "
3754 "advance Address by %s to 0x%s[%d]%s"),
3755 op_code
, dwarf_vmatoa ("u", uladv
),
3756 dwarf_vmatoa ("x", state_machine_regs
.address
),
3757 state_machine_regs
.op_index
,
3758 verbose_view
&& addrdelta
3759 ? _(" (reset view)") : "");
3761 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3762 state_machine_regs
.line
+= adv
;
3763 printf (_(" and Line by %s to %d"),
3764 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
3765 if (verbose_view
|| state_machine_regs
.view
)
3766 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3769 state_machine_regs
.view
++;
3771 else switch (op_code
)
3773 case DW_LNS_extended_op
:
3774 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3778 printf (_(" Copy"));
3779 if (verbose_view
|| state_machine_regs
.view
)
3780 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3783 state_machine_regs
.view
++;
3786 case DW_LNS_advance_pc
:
3787 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3789 if (linfo
.li_max_ops_per_insn
== 1)
3791 uladv
*= linfo
.li_min_insn_length
;
3792 state_machine_regs
.address
+= uladv
;
3794 state_machine_regs
.view
= 0;
3795 printf (_(" Advance PC by %s to 0x%s%s\n"),
3796 dwarf_vmatoa ("u", uladv
),
3797 dwarf_vmatoa ("x", state_machine_regs
.address
),
3798 verbose_view
&& uladv
3799 ? _(" (reset view)") : "");
3804 = ((state_machine_regs
.op_index
+ uladv
)
3805 / linfo
.li_max_ops_per_insn
)
3806 * linfo
.li_min_insn_length
;
3807 state_machine_regs
.address
3809 state_machine_regs
.op_index
3810 = (state_machine_regs
.op_index
+ uladv
)
3811 % linfo
.li_max_ops_per_insn
;
3813 state_machine_regs
.view
= 0;
3814 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
3815 dwarf_vmatoa ("u", uladv
),
3816 dwarf_vmatoa ("x", state_machine_regs
.address
),
3817 state_machine_regs
.op_index
,
3818 verbose_view
&& addrdelta
3819 ? _(" (reset view)") : "");
3823 case DW_LNS_advance_line
:
3824 adv
= read_sleb128 (data
, & bytes_read
, end
);
3826 state_machine_regs
.line
+= adv
;
3827 printf (_(" Advance Line by %s to %d\n"),
3828 dwarf_vmatoa ("d", adv
),
3829 state_machine_regs
.line
);
3832 case DW_LNS_set_file
:
3833 adv
= read_uleb128 (data
, & bytes_read
, end
);
3835 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3836 dwarf_vmatoa ("d", adv
));
3837 state_machine_regs
.file
= adv
;
3840 case DW_LNS_set_column
:
3841 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3843 printf (_(" Set column to %s\n"),
3844 dwarf_vmatoa ("u", uladv
));
3845 state_machine_regs
.column
= uladv
;
3848 case DW_LNS_negate_stmt
:
3849 adv
= state_machine_regs
.is_stmt
;
3851 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3852 state_machine_regs
.is_stmt
= adv
;
3855 case DW_LNS_set_basic_block
:
3856 printf (_(" Set basic block\n"));
3857 state_machine_regs
.basic_block
= 1;
3860 case DW_LNS_const_add_pc
:
3861 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3862 if (linfo
.li_max_ops_per_insn
)
3864 uladv
*= linfo
.li_min_insn_length
;
3865 state_machine_regs
.address
+= uladv
;
3867 state_machine_regs
.view
= 0;
3868 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
3869 dwarf_vmatoa ("u", uladv
),
3870 dwarf_vmatoa ("x", state_machine_regs
.address
),
3871 verbose_view
&& uladv
3872 ? _(" (reset view)") : "");
3877 = ((state_machine_regs
.op_index
+ uladv
)
3878 / linfo
.li_max_ops_per_insn
)
3879 * linfo
.li_min_insn_length
;
3880 state_machine_regs
.address
3882 state_machine_regs
.op_index
3883 = (state_machine_regs
.op_index
+ uladv
)
3884 % linfo
.li_max_ops_per_insn
;
3886 state_machine_regs
.view
= 0;
3887 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
3888 dwarf_vmatoa ("u", uladv
),
3889 dwarf_vmatoa ("x", state_machine_regs
.address
),
3890 state_machine_regs
.op_index
,
3891 verbose_view
&& addrdelta
3892 ? _(" (reset view)") : "");
3896 case DW_LNS_fixed_advance_pc
:
3897 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3898 state_machine_regs
.address
+= uladv
;
3899 state_machine_regs
.op_index
= 0;
3900 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3901 dwarf_vmatoa ("u", uladv
),
3902 dwarf_vmatoa ("x", state_machine_regs
.address
));
3903 /* Do NOT reset view. */
3906 case DW_LNS_set_prologue_end
:
3907 printf (_(" Set prologue_end to true\n"));
3910 case DW_LNS_set_epilogue_begin
:
3911 printf (_(" Set epilogue_begin to true\n"));
3914 case DW_LNS_set_isa
:
3915 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3917 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3921 printf (_(" Unknown opcode %d with operands: "), op_code
);
3923 if (standard_opcodes
!= NULL
)
3924 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3926 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3928 i
== 1 ? "" : ", ");
3944 unsigned char *name
;
3945 unsigned int directory_index
;
3946 unsigned int modification_date
;
3947 unsigned int length
;
3950 /* Output a decoded representation of the .debug_line section. */
3953 display_debug_lines_decoded (struct dwarf_section
* section
,
3954 unsigned char * data
,
3955 unsigned char * end
,
3958 static DWARF2_Internal_LineInfo saved_linfo
;
3960 introduce (section
, FALSE
);
3964 /* This loop amounts to one iteration per compilation unit. */
3965 DWARF2_Internal_LineInfo linfo
;
3966 unsigned char *standard_opcodes
;
3967 unsigned char *end_of_sequence
;
3969 File_Entry
*file_table
= NULL
;
3970 unsigned int n_files
= 0;
3971 unsigned char **directory_table
= NULL
;
3972 dwarf_vma n_directories
= 0;
3974 if (const_strneq (section
->name
, ".debug_line.")
3975 /* Note: the following does not apply to .debug_line.dwo sections.
3976 These are full debug_line sections. */
3977 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3979 /* See comment in display_debug_lines_raw(). */
3980 end_of_sequence
= end
;
3981 standard_opcodes
= NULL
;
3982 linfo
= saved_linfo
;
3983 /* PR 17531: file: 0522b371. */
3984 if (linfo
.li_line_range
== 0)
3986 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3989 reset_state_machine (linfo
.li_default_is_stmt
);
3993 unsigned char *hdrptr
;
3995 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3996 & end_of_sequence
)) == NULL
)
3999 /* PR 17531: file: 0522b371. */
4000 if (linfo
.li_line_range
== 0)
4002 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4003 linfo
.li_line_range
= 1;
4005 reset_state_machine (linfo
.li_default_is_stmt
);
4007 /* Save a pointer to the contents of the Opcodes table. */
4008 standard_opcodes
= hdrptr
;
4010 /* Traverse the Directory table just to count entries. */
4011 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4015 warn (_("opcode base of %d extends beyond end of section\n"),
4016 linfo
.li_opcode_base
);
4020 if (linfo
.li_version
>= 5)
4022 unsigned char *format_start
, format_count
, *format
;
4023 dwarf_vma formati
, entryi
;
4024 unsigned int bytes_read
;
4026 load_debug_section_with_follow (line_str
, fileptr
);
4028 /* Skip directories format. */
4029 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4030 format_start
= data
;
4031 for (formati
= 0; formati
< format_count
; formati
++)
4033 read_uleb128 (data
, & bytes_read
, end
);
4035 read_uleb128 (data
, & bytes_read
, end
);
4039 n_directories
= read_uleb128 (data
, & bytes_read
, end
);
4043 warn (_("Corrupt directories list\n"));
4047 directory_table
= (unsigned char **)
4048 xmalloc (n_directories
* sizeof (unsigned char *));
4050 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4052 unsigned char **pathp
= &directory_table
[entryi
];
4054 format
= format_start
;
4055 for (formati
= 0; formati
< format_count
; formati
++)
4057 dwarf_vma content_type
, form
;
4060 content_type
= read_uleb128 (format
, & bytes_read
, end
);
4061 format
+= bytes_read
;
4062 form
= read_uleb128 (format
, & bytes_read
, end
);
4063 format
+= bytes_read
;
4066 warn (_("Corrupt directories list\n"));
4069 switch (content_type
)
4074 case DW_FORM_string
:
4077 case DW_FORM_line_strp
:
4078 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4080 /* Remove const by the cast. */
4081 *pathp
= (unsigned char *)
4082 fetch_indirect_line_string (uvalue
);
4087 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
4089 linfo
.li_offset_size
,
4096 warn (_("Corrupt directories list\n"));
4101 /* Skip files format. */
4102 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4103 format_start
= data
;
4104 for (formati
= 0; formati
< format_count
; formati
++)
4106 read_uleb128 (data
, & bytes_read
, end
);
4108 read_uleb128 (data
, & bytes_read
, end
);
4112 n_files
= read_uleb128 (data
, & bytes_read
, end
);
4116 warn (_("Corrupt file name list\n"));
4120 file_table
= (File_Entry
*) xcalloc (1, n_files
4121 * sizeof (File_Entry
));
4123 for (entryi
= 0; entryi
< n_files
; entryi
++)
4125 File_Entry
*file
= &file_table
[entryi
];
4127 format
= format_start
;
4128 for (formati
= 0; formati
< format_count
; formati
++)
4130 dwarf_vma content_type
, form
;
4133 content_type
= read_uleb128 (format
, & bytes_read
, end
);
4134 format
+= bytes_read
;
4135 form
= read_uleb128 (format
, & bytes_read
, end
);
4136 format
+= bytes_read
;
4139 warn (_("Corrupt file name list\n"));
4142 switch (content_type
)
4147 case DW_FORM_string
:
4150 case DW_FORM_line_strp
:
4151 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4153 /* Remove const by the cast. */
4154 file
->name
= (unsigned char *)
4155 fetch_indirect_line_string (uvalue
);
4159 case DW_LNCT_directory_index
:
4163 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4167 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4171 file
->directory_index
= read_uleb128 (data
, NULL
,
4177 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
4179 linfo
.li_offset_size
,
4186 warn (_("Corrupt file name list\n"));
4195 unsigned char *ptr_directory_table
= data
;
4197 while (data
< end
&& *data
!= 0)
4199 data
+= strnlen ((char *) data
, end
- data
) + 1;
4206 warn (_("directory table ends unexpectedly\n"));
4211 /* Go through the directory table again to save the directories. */
4212 directory_table
= (unsigned char **)
4213 xmalloc (n_directories
* sizeof (unsigned char *));
4216 while (*ptr_directory_table
!= 0)
4218 directory_table
[i
] = ptr_directory_table
;
4219 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4220 ptr_directory_table
- end
) + 1;
4224 /* Skip the NUL at the end of the table. */
4227 /* Traverse the File Name table just to count the entries. */
4228 if (data
< end
&& *data
!= 0)
4230 unsigned char *ptr_file_name_table
= data
;
4232 while (data
< end
&& *data
!= 0)
4234 unsigned int bytes_read
;
4236 /* Skip Name, directory index, last modification time and length
4238 data
+= strnlen ((char *) data
, end
- data
) + 1;
4239 read_uleb128 (data
, & bytes_read
, end
);
4241 read_uleb128 (data
, & bytes_read
, end
);
4243 read_uleb128 (data
, & bytes_read
, end
);
4251 warn (_("file table ends unexpectedly\n"));
4256 /* Go through the file table again to save the strings. */
4257 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4260 while (*ptr_file_name_table
!= 0)
4262 unsigned int bytes_read
;
4264 file_table
[i
].name
= ptr_file_name_table
;
4265 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4266 end
- ptr_file_name_table
) + 1;
4268 /* We are not interested in directory, time or size. */
4269 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
4271 ptr_file_name_table
+= bytes_read
;
4272 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
4274 ptr_file_name_table
+= bytes_read
;
4275 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
4276 ptr_file_name_table
+= bytes_read
;
4282 /* Skip the NUL at the end of the table. */
4286 /* Print the Compilation Unit's name and a header. */
4287 if (file_table
== NULL
)
4289 else if (directory_table
== NULL
)
4290 printf (_("CU: %s:\n"), file_table
[0].name
);
4293 unsigned int ix
= file_table
[0].directory_index
;
4294 const char *directory
;
4299 else if (n_directories
== 0)
4300 directory
= _("<unknown>");
4301 else if (ix
> n_directories
)
4303 warn (_("directory index %u > number of directories %s\n"),
4304 ix
, dwarf_vmatoa ("u", n_directories
));
4305 directory
= _("<corrupt>");
4308 directory
= (char *) directory_table
[ix
- 1];
4310 if (do_wide
|| strlen (directory
) < 76)
4311 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4313 printf ("%s:\n", file_table
[0].name
);
4316 printf (_("File name Line number Starting address View\n"));
4317 saved_linfo
= linfo
;
4320 /* This loop iterates through the Dwarf Line Number Program. */
4321 while (data
< end_of_sequence
)
4323 unsigned char op_code
;
4326 unsigned long int uladv
;
4327 unsigned int bytes_read
;
4328 int is_special_opcode
= 0;
4333 if (op_code
>= linfo
.li_opcode_base
)
4335 op_code
-= linfo
.li_opcode_base
;
4336 uladv
= (op_code
/ linfo
.li_line_range
);
4337 if (linfo
.li_max_ops_per_insn
== 1)
4339 uladv
*= linfo
.li_min_insn_length
;
4340 state_machine_regs
.address
+= uladv
;
4342 state_machine_regs
.view
= 0;
4347 = ((state_machine_regs
.op_index
+ uladv
)
4348 / linfo
.li_max_ops_per_insn
)
4349 * linfo
.li_min_insn_length
;
4350 state_machine_regs
.address
4352 state_machine_regs
.op_index
4353 = (state_machine_regs
.op_index
+ uladv
)
4354 % linfo
.li_max_ops_per_insn
;
4356 state_machine_regs
.view
= 0;
4359 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4360 state_machine_regs
.line
+= adv
;
4361 is_special_opcode
= 1;
4362 /* Increment view after printing this row. */
4364 else switch (op_code
)
4366 case DW_LNS_extended_op
:
4368 unsigned int ext_op_code_len
;
4369 unsigned char ext_op_code
;
4370 unsigned char *op_code_data
= data
;
4372 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
4374 op_code_data
+= bytes_read
;
4376 if (ext_op_code_len
== 0)
4378 warn (_("Badly formed extended line op encountered!\n"));
4381 ext_op_code_len
+= bytes_read
;
4382 ext_op_code
= *op_code_data
++;
4386 switch (ext_op_code
)
4388 case DW_LNE_end_sequence
:
4389 /* Reset stuff after printing this row. */
4391 case DW_LNE_set_address
:
4392 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4394 ext_op_code_len
- bytes_read
- 1,
4396 state_machine_regs
.op_index
= 0;
4397 state_machine_regs
.view
= 0;
4399 case DW_LNE_define_file
:
4401 file_table
= (File_Entry
*) xrealloc
4402 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4404 ++state_machine_regs
.last_file_entry
;
4405 /* Source file name. */
4406 file_table
[n_files
].name
= op_code_data
;
4407 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4408 /* Directory index. */
4409 file_table
[n_files
].directory_index
=
4410 read_uleb128 (op_code_data
, & bytes_read
,
4412 op_code_data
+= bytes_read
;
4413 /* Last modification time. */
4414 file_table
[n_files
].modification_date
=
4415 read_uleb128 (op_code_data
, & bytes_read
,
4417 op_code_data
+= bytes_read
;
4419 file_table
[n_files
].length
=
4420 read_uleb128 (op_code_data
, & bytes_read
,
4426 case DW_LNE_set_discriminator
:
4427 case DW_LNE_HP_set_sequence
:
4428 /* Simply ignored. */
4432 printf (_("UNKNOWN (%u): length %d\n"),
4433 ext_op_code
, ext_op_code_len
- bytes_read
);
4436 data
+= ext_op_code_len
;
4440 /* Increment view after printing this row. */
4443 case DW_LNS_advance_pc
:
4444 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4446 if (linfo
.li_max_ops_per_insn
== 1)
4448 uladv
*= linfo
.li_min_insn_length
;
4449 state_machine_regs
.address
+= uladv
;
4451 state_machine_regs
.view
= 0;
4456 = ((state_machine_regs
.op_index
+ uladv
)
4457 / linfo
.li_max_ops_per_insn
)
4458 * linfo
.li_min_insn_length
;
4459 state_machine_regs
.address
4461 state_machine_regs
.op_index
4462 = (state_machine_regs
.op_index
+ uladv
)
4463 % linfo
.li_max_ops_per_insn
;
4465 state_machine_regs
.view
= 0;
4469 case DW_LNS_advance_line
:
4470 adv
= read_sleb128 (data
, & bytes_read
, end
);
4472 state_machine_regs
.line
+= adv
;
4475 case DW_LNS_set_file
:
4476 adv
= read_uleb128 (data
, & bytes_read
, end
);
4478 state_machine_regs
.file
= adv
;
4481 unsigned file
= state_machine_regs
.file
- 1;
4484 if (file_table
== NULL
|| n_files
== 0)
4485 printf (_("\n [Use file table entry %d]\n"), file
);
4487 else if (file
>= n_files
)
4489 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4490 printf (_("\n <over large file table index %u>"), file
);
4492 else if ((dir
= file_table
[file
].directory_index
) == 0)
4493 /* If directory index is 0, that means current directory. */
4494 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4495 else if (directory_table
== NULL
|| n_directories
== 0)
4496 printf (_("\n [Use file %s in directory table entry %d]\n"),
4497 file_table
[file
].name
, dir
);
4499 else if (dir
> n_directories
)
4501 warn (_("directory index %u > number of directories %s\n"),
4502 dir
, dwarf_vmatoa ("u", n_directories
));
4503 printf (_("\n <over large directory table entry %u>\n"), dir
);
4506 printf ("\n%s/%s:\n",
4507 /* The directory index starts counting at 1. */
4508 directory_table
[dir
- 1], file_table
[file
].name
);
4512 case DW_LNS_set_column
:
4513 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4515 state_machine_regs
.column
= uladv
;
4518 case DW_LNS_negate_stmt
:
4519 adv
= state_machine_regs
.is_stmt
;
4521 state_machine_regs
.is_stmt
= adv
;
4524 case DW_LNS_set_basic_block
:
4525 state_machine_regs
.basic_block
= 1;
4528 case DW_LNS_const_add_pc
:
4529 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4530 if (linfo
.li_max_ops_per_insn
== 1)
4532 uladv
*= linfo
.li_min_insn_length
;
4533 state_machine_regs
.address
+= uladv
;
4535 state_machine_regs
.view
= 0;
4540 = ((state_machine_regs
.op_index
+ uladv
)
4541 / linfo
.li_max_ops_per_insn
)
4542 * linfo
.li_min_insn_length
;
4543 state_machine_regs
.address
4545 state_machine_regs
.op_index
4546 = (state_machine_regs
.op_index
+ uladv
)
4547 % linfo
.li_max_ops_per_insn
;
4549 state_machine_regs
.view
= 0;
4553 case DW_LNS_fixed_advance_pc
:
4554 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4555 state_machine_regs
.address
+= uladv
;
4556 state_machine_regs
.op_index
= 0;
4557 /* Do NOT reset view. */
4560 case DW_LNS_set_prologue_end
:
4563 case DW_LNS_set_epilogue_begin
:
4566 case DW_LNS_set_isa
:
4567 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4569 printf (_(" Set ISA to %lu\n"), uladv
);
4573 printf (_(" Unknown opcode %d with operands: "), op_code
);
4575 if (standard_opcodes
!= NULL
)
4576 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4578 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
4580 i
== 1 ? "" : ", ");
4587 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4588 to the DWARF address/line matrix. */
4589 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4590 || (xop
== DW_LNS_copy
))
4592 const unsigned int MAX_FILENAME_LENGTH
= 35;
4594 char *newFileName
= NULL
;
4595 size_t fileNameLength
;
4599 unsigned indx
= state_machine_regs
.file
- 1;
4601 if (indx
>= n_files
)
4603 warn (_("corrupt file index %u encountered\n"), indx
);
4604 fileName
= _("<corrupt>");
4607 fileName
= (char *) file_table
[indx
].name
;
4610 fileName
= _("<unknown>");
4612 fileNameLength
= strlen (fileName
);
4614 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4616 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4617 /* Truncate file name */
4618 strncpy (newFileName
,
4619 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4620 MAX_FILENAME_LENGTH
+ 1);
4624 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4625 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4628 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4630 if (linfo
.li_max_ops_per_insn
== 1)
4631 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4632 newFileName
, state_machine_regs
.line
,
4633 state_machine_regs
.address
);
4635 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4636 newFileName
, state_machine_regs
.line
,
4637 state_machine_regs
.address
,
4638 state_machine_regs
.op_index
);
4642 if (linfo
.li_max_ops_per_insn
== 1)
4643 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
4644 newFileName
, state_machine_regs
.line
,
4645 state_machine_regs
.address
);
4647 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4648 newFileName
, state_machine_regs
.line
,
4649 state_machine_regs
.address
,
4650 state_machine_regs
.op_index
);
4653 if (state_machine_regs
.view
)
4654 printf (" %6u\n", state_machine_regs
.view
);
4657 state_machine_regs
.view
++;
4659 if (xop
== -DW_LNE_end_sequence
)
4661 reset_state_machine (linfo
.li_default_is_stmt
);
4676 if (directory_table
)
4678 free (directory_table
);
4679 directory_table
= NULL
;
4690 display_debug_lines (struct dwarf_section
*section
, void *file
)
4692 unsigned char *data
= section
->start
;
4693 unsigned char *end
= data
+ section
->size
;
4695 int retValDecoded
= 1;
4697 if (do_debug_lines
== 0)
4698 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
4700 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
4701 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
4703 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
4704 retValDecoded
= display_debug_lines_decoded (section
, data
, end
, file
);
4706 if (!retValRaw
|| !retValDecoded
)
4713 find_debug_info_for_offset (unsigned long offset
)
4717 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4720 for (i
= 0; i
< num_debug_info_entries
; i
++)
4721 if (debug_information
[i
].cu_offset
== offset
)
4722 return debug_information
+ i
;
4728 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
4730 /* See gdb/gdb-index.h. */
4731 static const char * const kinds
[] =
4743 return _ (kinds
[kind
]);
4747 display_debug_pubnames_worker (struct dwarf_section
*section
,
4748 void *file ATTRIBUTE_UNUSED
,
4751 DWARF2_Internal_PubNames names
;
4752 unsigned char *start
= section
->start
;
4753 unsigned char *end
= start
+ section
->size
;
4755 /* It does not matter if this load fails,
4756 we test for that later on. */
4757 load_debug_info (file
);
4759 introduce (section
, FALSE
);
4763 unsigned char *data
;
4764 unsigned long sec_off
;
4765 unsigned int offset_size
, initial_length_size
;
4767 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
4768 if (names
.pn_length
== 0xffffffff)
4770 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
4772 initial_length_size
= 12;
4777 initial_length_size
= 4;
4780 sec_off
= start
- section
->start
;
4781 if (sec_off
+ names
.pn_length
< sec_off
4782 || sec_off
+ names
.pn_length
> section
->size
)
4784 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
4786 sec_off
- initial_length_size
,
4787 dwarf_vmatoa ("x", names
.pn_length
));
4792 start
+= names
.pn_length
;
4794 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
4795 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
4797 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4798 && num_debug_info_entries
> 0
4799 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
4800 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4801 (unsigned long) names
.pn_offset
, section
->name
);
4803 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
4805 printf (_(" Length: %ld\n"),
4806 (long) names
.pn_length
);
4807 printf (_(" Version: %d\n"),
4809 printf (_(" Offset into .debug_info section: 0x%lx\n"),
4810 (unsigned long) names
.pn_offset
);
4811 printf (_(" Size of area in .debug_info section: %ld\n"),
4812 (long) names
.pn_size
);
4814 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
4816 static int warned
= 0;
4820 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
4828 printf (_("\n Offset Kind Name\n"));
4830 printf (_("\n Offset\tName\n"));
4834 bfd_size_type maxprint
;
4837 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
4842 data
+= offset_size
;
4845 maxprint
= (end
- data
) - 1;
4849 unsigned int kind_data
;
4850 gdb_index_symbol_kind kind
;
4851 const char *kind_name
;
4854 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
4857 /* GCC computes the kind as the upper byte in the CU index
4858 word, and then right shifts it by the CU index size.
4859 Left shift KIND to where the gdb-index.h accessor macros
4861 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
4862 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
4863 kind_name
= get_gdb_index_symbol_kind_name (kind
);
4864 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
4865 printf (" %-6lx %s,%-10s %.*s\n",
4866 (unsigned long) offset
, is_static
? _("s") : _("g"),
4867 kind_name
, (int) maxprint
, data
);
4870 printf (" %-6lx\t%.*s\n",
4871 (unsigned long) offset
, (int) maxprint
, data
);
4873 data
+= strnlen ((char *) data
, maxprint
) + 1;
4884 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
4886 return display_debug_pubnames_worker (section
, file
, 0);
4890 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
4892 return display_debug_pubnames_worker (section
, file
, 1);
4896 display_debug_macinfo (struct dwarf_section
*section
,
4897 void *file ATTRIBUTE_UNUSED
)
4899 unsigned char *start
= section
->start
;
4900 unsigned char *end
= start
+ section
->size
;
4901 unsigned char *curr
= start
;
4902 unsigned int bytes_read
;
4903 enum dwarf_macinfo_record_type op
;
4905 introduce (section
, FALSE
);
4909 unsigned int lineno
;
4910 const unsigned char *string
;
4912 op
= (enum dwarf_macinfo_record_type
) *curr
;
4917 case DW_MACINFO_start_file
:
4919 unsigned int filenum
;
4921 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4923 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
4926 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
4931 case DW_MACINFO_end_file
:
4932 printf (_(" DW_MACINFO_end_file\n"));
4935 case DW_MACINFO_define
:
4936 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4939 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4940 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
4944 case DW_MACINFO_undef
:
4945 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4948 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4949 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
4953 case DW_MACINFO_vendor_ext
:
4955 unsigned int constant
;
4957 constant
= read_uleb128 (curr
, & bytes_read
, end
);
4960 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4961 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
4971 /* Given LINE_OFFSET into the .debug_line section, attempt to return
4972 filename and dirname corresponding to file name table entry with index
4973 FILEIDX. Return NULL on failure. */
4975 static unsigned char *
4976 get_line_filename_and_dirname (dwarf_vma line_offset
,
4978 unsigned char **dir_name
)
4980 struct dwarf_section
*section
= &debug_displays
[line
].section
;
4981 unsigned char *hdrptr
, *dirtable
, *file_name
;
4982 unsigned int offset_size
, initial_length_size
;
4983 unsigned int version
, opcode_base
, bytes_read
;
4984 dwarf_vma length
, diridx
;
4985 const unsigned char * end
;
4988 if (section
->start
== NULL
4989 || line_offset
>= section
->size
4993 hdrptr
= section
->start
+ line_offset
;
4994 end
= section
->start
+ section
->size
;
4996 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
4997 if (length
== 0xffffffff)
4999 /* This section is 64-bit DWARF 3. */
5000 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5002 initial_length_size
= 12;
5007 initial_length_size
= 4;
5009 if (length
+ initial_length_size
< length
5010 || length
+ initial_length_size
> section
->size
)
5013 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5014 if (version
!= 2 && version
!= 3 && version
!= 4)
5016 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5018 hdrptr
++; /* Skip max_ops_per_insn. */
5019 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5021 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5022 if (opcode_base
== 0)
5025 hdrptr
+= opcode_base
- 1;
5030 /* Skip over dirname table. */
5031 while (*hdrptr
!= '\0')
5033 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5037 hdrptr
++; /* Skip the NUL at the end of the table. */
5039 /* Now skip over preceding filename table entries. */
5040 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5042 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5043 read_uleb128 (hdrptr
, &bytes_read
, end
);
5044 hdrptr
+= bytes_read
;
5045 read_uleb128 (hdrptr
, &bytes_read
, end
);
5046 hdrptr
+= bytes_read
;
5047 read_uleb128 (hdrptr
, &bytes_read
, end
);
5048 hdrptr
+= bytes_read
;
5050 if (hdrptr
>= end
|| *hdrptr
== '\0')
5054 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5057 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
5060 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5061 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5062 if (dirtable
>= end
|| *dirtable
== '\0')
5064 *dir_name
= dirtable
;
5069 display_debug_macro (struct dwarf_section
*section
,
5072 unsigned char *start
= section
->start
;
5073 unsigned char *end
= start
+ section
->size
;
5074 unsigned char *curr
= start
;
5075 unsigned char *extended_op_buf
[256];
5076 unsigned int bytes_read
;
5078 load_debug_section_with_follow (str
, file
);
5079 load_debug_section_with_follow (line
, file
);
5081 introduce (section
, FALSE
);
5085 unsigned int lineno
, version
, flags
;
5086 unsigned int offset_size
= 4;
5087 const unsigned char *string
;
5088 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5089 unsigned char **extended_ops
= NULL
;
5091 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5092 if (version
!= 4 && version
!= 5)
5094 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5099 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5102 printf (_(" Offset: 0x%lx\n"),
5103 (unsigned long) sec_offset
);
5104 printf (_(" Version: %d\n"), version
);
5105 printf (_(" Offset size: %d\n"), offset_size
);
5108 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5109 printf (_(" Offset into .debug_line: 0x%lx\n"),
5110 (unsigned long) line_offset
);
5114 unsigned int i
, count
, op
;
5117 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5119 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5120 extended_ops
= extended_op_buf
;
5123 printf (_(" Extension opcode arguments:\n"));
5124 for (i
= 0; i
< count
; i
++)
5126 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5127 extended_ops
[op
] = curr
;
5128 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
5131 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5134 printf (_(" DW_MACRO_%02x arguments: "), op
);
5135 for (n
= 0; n
< nargs
; n
++)
5139 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5140 printf ("%s%s", get_FORM_name (form
),
5141 n
== nargs
- 1 ? "\n" : ", ");
5151 case DW_FORM_block1
:
5152 case DW_FORM_block2
:
5153 case DW_FORM_block4
:
5155 case DW_FORM_string
:
5157 case DW_FORM_sec_offset
:
5160 error (_("Invalid extension opcode form %s\n"),
5161 get_FORM_name (form
));
5177 error (_(".debug_macro section not zero terminated\n"));
5181 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5187 case DW_MACRO_start_file
:
5189 unsigned int filenum
;
5190 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5192 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5194 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
5197 if ((flags
& 2) == 0)
5198 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5201 = get_line_filename_and_dirname (line_offset
, filenum
,
5203 if (file_name
== NULL
)
5204 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5207 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5209 dir_name
!= NULL
? (const char *) dir_name
: "",
5210 dir_name
!= NULL
? "/" : "", file_name
);
5214 case DW_MACRO_end_file
:
5215 printf (_(" DW_MACRO_end_file\n"));
5218 case DW_MACRO_define
:
5219 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5222 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5223 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5227 case DW_MACRO_undef
:
5228 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5231 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5232 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5236 case DW_MACRO_define_strp
:
5237 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5239 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5240 string
= fetch_indirect_string (offset
);
5241 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5245 case DW_MACRO_undef_strp
:
5246 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5248 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5249 string
= fetch_indirect_string (offset
);
5250 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5254 case DW_MACRO_import
:
5255 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5256 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5257 (unsigned long) offset
);
5260 case DW_MACRO_define_sup
:
5261 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5263 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5264 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5265 lineno
, (unsigned long) offset
);
5268 case DW_MACRO_undef_sup
:
5269 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5271 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5272 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5273 lineno
, (unsigned long) offset
);
5276 case DW_MACRO_import_sup
:
5277 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5278 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5279 (unsigned long) offset
);
5283 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5285 error (_(" Unknown macro opcode %02x seen\n"), op
);
5290 /* Skip over unhandled opcodes. */
5292 unsigned char *desc
= extended_ops
[op
];
5293 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
5297 printf (_(" DW_MACRO_%02x\n"), op
);
5300 printf (_(" DW_MACRO_%02x -"), op
);
5301 for (n
= 0; n
< nargs
; n
++)
5305 /* DW_FORM_implicit_const is not expected here. */
5306 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5308 = read_and_display_attr_value (0, val
, 0,
5309 curr
, end
, 0, 0, offset_size
,
5310 version
, NULL
, 0, NULL
,
5328 display_debug_abbrev (struct dwarf_section
*section
,
5329 void *file ATTRIBUTE_UNUSED
)
5331 abbrev_entry
*entry
;
5332 unsigned char *start
= section
->start
;
5333 unsigned char *end
= start
+ section
->size
;
5335 introduce (section
, FALSE
);
5339 unsigned char *last
;
5344 start
= process_abbrev_section (start
, end
);
5346 if (first_abbrev
== NULL
)
5349 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5351 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5355 printf (" %ld %s [%s]\n",
5357 get_TAG_name (entry
->tag
),
5358 entry
->children
? _("has children") : _("no children"));
5360 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5362 printf (" %-18s %s",
5363 get_AT_name (attr
->attribute
),
5364 get_FORM_name (attr
->form
));
5365 if (attr
->form
== DW_FORM_implicit_const
)
5366 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5378 /* Return true when ADDR is the maximum address, when addresses are
5379 POINTER_SIZE bytes long. */
5382 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5384 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5385 return ((addr
& mask
) == mask
);
5388 /* Display a view pair list starting at *VSTART_PTR and ending at
5389 VLISTEND within SECTION. */
5392 display_view_pair_list (struct dwarf_section
*section
,
5393 unsigned char **vstart_ptr
,
5394 unsigned int debug_info_entry
,
5395 unsigned char *vlistend
)
5397 unsigned char *vstart
= *vstart_ptr
;
5398 unsigned char *section_end
= section
->start
+ section
->size
;
5399 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5401 if (vlistend
< section_end
)
5402 section_end
= vlistend
;
5406 while (vstart
< section_end
)
5408 dwarf_vma off
= vstart
- section
->start
;
5409 dwarf_vma vbegin
, vend
;
5411 unsigned int bytes_read
;
5412 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5413 vstart
+= bytes_read
;
5414 if (vstart
== section_end
)
5416 vstart
-= bytes_read
;
5420 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5421 vstart
+= bytes_read
;
5423 printf (" %8.8lx ", (unsigned long) off
);
5425 print_dwarf_view (vbegin
, pointer_size
, 1);
5426 print_dwarf_view (vend
, pointer_size
, 1);
5427 printf (_("location view pair\n"));
5431 *vstart_ptr
= vstart
;
5434 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5437 display_loc_list (struct dwarf_section
*section
,
5438 unsigned char **start_ptr
,
5439 unsigned int debug_info_entry
,
5441 dwarf_vma base_address
,
5442 unsigned char **vstart_ptr
,
5445 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5446 unsigned char *section_end
= section
->start
+ section
->size
;
5447 unsigned long cu_offset
;
5448 unsigned int pointer_size
;
5449 unsigned int offset_size
;
5454 unsigned short length
;
5455 int need_frame_base
;
5457 if (debug_info_entry
>= num_debug_info_entries
)
5459 warn (_("No debug information available for loc lists of entry: %u\n"),
5464 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5465 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5466 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5467 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5469 if (pointer_size
< 2 || pointer_size
> 8)
5471 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5472 pointer_size
, debug_info_entry
);
5478 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5479 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5481 if (start
+ 2 * pointer_size
> section_end
)
5483 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5484 (unsigned long) offset
);
5488 printf (" %8.8lx ", (unsigned long) off
);
5490 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5491 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5493 if (begin
== 0 && end
== 0)
5495 /* PR 18374: In a object file we can have a location list that
5496 starts with a begin and end of 0 because there are relocations
5497 that need to be applied to the addresses. Actually applying
5498 the relocations now does not help as they will probably resolve
5499 to 0, since the object file has not been fully linked. Real
5500 end of list markers will not have any relocations against them. */
5501 if (! reloc_at (section
, off
)
5502 && ! reloc_at (section
, off
+ pointer_size
))
5504 printf (_("<End of list>\n"));
5509 /* Check base address specifiers. */
5510 if (is_max_address (begin
, pointer_size
)
5511 && !is_max_address (end
, pointer_size
))
5514 print_dwarf_vma (begin
, pointer_size
);
5515 print_dwarf_vma (end
, pointer_size
);
5516 printf (_("(base address)\n"));
5522 unsigned int bytes_read
;
5524 off
= offset
+ (vstart
- *start_ptr
);
5526 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5527 vstart
+= bytes_read
;
5528 print_dwarf_view (vbegin
, pointer_size
, 1);
5530 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5531 vstart
+= bytes_read
;
5532 print_dwarf_view (vend
, pointer_size
, 1);
5534 printf (_("views at %8.8lx for:\n %*s "),
5535 (unsigned long) off
, 8, "");
5538 if (start
+ 2 > section_end
)
5540 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5541 (unsigned long) offset
);
5545 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5547 if (start
+ length
> section_end
)
5549 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5550 (unsigned long) offset
);
5554 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5555 print_dwarf_vma (end
+ base_address
, pointer_size
);
5558 need_frame_base
= decode_location_expression (start
,
5563 cu_offset
, section
);
5566 if (need_frame_base
&& !has_frame_base
)
5567 printf (_(" [without DW_AT_frame_base]"));
5569 if (begin
== end
&& vbegin
== vend
)
5570 fputs (_(" (start == end)"), stdout
);
5571 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5572 fputs (_(" (start > end)"), stdout
);
5580 *vstart_ptr
= vstart
;
5583 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5586 display_loclists_list (struct dwarf_section
*section
,
5587 unsigned char **start_ptr
,
5588 unsigned int debug_info_entry
,
5590 dwarf_vma base_address
,
5591 unsigned char **vstart_ptr
,
5594 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5595 unsigned char *section_end
= section
->start
+ section
->size
;
5596 unsigned long cu_offset
;
5597 unsigned int pointer_size
;
5598 unsigned int offset_size
;
5600 unsigned int bytes_read
;
5602 /* Initialize it due to a false compiler warning. */
5603 dwarf_vma begin
= -1, vbegin
= -1;
5604 dwarf_vma end
= -1, vend
= -1;
5606 int need_frame_base
;
5608 if (debug_info_entry
>= num_debug_info_entries
)
5610 warn (_("No debug information available for "
5611 "loclists lists of entry: %u\n"),
5616 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5617 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5618 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5619 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5621 if (pointer_size
< 2 || pointer_size
> 8)
5623 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5624 pointer_size
, debug_info_entry
);
5630 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5631 enum dwarf_location_list_entry_type llet
;
5633 if (start
+ 1 > section_end
)
5635 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5636 (unsigned long) offset
);
5640 printf (" %8.8lx ", (unsigned long) off
);
5642 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5644 if (vstart
&& llet
== DW_LLE_offset_pair
)
5646 off
= offset
+ (vstart
- *start_ptr
);
5648 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5649 vstart
+= bytes_read
;
5650 print_dwarf_view (vbegin
, pointer_size
, 1);
5652 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5653 vstart
+= bytes_read
;
5654 print_dwarf_view (vend
, pointer_size
, 1);
5656 printf (_("views at %8.8lx for:\n %*s "),
5657 (unsigned long) off
, 8, "");
5662 case DW_LLE_end_of_list
:
5663 printf (_("<End of list>\n"));
5665 case DW_LLE_offset_pair
:
5666 begin
= read_uleb128 (start
, &bytes_read
, section_end
);
5667 start
+= bytes_read
;
5668 end
= read_uleb128 (start
, &bytes_read
, section_end
);
5669 start
+= bytes_read
;
5671 case DW_LLE_base_address
:
5672 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
5674 print_dwarf_vma (base_address
, pointer_size
);
5675 printf (_("(base address)\n"));
5677 #ifdef DW_LLE_view_pair
5678 case DW_LLE_view_pair
:
5680 printf (_("View pair entry in loclist with locviews attribute\n"));
5681 vbegin
= read_uleb128 (start
, &bytes_read
, section_end
);
5682 start
+= bytes_read
;
5683 print_dwarf_view (vbegin
, pointer_size
, 1);
5685 vend
= read_uleb128 (start
, &bytes_read
, section_end
);
5686 start
+= bytes_read
;
5687 print_dwarf_view (vend
, pointer_size
, 1);
5689 printf (_("views for:\n"));
5693 error (_("Invalid location list entry type %d\n"), llet
);
5696 if (llet
== DW_LLE_end_of_list
)
5698 if (llet
!= DW_LLE_offset_pair
)
5701 if (start
+ 2 > section_end
)
5703 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5704 (unsigned long) offset
);
5708 length
= read_uleb128 (start
, &bytes_read
, section_end
);
5709 start
+= bytes_read
;
5711 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5712 print_dwarf_vma (end
+ base_address
, pointer_size
);
5715 need_frame_base
= decode_location_expression (start
,
5720 cu_offset
, section
);
5723 if (need_frame_base
&& !has_frame_base
)
5724 printf (_(" [without DW_AT_frame_base]"));
5726 if (begin
== end
&& vbegin
== vend
)
5727 fputs (_(" (start == end)"), stdout
);
5728 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5729 fputs (_(" (start > end)"), stdout
);
5737 if (vbegin
!= vm1
|| vend
!= vm1
)
5738 printf (_("Trailing view pair not used in a range"));
5741 *vstart_ptr
= vstart
;
5744 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
5745 right-adjusted in a field of length LEN, and followed by a space. */
5748 print_addr_index (unsigned int idx
, unsigned int len
)
5750 static char buf
[15];
5751 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
5752 printf ("%*s ", len
, buf
);
5755 /* Display a location list from a .dwo section. It uses address indexes rather
5756 than embedded addresses. This code closely follows display_loc_list, but the
5757 two are sufficiently different that combining things is very ugly. */
5760 display_loc_list_dwo (struct dwarf_section
*section
,
5761 unsigned char **start_ptr
,
5762 unsigned int debug_info_entry
,
5764 unsigned char **vstart_ptr
,
5767 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5768 unsigned char *section_end
= section
->start
+ section
->size
;
5769 unsigned long cu_offset
;
5770 unsigned int pointer_size
;
5771 unsigned int offset_size
;
5774 unsigned short length
;
5775 int need_frame_base
;
5777 unsigned int bytes_read
;
5779 if (debug_info_entry
>= num_debug_info_entries
)
5781 warn (_("No debug information for loc lists of entry: %u\n"),
5786 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5787 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5788 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5789 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5791 if (pointer_size
< 2 || pointer_size
> 8)
5793 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5794 pointer_size
, debug_info_entry
);
5800 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
5802 if (start
>= section_end
)
5804 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5805 (unsigned long) offset
);
5809 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
5822 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
5824 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5825 vstart
+= bytes_read
;
5826 print_dwarf_view (view
, 8, 1);
5828 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5829 vstart
+= bytes_read
;
5830 print_dwarf_view (view
, 8, 1);
5832 printf (_("views at %8.8lx for:\n %*s "),
5833 (unsigned long) off
, 8, "");
5841 case 0: /* A terminating entry. */
5843 *vstart_ptr
= vstart
;
5844 printf (_("<End of list>\n"));
5846 case 1: /* A base-address entry. */
5847 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5848 start
+= bytes_read
;
5849 print_addr_index (idx
, 8);
5850 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
5851 printf (_("(base address selection entry)\n"));
5853 case 2: /* A start/end entry. */
5854 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5855 start
+= bytes_read
;
5856 print_addr_index (idx
, 8);
5857 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5858 start
+= bytes_read
;
5859 print_addr_index (idx
, 8);
5861 case 3: /* A start/length entry. */
5862 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5863 start
+= bytes_read
;
5864 print_addr_index (idx
, 8);
5865 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5866 printf ("%08x ", idx
);
5868 case 4: /* An offset pair entry. */
5869 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5870 printf ("%08x ", idx
);
5871 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5872 printf ("%08x ", idx
);
5875 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
5877 *vstart_ptr
= vstart
;
5881 if (start
+ 2 > section_end
)
5883 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5884 (unsigned long) offset
);
5888 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5889 if (start
+ length
> section_end
)
5891 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5892 (unsigned long) offset
);
5897 need_frame_base
= decode_location_expression (start
,
5902 cu_offset
, section
);
5905 if (need_frame_base
&& !has_frame_base
)
5906 printf (_(" [without DW_AT_frame_base]"));
5914 *vstart_ptr
= vstart
;
5917 /* Sort array of indexes in ascending order of loc_offsets[idx] and
5920 static dwarf_vma
*loc_offsets
, *loc_views
;
5923 loc_offsets_compar (const void *ap
, const void *bp
)
5925 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
5926 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
5928 int ret
= (a
> b
) - (b
> a
);
5932 a
= loc_views
[*(const unsigned int *) ap
];
5933 b
= loc_views
[*(const unsigned int *) bp
];
5935 ret
= (a
> b
) - (b
> a
);
5941 display_debug_loc (struct dwarf_section
*section
, void *file
)
5943 unsigned char *start
= section
->start
, *vstart
= NULL
;
5944 unsigned long bytes
;
5945 unsigned char *section_begin
= start
;
5946 unsigned int num_loc_list
= 0;
5947 unsigned long last_offset
= 0;
5948 unsigned long last_view
= 0;
5949 unsigned int first
= 0;
5952 int seen_first_offset
= 0;
5953 int locs_sorted
= 1;
5954 unsigned char *next
= start
, *vnext
= vstart
;
5955 unsigned int *array
= NULL
;
5956 const char *suffix
= strrchr (section
->name
, '.');
5958 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
5959 dwarf_vma expected_start
= 0;
5961 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
5964 bytes
= section
->size
;
5968 printf (_("\nThe %s section is empty.\n"), section
->name
);
5974 unsigned char *hdrptr
= section_begin
;
5975 dwarf_vma ll_length
;
5976 unsigned short ll_version
;
5977 unsigned char *end
= section_begin
+ section
->size
;
5978 unsigned char address_size
, segment_selector_size
;
5979 uint32_t offset_entry_count
;
5981 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
5982 if (ll_length
== 0xffffffff)
5983 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
5985 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
5986 if (ll_version
!= 5)
5988 warn (_("The %s section contains corrupt or "
5989 "unsupported version number: %d.\n"),
5990 section
->name
, ll_version
);
5994 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
5996 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
5997 if (segment_selector_size
!= 0)
5999 warn (_("The %s section contains "
6000 "unsupported segment selector size: %d.\n"),
6001 section
->name
, segment_selector_size
);
6005 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6006 if (offset_entry_count
!= 0)
6008 warn (_("The %s section contains "
6009 "unsupported offset entry count: %d.\n"),
6010 section
->name
, offset_entry_count
);
6014 expected_start
= hdrptr
- section_begin
;
6017 if (load_debug_info (file
) == 0)
6019 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6024 /* Check the order of location list in .debug_info section. If
6025 offsets of location lists are in the ascending order, we can
6026 use `debug_information' directly. */
6027 for (i
= 0; i
< num_debug_info_entries
; i
++)
6031 num
= debug_information
[i
].num_loc_offsets
;
6032 if (num
> num_loc_list
)
6035 /* Check if we can use `debug_information' directly. */
6036 if (locs_sorted
&& num
!= 0)
6038 if (!seen_first_offset
)
6040 /* This is the first location list. */
6041 last_offset
= debug_information
[i
].loc_offsets
[0];
6042 last_view
= debug_information
[i
].loc_views
[0];
6044 seen_first_offset
= 1;
6050 for (; j
< num
; j
++)
6053 debug_information
[i
].loc_offsets
[j
]
6054 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6055 && last_view
> debug_information
[i
].loc_views
[j
]))
6060 last_offset
= debug_information
[i
].loc_offsets
[j
];
6061 last_view
= debug_information
[i
].loc_views
[j
];
6066 if (!seen_first_offset
)
6067 error (_("No location lists in .debug_info section!\n"));
6069 if (debug_information
[first
].num_loc_offsets
> 0
6070 && debug_information
[first
].loc_offsets
[0] != expected_start
6071 && debug_information
[first
].loc_views
[0] != expected_start
)
6072 warn (_("Location lists in %s section start at 0x%s\n"),
6074 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6077 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6079 introduce (section
, FALSE
);
6081 if (reloc_at (section
, 0))
6082 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6084 printf (_(" Offset Begin End Expression\n"));
6086 seen_first_offset
= 0;
6087 for (i
= first
; i
< num_debug_info_entries
; i
++)
6089 dwarf_vma offset
, voffset
;
6090 dwarf_vma base_address
;
6096 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6098 loc_offsets
= debug_information
[i
].loc_offsets
;
6099 loc_views
= debug_information
[i
].loc_views
;
6100 qsort (array
, debug_information
[i
].num_loc_offsets
,
6101 sizeof (*array
), loc_offsets_compar
);
6104 int adjacent_view_loclists
= 1;
6105 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6107 j
= locs_sorted
? k
: array
[k
];
6109 && (debug_information
[i
].loc_offsets
[locs_sorted
6110 ? k
- 1 : array
[k
- 1]]
6111 == debug_information
[i
].loc_offsets
[j
])
6112 && (debug_information
[i
].loc_views
[locs_sorted
6113 ? k
- 1 : array
[k
- 1]]
6114 == debug_information
[i
].loc_views
[j
]))
6116 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6117 offset
= debug_information
[i
].loc_offsets
[j
];
6118 next
= section_begin
+ offset
;
6119 voffset
= debug_information
[i
].loc_views
[j
];
6121 vnext
= section_begin
+ voffset
;
6124 base_address
= debug_information
[i
].base_address
;
6126 if (vnext
&& vnext
< next
)
6129 display_view_pair_list (section
, &vstart
, i
, next
);
6134 if (!seen_first_offset
|| !adjacent_view_loclists
)
6135 seen_first_offset
= 1;
6139 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6140 (unsigned long) (start
- section_begin
),
6141 (unsigned long) offset
);
6142 else if (start
> next
)
6143 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6144 (unsigned long) (start
- section_begin
),
6145 (unsigned long) offset
);
6150 if (offset
>= bytes
)
6152 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6153 (unsigned long) offset
);
6157 if (vnext
&& voffset
>= bytes
)
6159 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6160 (unsigned long) voffset
);
6167 display_loc_list_dwo (section
, &start
, i
, offset
,
6168 &vstart
, has_frame_base
);
6170 display_loc_list (section
, &start
, i
, offset
, base_address
,
6171 &vstart
, has_frame_base
);
6176 warn (_("DWO is not yet supported.\n"));
6178 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6179 &vstart
, has_frame_base
);
6182 /* FIXME: this arrangement is quite simplistic. Nothing
6183 requires locview lists to be adjacent to corresponding
6184 loclists, and a single loclist could be augmented by
6185 different locview lists, and vice-versa, unlikely as it
6186 is that it would make sense to do so. Hopefully we'll
6187 have view pair support built into loclists before we ever
6188 need to address all these possibilities. */
6189 if (adjacent_view_loclists
&& vnext
6190 && vnext
!= start
&& vstart
!= next
)
6192 adjacent_view_loclists
= 0;
6193 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6196 if (vnext
&& vnext
== start
)
6197 display_view_pair_list (section
, &start
, i
, vstart
);
6201 if (start
< section
->start
+ section
->size
)
6202 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6203 "There are %ld unused bytes at the end of section %s\n",
6204 (long) (section
->start
+ section
->size
- start
)),
6205 (long) (section
->start
+ section
->size
- start
), section
->name
);
6212 display_debug_str (struct dwarf_section
*section
,
6213 void *file ATTRIBUTE_UNUSED
)
6215 unsigned char *start
= section
->start
;
6216 unsigned long bytes
= section
->size
;
6217 dwarf_vma addr
= section
->address
;
6221 printf (_("\nThe %s section is empty.\n"), section
->name
);
6225 introduce (section
, FALSE
);
6233 lbytes
= (bytes
> 16 ? 16 : bytes
);
6235 printf (" 0x%8.8lx ", (unsigned long) addr
);
6237 for (j
= 0; j
< 16; j
++)
6240 printf ("%2.2x", start
[j
]);
6248 for (j
= 0; j
< lbytes
; j
++)
6251 if (k
>= ' ' && k
< 0x80)
6270 display_debug_info (struct dwarf_section
*section
, void *file
)
6272 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6276 display_debug_types (struct dwarf_section
*section
, void *file
)
6278 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6282 display_trace_info (struct dwarf_section
*section
, void *file
)
6284 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6288 display_debug_aranges (struct dwarf_section
*section
,
6289 void *file ATTRIBUTE_UNUSED
)
6291 unsigned char *start
= section
->start
;
6292 unsigned char *end
= start
+ section
->size
;
6294 introduce (section
, FALSE
);
6296 /* It does not matter if this load fails,
6297 we test for that later on. */
6298 load_debug_info (file
);
6302 unsigned char *hdrptr
;
6303 DWARF2_Internal_ARange arange
;
6304 unsigned char *addr_ranges
;
6307 unsigned long sec_off
;
6308 unsigned char address_size
;
6310 unsigned int offset_size
;
6311 unsigned int initial_length_size
;
6315 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6316 if (arange
.ar_length
== 0xffffffff)
6318 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6320 initial_length_size
= 12;
6325 initial_length_size
= 4;
6328 sec_off
= hdrptr
- section
->start
;
6329 if (sec_off
+ arange
.ar_length
< sec_off
6330 || sec_off
+ arange
.ar_length
> section
->size
)
6332 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6334 sec_off
- initial_length_size
,
6335 dwarf_vmatoa ("x", arange
.ar_length
));
6339 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6340 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6342 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6343 && num_debug_info_entries
> 0
6344 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6345 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6346 (unsigned long) arange
.ar_info_offset
, section
->name
);
6348 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6349 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6351 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6353 /* PR 19872: A version number of 0 probably means that there is
6354 padding at the end of the .debug_aranges section. Gold puts
6355 it there when performing an incremental link, for example.
6356 So do not generate a warning in this case. */
6357 if (arange
.ar_version
)
6358 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6362 printf (_(" Length: %ld\n"),
6363 (long) arange
.ar_length
);
6364 printf (_(" Version: %d\n"), arange
.ar_version
);
6365 printf (_(" Offset into .debug_info: 0x%lx\n"),
6366 (unsigned long) arange
.ar_info_offset
);
6367 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6368 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6370 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6372 /* PR 17512: file: 001-108546-0.001:0.1. */
6373 if (address_size
== 0 || address_size
> 8)
6375 error (_("Invalid address size in %s section!\n"),
6380 /* The DWARF spec does not require that the address size be a power
6381 of two, but we do. This will have to change if we ever encounter
6382 an uneven architecture. */
6383 if ((address_size
& (address_size
- 1)) != 0)
6385 warn (_("Pointer size + Segment size is not a power of two.\n"));
6389 if (address_size
> 4)
6390 printf (_("\n Address Length\n"));
6392 printf (_("\n Address Length\n"));
6394 addr_ranges
= hdrptr
;
6396 /* Must pad to an alignment boundary that is twice the address size. */
6397 excess
= (hdrptr
- start
) % (2 * address_size
);
6399 addr_ranges
+= (2 * address_size
) - excess
;
6401 start
+= arange
.ar_length
+ initial_length_size
;
6403 while (addr_ranges
+ 2 * address_size
<= start
)
6405 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6406 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6409 print_dwarf_vma (address
, address_size
);
6410 print_dwarf_vma (length
, address_size
);
6420 /* Comparison function for qsort. */
6422 comp_addr_base (const void * v0
, const void * v1
)
6424 debug_info
* info0
= (debug_info
*) v0
;
6425 debug_info
* info1
= (debug_info
*) v1
;
6426 return info0
->addr_base
- info1
->addr_base
;
6429 /* Display the debug_addr section. */
6431 display_debug_addr (struct dwarf_section
*section
,
6434 debug_info
**debug_addr_info
;
6435 unsigned char *entry
;
6440 if (section
->size
== 0)
6442 printf (_("\nThe %s section is empty.\n"), section
->name
);
6446 if (load_debug_info (file
) == 0)
6448 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6453 introduce (section
, FALSE
);
6455 /* PR 17531: file: cf38d01b.
6456 We use xcalloc because a corrupt file may not have initialised all of the
6457 fields in the debug_info structure, which means that the sort below might
6458 try to move uninitialised data. */
6459 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6460 sizeof (debug_info
*));
6463 for (i
= 0; i
< num_debug_info_entries
; i
++)
6464 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6466 /* PR 17531: file: cf38d01b. */
6467 if (debug_information
[i
].addr_base
>= section
->size
)
6468 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6469 (unsigned long) debug_information
[i
].addr_base
, i
);
6471 debug_addr_info
[count
++] = debug_information
+ i
;
6474 /* Add a sentinel to make iteration convenient. */
6475 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6476 debug_addr_info
[count
]->addr_base
= section
->size
;
6477 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6479 for (i
= 0; i
< count
; i
++)
6482 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6484 printf (_(" For compilation unit at offset 0x%s:\n"),
6485 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6487 printf (_("\tIndex\tAddress\n"));
6488 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6489 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6493 dwarf_vma base
= byte_get (entry
, address_size
);
6494 printf (_("\t%d:\t"), idx
);
6495 print_dwarf_vma (base
, address_size
);
6497 entry
+= address_size
;
6503 free (debug_addr_info
);
6507 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6509 display_debug_str_offsets (struct dwarf_section
*section
,
6510 void *file ATTRIBUTE_UNUSED
)
6512 if (section
->size
== 0)
6514 printf (_("\nThe %s section is empty.\n"), section
->name
);
6517 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6518 what the offset size is for this section. */
6522 /* Each debug_information[x].range_lists[y] gets this representation for
6523 sorting purposes. */
6527 /* The debug_information[x].range_lists[y] value. */
6528 dwarf_vma ranges_offset
;
6530 /* Original debug_information to find parameters of the data. */
6531 debug_info
*debug_info_p
;
6534 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6537 range_entry_compar (const void *ap
, const void *bp
)
6539 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6540 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6541 const dwarf_vma a
= a_re
->ranges_offset
;
6542 const dwarf_vma b
= b_re
->ranges_offset
;
6544 return (a
> b
) - (b
> a
);
6548 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6549 unsigned int pointer_size
, unsigned long offset
,
6550 unsigned long base_address
)
6552 while (start
< finish
)
6557 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6558 if (start
>= finish
)
6560 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6563 printf (" %8.8lx ", offset
);
6565 if (begin
== 0 && end
== 0)
6567 printf (_("<End of list>\n"));
6571 /* Check base address specifiers. */
6572 if (is_max_address (begin
, pointer_size
)
6573 && !is_max_address (end
, pointer_size
))
6576 print_dwarf_vma (begin
, pointer_size
);
6577 print_dwarf_vma (end
, pointer_size
);
6578 printf ("(base address)\n");
6582 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6583 print_dwarf_vma (end
+ base_address
, pointer_size
);
6586 fputs (_("(start == end)"), stdout
);
6587 else if (begin
> end
)
6588 fputs (_("(start > end)"), stdout
);
6595 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
6596 unsigned int pointer_size
, unsigned long offset
,
6597 unsigned long base_address
)
6599 unsigned char *next
= start
;
6603 unsigned long off
= offset
+ (start
- next
);
6604 enum dwarf_range_list_entry rlet
;
6605 /* Initialize it due to a false compiler warning. */
6606 dwarf_vma begin
= -1, length
, end
= -1;
6607 unsigned int bytes_read
;
6609 if (start
+ 1 > finish
)
6611 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6616 printf (" %8.8lx ", off
);
6618 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
6622 case DW_RLE_end_of_list
:
6623 printf (_("<End of list>\n"));
6625 case DW_RLE_base_address
:
6626 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
6627 print_dwarf_vma (base_address
, pointer_size
);
6628 printf (_("(base address)\n"));
6630 case DW_RLE_start_length
:
6631 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6632 length
= read_uleb128 (start
, &bytes_read
, finish
);
6633 start
+= bytes_read
;
6634 end
= begin
+ length
;
6636 case DW_RLE_offset_pair
:
6637 begin
= read_uleb128 (start
, &bytes_read
, finish
);
6638 start
+= bytes_read
;
6639 end
= read_uleb128 (start
, &bytes_read
, finish
);
6640 start
+= bytes_read
;
6642 case DW_RLE_start_end
:
6643 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6644 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6647 error (_("Invalid range list entry type %d\n"), rlet
);
6648 rlet
= DW_RLE_end_of_list
;
6651 if (rlet
== DW_RLE_end_of_list
)
6653 if (rlet
== DW_RLE_base_address
)
6656 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6657 print_dwarf_vma (end
+ base_address
, pointer_size
);
6660 fputs (_("(start == end)"), stdout
);
6661 else if (begin
> end
)
6662 fputs (_("(start > end)"), stdout
);
6669 display_debug_ranges (struct dwarf_section
*section
,
6670 void *file ATTRIBUTE_UNUSED
)
6672 unsigned char *start
= section
->start
;
6673 unsigned char *last_start
= start
;
6674 unsigned long bytes
= section
->size
;
6675 unsigned char *section_begin
= start
;
6676 unsigned char *finish
= start
+ bytes
;
6677 unsigned int num_range_list
, i
;
6678 struct range_entry
*range_entries
, *range_entry_fill
;
6679 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
6680 /* Initialize it due to a false compiler warning. */
6681 unsigned char address_size
= 0;
6685 printf (_("\nThe %s section is empty.\n"), section
->name
);
6691 dwarf_vma initial_length
;
6692 unsigned int initial_length_size
;
6693 unsigned char segment_selector_size
;
6694 unsigned int offset_size
, offset_entry_count
;
6695 unsigned short version
;
6697 /* Get and check the length of the block. */
6698 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
6700 if (initial_length
== 0xffffffff)
6702 /* This section is 64-bit DWARF 3. */
6703 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
6705 initial_length_size
= 12;
6710 initial_length_size
= 4;
6713 if (initial_length
+ initial_length_size
> section
->size
)
6715 /* If the length field has a relocation against it, then we should
6716 not complain if it is inaccurate (and probably negative).
6717 It is copied from .debug_line handling code. */
6718 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
6720 initial_length
= (finish
- start
) - initial_length_size
;
6724 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6725 (long) initial_length
);
6730 /* Get and check the version number. */
6731 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
6735 warn (_("Only DWARF version 5 debug_rnglists info "
6736 "is currently supported.\n"));
6740 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
6742 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
6743 if (segment_selector_size
!= 0)
6745 warn (_("The %s section contains "
6746 "unsupported segment selector size: %d.\n"),
6747 section
->name
, segment_selector_size
);
6751 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
6752 if (offset_entry_count
!= 0)
6754 warn (_("The %s section contains "
6755 "unsupported offset entry count: %u.\n"),
6756 section
->name
, offset_entry_count
);
6761 if (load_debug_info (file
) == 0)
6763 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6769 for (i
= 0; i
< num_debug_info_entries
; i
++)
6770 num_range_list
+= debug_information
[i
].num_range_lists
;
6772 if (num_range_list
== 0)
6774 /* This can happen when the file was compiled with -gsplit-debug
6775 which removes references to range lists from the primary .o file. */
6776 printf (_("No range lists in .debug_info section.\n"));
6780 range_entries
= (struct range_entry
*)
6781 xmalloc (sizeof (*range_entries
) * num_range_list
);
6782 range_entry_fill
= range_entries
;
6784 for (i
= 0; i
< num_debug_info_entries
; i
++)
6786 debug_info
*debug_info_p
= &debug_information
[i
];
6789 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
6791 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
6792 range_entry_fill
->debug_info_p
= debug_info_p
;
6797 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
6798 range_entry_compar
);
6800 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
6801 warn (_("Range lists in %s section start at 0x%lx\n"),
6802 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
6804 introduce (section
, FALSE
);
6806 printf (_(" Offset Begin End\n"));
6808 for (i
= 0; i
< num_range_list
; i
++)
6810 struct range_entry
*range_entry
= &range_entries
[i
];
6811 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
6812 unsigned int pointer_size
;
6814 unsigned char *next
;
6815 dwarf_vma base_address
;
6817 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
6818 offset
= range_entry
->ranges_offset
;
6819 next
= section_begin
+ offset
;
6820 base_address
= debug_info_p
->base_address
;
6822 /* PR 17512: file: 001-101485-0.001:0.1. */
6823 if (pointer_size
< 2 || pointer_size
> 8)
6825 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
6826 pointer_size
, (unsigned long) offset
);
6830 if (next
< section_begin
|| next
>= finish
)
6832 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
6833 (unsigned long) offset
, i
);
6837 if (dwarf_check
!= 0 && i
> 0)
6840 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
6841 (unsigned long) (start
- section_begin
),
6842 (unsigned long) (next
- section_begin
), section
->name
);
6843 else if (start
> next
)
6845 if (next
== last_start
)
6847 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
6848 (unsigned long) (start
- section_begin
),
6849 (unsigned long) (next
- section_begin
), section
->name
);
6856 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
6857 (start
, finish
, pointer_size
, offset
, base_address
);
6861 free (range_entries
);
6866 typedef struct Frame_Chunk
6868 struct Frame_Chunk
*next
;
6869 unsigned char *chunk_start
;
6871 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6872 short int *col_type
;
6875 unsigned int code_factor
;
6879 unsigned int cfa_reg
;
6880 dwarf_vma cfa_offset
;
6882 unsigned char fde_encoding
;
6883 unsigned char cfa_exp
;
6884 unsigned char ptr_size
;
6885 unsigned char segment_size
;
6889 static const char *const *dwarf_regnames
;
6890 static unsigned int dwarf_regnames_count
;
6892 /* A marker for a col_type that means this column was never referenced
6893 in the frame info. */
6894 #define DW_CFA_unreferenced (-1)
6896 /* Return 0 if no more space is needed, 1 if more space is needed,
6897 -1 for invalid reg. */
6900 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
6902 unsigned int prev
= fc
->ncols
;
6904 if (reg
< (unsigned int) fc
->ncols
)
6907 if (dwarf_regnames_count
6908 && reg
> dwarf_regnames_count
)
6911 fc
->ncols
= reg
+ 1;
6912 /* PR 17512: file: 10450-2643-0.004.
6913 If reg == -1 then this can happen... */
6917 /* PR 17512: file: 2844a11d. */
6918 if (fc
->ncols
> 1024)
6920 error (_("Unfeasibly large register number: %u\n"), reg
);
6922 /* FIXME: 1024 is an arbitrary limit. Increase it if
6923 we ever encounter a valid binary that exceeds it. */
6927 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
6928 sizeof (short int));
6929 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
6930 /* PR 17512: file:002-10025-0.005. */
6931 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
6933 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
6939 while (prev
< fc
->ncols
)
6941 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
6942 fc
->col_offset
[prev
] = 0;
6948 static const char *const dwarf_regnames_i386
[] =
6950 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6951 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6952 "eip", "eflags", NULL
, /* 8 - 10 */
6953 "st0", "st1", "st2", "st3", /* 11 - 14 */
6954 "st4", "st5", "st6", "st7", /* 15 - 18 */
6955 NULL
, NULL
, /* 19 - 20 */
6956 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
6957 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
6958 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
6959 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
6960 "fcw", "fsw", "mxcsr", /* 37 - 39 */
6961 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
6962 "tr", "ldtr", /* 48 - 49 */
6963 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
6964 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
6965 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
6966 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
6967 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
6968 NULL
, NULL
, NULL
, /* 90 - 92 */
6969 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
6972 static const char *const dwarf_regnames_iamcu
[] =
6974 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6975 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6976 "eip", "eflags", NULL
, /* 8 - 10 */
6977 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
6978 NULL
, NULL
, /* 19 - 20 */
6979 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
6980 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
6981 NULL
, NULL
, NULL
, /* 37 - 39 */
6982 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
6983 "tr", "ldtr", /* 48 - 49 */
6984 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
6985 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
6986 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
6987 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
6988 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
6989 NULL
, NULL
, NULL
, /* 90 - 92 */
6990 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
6994 init_dwarf_regnames_i386 (void)
6996 dwarf_regnames
= dwarf_regnames_i386
;
6997 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7001 init_dwarf_regnames_iamcu (void)
7003 dwarf_regnames
= dwarf_regnames_iamcu
;
7004 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7007 static const char *const dwarf_regnames_x86_64
[] =
7009 "rax", "rdx", "rcx", "rbx",
7010 "rsi", "rdi", "rbp", "rsp",
7011 "r8", "r9", "r10", "r11",
7012 "r12", "r13", "r14", "r15",
7014 "xmm0", "xmm1", "xmm2", "xmm3",
7015 "xmm4", "xmm5", "xmm6", "xmm7",
7016 "xmm8", "xmm9", "xmm10", "xmm11",
7017 "xmm12", "xmm13", "xmm14", "xmm15",
7018 "st0", "st1", "st2", "st3",
7019 "st4", "st5", "st6", "st7",
7020 "mm0", "mm1", "mm2", "mm3",
7021 "mm4", "mm5", "mm6", "mm7",
7023 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7024 "fs.base", "gs.base", NULL
, NULL
,
7026 "mxcsr", "fcw", "fsw",
7027 "xmm16", "xmm17", "xmm18", "xmm19",
7028 "xmm20", "xmm21", "xmm22", "xmm23",
7029 "xmm24", "xmm25", "xmm26", "xmm27",
7030 "xmm28", "xmm29", "xmm30", "xmm31",
7031 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7032 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7033 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7034 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7035 NULL
, NULL
, NULL
, /* 115 - 117 */
7036 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7040 init_dwarf_regnames_x86_64 (void)
7042 dwarf_regnames
= dwarf_regnames_x86_64
;
7043 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7046 static const char *const dwarf_regnames_aarch64
[] =
7048 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7049 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7050 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7051 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7052 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7053 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7054 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7055 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7056 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7057 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7058 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7059 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7063 init_dwarf_regnames_aarch64 (void)
7065 dwarf_regnames
= dwarf_regnames_aarch64
;
7066 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7069 static const char *const dwarf_regnames_s390
[] =
7071 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7072 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7073 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7074 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7075 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7076 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7077 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7078 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7079 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7082 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7083 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7087 init_dwarf_regnames_s390 (void)
7089 dwarf_regnames
= dwarf_regnames_s390
;
7090 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7093 static const char *const dwarf_regnames_riscv
[] =
7095 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7096 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7097 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7098 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7099 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7100 "fs0", "fs1", /* 40 - 41 */
7101 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7102 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7103 "fs10", "fs11", /* 58 - 59 */
7104 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7108 init_dwarf_regnames_riscv (void)
7110 dwarf_regnames
= dwarf_regnames_riscv
;
7111 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_riscv
);
7115 init_dwarf_regnames (unsigned int e_machine
)
7120 init_dwarf_regnames_i386 ();
7124 init_dwarf_regnames_iamcu ();
7130 init_dwarf_regnames_x86_64 ();
7134 init_dwarf_regnames_aarch64 ();
7138 init_dwarf_regnames_s390 ();
7142 init_dwarf_regnames_riscv ();
7151 regname (unsigned int regno
, int row
)
7153 static char reg
[64];
7156 && regno
< dwarf_regnames_count
7157 && dwarf_regnames
[regno
] != NULL
)
7160 return dwarf_regnames
[regno
];
7161 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
7162 dwarf_regnames
[regno
]);
7165 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7170 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7175 if (*max_regs
!= fc
->ncols
)
7176 *max_regs
= fc
->ncols
;
7178 if (*need_col_headers
)
7180 static const char *sloc
= " LOC";
7182 *need_col_headers
= 0;
7184 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7186 for (r
= 0; r
< *max_regs
; r
++)
7187 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7192 printf ("%-5s ", regname (r
, 1));
7198 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7200 strcpy (tmp
, "exp");
7202 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7203 printf ("%-8s ", tmp
);
7205 for (r
= 0; r
< fc
->ncols
; r
++)
7207 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7209 switch (fc
->col_type
[r
])
7211 case DW_CFA_undefined
:
7214 case DW_CFA_same_value
:
7218 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7220 case DW_CFA_val_offset
:
7221 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7223 case DW_CFA_register
:
7224 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7226 case DW_CFA_expression
:
7227 strcpy (tmp
, "exp");
7229 case DW_CFA_val_expression
:
7230 strcpy (tmp
, "vexp");
7233 strcpy (tmp
, "n/a");
7236 printf ("%-5s ", tmp
);
7242 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7244 static unsigned char *
7245 read_cie (unsigned char *start
, unsigned char *end
,
7246 Frame_Chunk
**p_cie
, int *p_version
,
7247 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7251 unsigned int length_return
;
7252 unsigned char *augmentation_data
= NULL
;
7253 bfd_size_type augmentation_data_len
= 0;
7256 /* PR 17512: file: 001-228113-0.004. */
7260 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7261 memset (fc
, 0, sizeof (Frame_Chunk
));
7263 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7264 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7268 fc
->augmentation
= (char *) start
;
7269 /* PR 17512: file: 001-228113-0.004.
7270 Skip past augmentation name, but avoid running off the end of the data. */
7272 if (* start
++ == '\0')
7276 warn (_("No terminator for augmentation name\n"));
7280 if (strcmp (fc
->augmentation
, "eh") == 0)
7281 start
+= eh_addr_size
;
7285 GET (fc
->ptr_size
, 1);
7286 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7288 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7292 GET (fc
->segment_size
, 1);
7293 /* PR 17512: file: e99d2804. */
7294 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7296 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7300 eh_addr_size
= fc
->ptr_size
;
7304 fc
->ptr_size
= eh_addr_size
;
7305 fc
->segment_size
= 0;
7307 READ_ULEB (fc
->code_factor
);
7308 READ_SLEB (fc
->data_factor
);
7318 if (fc
->augmentation
[0] == 'z')
7320 READ_ULEB (augmentation_data_len
);
7321 augmentation_data
= start
;
7322 /* PR 17512: file: 11042-2589-0.004. */
7323 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7325 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7326 dwarf_vmatoa ("x", augmentation_data_len
),
7327 (unsigned long) (end
- start
));
7330 start
+= augmentation_data_len
;
7333 if (augmentation_data_len
)
7337 unsigned char *qend
;
7339 p
= (unsigned char *) fc
->augmentation
+ 1;
7340 q
= augmentation_data
;
7341 qend
= q
+ augmentation_data_len
;
7343 while (p
< end
&& q
< qend
)
7348 q
+= 1 + size_of_encoded_value (*q
);
7350 fc
->fde_encoding
= *q
++;
7357 /* Note - it is OK if this loop terminates with q < qend.
7358 Padding may have been inserted to align the end of the CIE. */
7363 *p_version
= version
;
7366 *p_aug_len
= augmentation_data_len
;
7367 *p_aug
= augmentation_data
;
7372 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7373 If do_wide is not enabled, then formats the output to fit into 80 columns.
7374 PRINTED contains the number of characters already written to the current
7378 display_data (bfd_size_type printed
,
7379 const unsigned char * data
,
7380 const bfd_size_type len
)
7382 if (do_wide
|| len
< ((80 - printed
) / 3))
7383 for (printed
= 0; printed
< len
; ++printed
)
7384 printf (" %02x", data
[printed
]);
7387 for (printed
= 0; printed
< len
; ++printed
)
7389 if (printed
% (80 / 3) == 0)
7391 printf (" %02x", data
[printed
]);
7396 /* Prints out the contents on the augmentation data array.
7397 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7400 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7404 i
= printf (_(" Augmentation data: "));
7405 display_data (i
, data
, len
);
7409 display_debug_frames (struct dwarf_section
*section
,
7410 void *file ATTRIBUTE_UNUSED
)
7412 unsigned char *start
= section
->start
;
7413 unsigned char *end
= start
+ section
->size
;
7414 unsigned char *section_start
= start
;
7415 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
7416 Frame_Chunk
*remembered_state
= 0;
7418 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7419 unsigned int length_return
;
7420 unsigned int max_regs
= 0;
7421 const char *bad_reg
= _("bad register: ");
7422 unsigned int saved_eh_addr_size
= eh_addr_size
;
7424 introduce (section
, FALSE
);
7428 unsigned char *saved_start
;
7429 unsigned char *block_end
;
7434 int need_col_headers
= 1;
7435 unsigned char *augmentation_data
= NULL
;
7436 bfd_size_type augmentation_data_len
= 0;
7437 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7438 unsigned int offset_size
;
7439 unsigned int initial_length_size
;
7440 bfd_boolean all_nops
;
7442 saved_start
= start
;
7444 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7448 printf ("\n%08lx ZERO terminator\n\n",
7449 (unsigned long)(saved_start
- section_start
));
7450 /* Skip any zero terminators that directly follow.
7451 A corrupt section size could have loaded a whole
7452 slew of zero filled memory bytes. eg
7453 PR 17512: file: 070-19381-0.004. */
7454 while (start
< end
&& * start
== 0)
7459 if (length
== 0xffffffff)
7461 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7463 initial_length_size
= 12;
7468 initial_length_size
= 4;
7471 block_end
= saved_start
+ length
+ initial_length_size
;
7472 if (block_end
> end
|| block_end
< start
)
7474 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7475 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7476 (unsigned long) (saved_start
- section_start
));
7480 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7482 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7483 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7488 start
= read_cie (start
, end
, &cie
, &version
,
7489 &augmentation_data_len
, &augmentation_data
);
7490 /* PR 17512: file: 027-135133-0.005. */
7497 fc
->chunk_start
= saved_start
;
7498 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7501 if (frame_need_space (fc
, mreg
) < 0)
7503 if (fc
->fde_encoding
)
7504 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7506 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7507 print_dwarf_vma (length
, fc
->ptr_size
);
7508 print_dwarf_vma (cie_id
, offset_size
);
7510 if (do_debug_frames_interp
)
7512 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7513 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7518 printf (" Version: %d\n", version
);
7519 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7522 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7523 printf (" Segment Size: %u\n", fc
->segment_size
);
7525 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7526 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7527 printf (" Return address column: %d\n", fc
->ra
);
7529 if (augmentation_data_len
)
7530 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7537 unsigned char *look_for
;
7538 static Frame_Chunk fde_fc
;
7539 unsigned long segment_selector
;
7543 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7544 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7547 look_for
= section_start
+ cie_id
;
7549 if (look_for
<= saved_start
)
7551 for (cie
= chunks
; cie
; cie
= cie
->next
)
7552 if (cie
->chunk_start
== look_for
)
7557 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7558 if (cie
->chunk_start
== look_for
)
7562 unsigned int off_size
;
7563 unsigned char *cie_scan
;
7565 cie_scan
= look_for
;
7567 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7568 if (length
== 0xffffffff)
7570 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7577 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7580 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7581 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7586 read_cie (cie_scan
, end
, &cie
, &version
,
7587 &augmentation_data_len
, &augmentation_data
);
7588 /* PR 17512: file: 3450-2098-0.004. */
7591 warn (_("Failed to read CIE information\n"));
7594 cie
->next
= forward_refs
;
7596 cie
->chunk_start
= look_for
;
7597 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7600 if (frame_need_space (cie
, mreg
) < 0)
7602 warn (_("Invalid max register\n"));
7605 if (cie
->fde_encoding
)
7607 = size_of_encoded_value (cie
->fde_encoding
);
7614 memset (fc
, 0, sizeof (Frame_Chunk
));
7618 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7619 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7620 (unsigned long) (saved_start
- section_start
));
7622 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7623 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7624 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
7626 warn (_("Invalid max register\n"));
7630 fc
->augmentation
= "";
7631 fc
->fde_encoding
= 0;
7632 fc
->ptr_size
= eh_addr_size
;
7633 fc
->segment_size
= 0;
7637 fc
->ncols
= cie
->ncols
;
7638 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
7639 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
7640 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
7641 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
7642 fc
->augmentation
= cie
->augmentation
;
7643 fc
->ptr_size
= cie
->ptr_size
;
7644 eh_addr_size
= cie
->ptr_size
;
7645 fc
->segment_size
= cie
->segment_size
;
7646 fc
->code_factor
= cie
->code_factor
;
7647 fc
->data_factor
= cie
->data_factor
;
7648 fc
->cfa_reg
= cie
->cfa_reg
;
7649 fc
->cfa_offset
= cie
->cfa_offset
;
7651 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
7653 warn (_("Invalid max register\n"));
7656 fc
->fde_encoding
= cie
->fde_encoding
;
7659 if (fc
->fde_encoding
)
7660 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7662 segment_selector
= 0;
7663 if (fc
->segment_size
)
7665 if (fc
->segment_size
> sizeof (segment_selector
))
7667 /* PR 17512: file: 9e196b3e. */
7668 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
7669 fc
->segment_size
= 4;
7671 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
7674 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
7676 /* FIXME: It appears that sometimes the final pc_range value is
7677 encoded in less than encoded_ptr_size bytes. See the x86_64
7678 run of the "objcopy on compressed debug sections" test for an
7680 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
7682 if (cie
->augmentation
[0] == 'z')
7684 READ_ULEB (augmentation_data_len
);
7685 augmentation_data
= start
;
7686 start
+= augmentation_data_len
;
7687 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
7689 || ((bfd_signed_vma
) augmentation_data_len
) < 0
7690 || augmentation_data
> start
)
7692 warn (_("Corrupt augmentation data length: 0x%s\n"),
7693 dwarf_vmatoa ("x", augmentation_data_len
));
7695 augmentation_data
= NULL
;
7696 augmentation_data_len
= 0;
7700 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
7701 (unsigned long)(saved_start
- section_start
),
7702 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
7703 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7704 (unsigned long)(cie
->chunk_start
- section_start
));
7706 if (fc
->segment_size
)
7707 printf ("%04lx:", segment_selector
);
7710 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
7711 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
7713 if (! do_debug_frames_interp
&& augmentation_data_len
)
7715 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7720 /* At this point, fc is the current chunk, cie (if any) is set, and
7721 we're about to interpret instructions for the chunk. */
7722 /* ??? At present we need to do this always, since this sizes the
7723 fc->col_type and fc->col_offset arrays, which we write into always.
7724 We should probably split the interpreted and non-interpreted bits
7725 into two different routines, since there's so much that doesn't
7726 really overlap between them. */
7727 if (1 || do_debug_frames_interp
)
7729 /* Start by making a pass over the chunk, allocating storage
7730 and taking note of what registers are used. */
7731 unsigned char *tmp
= start
;
7733 while (start
< block_end
)
7735 unsigned int reg
, op
, opa
;
7737 unsigned char * new_start
;
7744 /* Warning: if you add any more cases to this switch, be
7745 sure to add them to the corresponding switch below. */
7748 case DW_CFA_advance_loc
:
7752 if (frame_need_space (fc
, opa
) >= 0)
7753 fc
->col_type
[opa
] = DW_CFA_undefined
;
7755 case DW_CFA_restore
:
7756 if (frame_need_space (fc
, opa
) >= 0)
7757 fc
->col_type
[opa
] = DW_CFA_undefined
;
7759 case DW_CFA_set_loc
:
7760 start
+= encoded_ptr_size
;
7762 case DW_CFA_advance_loc1
:
7765 case DW_CFA_advance_loc2
:
7768 case DW_CFA_advance_loc4
:
7771 case DW_CFA_offset_extended
:
7772 case DW_CFA_val_offset
:
7775 if (frame_need_space (fc
, reg
) >= 0)
7776 fc
->col_type
[reg
] = DW_CFA_undefined
;
7778 case DW_CFA_restore_extended
:
7780 if (frame_need_space (fc
, reg
) >= 0)
7781 fc
->col_type
[reg
] = DW_CFA_undefined
;
7783 case DW_CFA_undefined
:
7785 if (frame_need_space (fc
, reg
) >= 0)
7786 fc
->col_type
[reg
] = DW_CFA_undefined
;
7788 case DW_CFA_same_value
:
7790 if (frame_need_space (fc
, reg
) >= 0)
7791 fc
->col_type
[reg
] = DW_CFA_undefined
;
7793 case DW_CFA_register
:
7796 if (frame_need_space (fc
, reg
) >= 0)
7797 fc
->col_type
[reg
] = DW_CFA_undefined
;
7799 case DW_CFA_def_cfa
:
7803 case DW_CFA_def_cfa_register
:
7806 case DW_CFA_def_cfa_offset
:
7809 case DW_CFA_def_cfa_expression
:
7811 new_start
= start
+ temp
;
7812 if (new_start
< start
)
7814 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
7820 case DW_CFA_expression
:
7821 case DW_CFA_val_expression
:
7824 new_start
= start
+ temp
;
7825 if (new_start
< start
)
7827 /* PR 17512: file:306-192417-0.005. */
7828 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
7833 if (frame_need_space (fc
, reg
) >= 0)
7834 fc
->col_type
[reg
] = DW_CFA_undefined
;
7836 case DW_CFA_offset_extended_sf
:
7837 case DW_CFA_val_offset_sf
:
7840 if (frame_need_space (fc
, reg
) >= 0)
7841 fc
->col_type
[reg
] = DW_CFA_undefined
;
7843 case DW_CFA_def_cfa_sf
:
7847 case DW_CFA_def_cfa_offset_sf
:
7850 case DW_CFA_MIPS_advance_loc8
:
7853 case DW_CFA_GNU_args_size
:
7856 case DW_CFA_GNU_negative_offset_extended
:
7859 if (frame_need_space (fc
, reg
) >= 0)
7860 fc
->col_type
[reg
] = DW_CFA_undefined
;
7871 /* Now we know what registers are used, make a second pass over
7872 the chunk, this time actually printing out the info. */
7874 while (start
< block_end
)
7876 unsigned char * tmp
;
7878 unsigned long ul
, roffs
;
7879 /* Note: It is tempting to use an unsigned long for 'reg' but there
7880 are various functions, notably frame_space_needed() that assume that
7881 reg is an unsigned int. */
7886 const char *reg_prefix
= "";
7893 /* Make a note if something other than DW_CFA_nop happens. */
7894 if (op
!= DW_CFA_nop
)
7897 /* Warning: if you add any more cases to this switch, be
7898 sure to add them to the corresponding switch above. */
7901 case DW_CFA_advance_loc
:
7902 if (do_debug_frames_interp
)
7903 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7905 printf (" DW_CFA_advance_loc: %d to %s\n",
7906 opa
* fc
->code_factor
,
7907 dwarf_vmatoa_1 (NULL
,
7908 fc
->pc_begin
+ opa
* fc
->code_factor
,
7910 fc
->pc_begin
+= opa
* fc
->code_factor
;
7915 if (opa
>= (unsigned int) fc
->ncols
)
7916 reg_prefix
= bad_reg
;
7917 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7918 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
7919 reg_prefix
, regname (opa
, 0),
7920 roffs
* fc
->data_factor
);
7921 if (*reg_prefix
== '\0')
7923 fc
->col_type
[opa
] = DW_CFA_offset
;
7924 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
7928 case DW_CFA_restore
:
7929 if (opa
>= (unsigned int) fc
->ncols
)
7930 reg_prefix
= bad_reg
;
7931 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7932 printf (" DW_CFA_restore: %s%s\n",
7933 reg_prefix
, regname (opa
, 0));
7934 if (*reg_prefix
!= '\0')
7937 if (opa
>= (unsigned int) cie
->ncols
7938 || (do_debug_frames_interp
7939 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
7941 fc
->col_type
[opa
] = DW_CFA_undefined
;
7942 fc
->col_offset
[opa
] = 0;
7946 fc
->col_type
[opa
] = cie
->col_type
[opa
];
7947 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
7951 case DW_CFA_set_loc
:
7952 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
7953 if (do_debug_frames_interp
)
7954 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7956 printf (" DW_CFA_set_loc: %s\n",
7957 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
7961 case DW_CFA_advance_loc1
:
7962 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
7963 if (do_debug_frames_interp
)
7964 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7966 printf (" DW_CFA_advance_loc1: %ld to %s\n",
7967 (unsigned long) (ofs
* fc
->code_factor
),
7968 dwarf_vmatoa_1 (NULL
,
7969 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7971 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7974 case DW_CFA_advance_loc2
:
7975 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
7976 if (do_debug_frames_interp
)
7977 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7979 printf (" DW_CFA_advance_loc2: %ld to %s\n",
7980 (unsigned long) (ofs
* fc
->code_factor
),
7981 dwarf_vmatoa_1 (NULL
,
7982 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7984 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7987 case DW_CFA_advance_loc4
:
7988 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
7989 if (do_debug_frames_interp
)
7990 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7992 printf (" DW_CFA_advance_loc4: %ld to %s\n",
7993 (unsigned long) (ofs
* fc
->code_factor
),
7994 dwarf_vmatoa_1 (NULL
,
7995 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7997 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8000 case DW_CFA_offset_extended
:
8003 if (reg
>= (unsigned int) fc
->ncols
)
8004 reg_prefix
= bad_reg
;
8005 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8006 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
8007 reg_prefix
, regname (reg
, 0),
8008 roffs
* fc
->data_factor
);
8009 if (*reg_prefix
== '\0')
8011 fc
->col_type
[reg
] = DW_CFA_offset
;
8012 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8016 case DW_CFA_val_offset
:
8019 if (reg
>= (unsigned int) fc
->ncols
)
8020 reg_prefix
= bad_reg
;
8021 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8022 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8023 reg_prefix
, regname (reg
, 0),
8024 roffs
* fc
->data_factor
);
8025 if (*reg_prefix
== '\0')
8027 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8028 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8032 case DW_CFA_restore_extended
:
8034 if (reg
>= (unsigned int) fc
->ncols
)
8035 reg_prefix
= bad_reg
;
8036 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8037 printf (" DW_CFA_restore_extended: %s%s\n",
8038 reg_prefix
, regname (reg
, 0));
8039 if (*reg_prefix
!= '\0')
8042 if (reg
>= (unsigned int) cie
->ncols
)
8044 fc
->col_type
[reg
] = DW_CFA_undefined
;
8045 fc
->col_offset
[reg
] = 0;
8049 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8050 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8054 case DW_CFA_undefined
:
8056 if (reg
>= (unsigned int) fc
->ncols
)
8057 reg_prefix
= bad_reg
;
8058 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8059 printf (" DW_CFA_undefined: %s%s\n",
8060 reg_prefix
, regname (reg
, 0));
8061 if (*reg_prefix
== '\0')
8063 fc
->col_type
[reg
] = DW_CFA_undefined
;
8064 fc
->col_offset
[reg
] = 0;
8068 case DW_CFA_same_value
:
8070 if (reg
>= (unsigned int) fc
->ncols
)
8071 reg_prefix
= bad_reg
;
8072 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8073 printf (" DW_CFA_same_value: %s%s\n",
8074 reg_prefix
, regname (reg
, 0));
8075 if (*reg_prefix
== '\0')
8077 fc
->col_type
[reg
] = DW_CFA_same_value
;
8078 fc
->col_offset
[reg
] = 0;
8082 case DW_CFA_register
:
8085 if (reg
>= (unsigned int) fc
->ncols
)
8086 reg_prefix
= bad_reg
;
8087 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8089 printf (" DW_CFA_register: %s%s in ",
8090 reg_prefix
, regname (reg
, 0));
8091 puts (regname (roffs
, 0));
8093 if (*reg_prefix
== '\0')
8095 fc
->col_type
[reg
] = DW_CFA_register
;
8096 fc
->col_offset
[reg
] = roffs
;
8100 case DW_CFA_remember_state
:
8101 if (! do_debug_frames_interp
)
8102 printf (" DW_CFA_remember_state\n");
8103 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8104 rs
->cfa_offset
= fc
->cfa_offset
;
8105 rs
->cfa_reg
= fc
->cfa_reg
;
8107 rs
->cfa_exp
= fc
->cfa_exp
;
8108 rs
->ncols
= fc
->ncols
;
8109 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8110 sizeof (* rs
->col_type
));
8111 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8112 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8113 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8114 rs
->next
= remembered_state
;
8115 remembered_state
= rs
;
8118 case DW_CFA_restore_state
:
8119 if (! do_debug_frames_interp
)
8120 printf (" DW_CFA_restore_state\n");
8121 rs
= remembered_state
;
8124 remembered_state
= rs
->next
;
8125 fc
->cfa_offset
= rs
->cfa_offset
;
8126 fc
->cfa_reg
= rs
->cfa_reg
;
8128 fc
->cfa_exp
= rs
->cfa_exp
;
8129 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8131 warn (_("Invalid column number in saved frame state\n"));
8135 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8136 memcpy (fc
->col_offset
, rs
->col_offset
,
8137 rs
->ncols
* sizeof (* rs
->col_offset
));
8138 free (rs
->col_type
);
8139 free (rs
->col_offset
);
8142 else if (do_debug_frames_interp
)
8143 printf ("Mismatched DW_CFA_restore_state\n");
8146 case DW_CFA_def_cfa
:
8147 READ_ULEB (fc
->cfa_reg
);
8148 READ_ULEB (fc
->cfa_offset
);
8150 if (! do_debug_frames_interp
)
8151 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8152 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8155 case DW_CFA_def_cfa_register
:
8156 READ_ULEB (fc
->cfa_reg
);
8158 if (! do_debug_frames_interp
)
8159 printf (" DW_CFA_def_cfa_register: %s\n",
8160 regname (fc
->cfa_reg
, 0));
8163 case DW_CFA_def_cfa_offset
:
8164 READ_ULEB (fc
->cfa_offset
);
8165 if (! do_debug_frames_interp
)
8166 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8170 if (! do_debug_frames_interp
)
8171 printf (" DW_CFA_nop\n");
8174 case DW_CFA_def_cfa_expression
:
8176 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8178 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8181 if (! do_debug_frames_interp
)
8183 printf (" DW_CFA_def_cfa_expression (");
8184 decode_location_expression (start
, eh_addr_size
, 0, -1,
8192 case DW_CFA_expression
:
8195 if (reg
>= (unsigned int) fc
->ncols
)
8196 reg_prefix
= bad_reg
;
8197 /* PR 17512: file: 069-133014-0.006. */
8198 /* PR 17512: file: 98c02eb4. */
8200 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8202 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8205 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8207 printf (" DW_CFA_expression: %s%s (",
8208 reg_prefix
, regname (reg
, 0));
8209 decode_location_expression (start
, eh_addr_size
, 0, -1,
8213 if (*reg_prefix
== '\0')
8214 fc
->col_type
[reg
] = DW_CFA_expression
;
8218 case DW_CFA_val_expression
:
8221 if (reg
>= (unsigned int) fc
->ncols
)
8222 reg_prefix
= bad_reg
;
8224 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8226 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8229 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8231 printf (" DW_CFA_val_expression: %s%s (",
8232 reg_prefix
, regname (reg
, 0));
8233 decode_location_expression (start
, eh_addr_size
, 0, -1,
8237 if (*reg_prefix
== '\0')
8238 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8242 case DW_CFA_offset_extended_sf
:
8245 if (frame_need_space (fc
, reg
) < 0)
8246 reg_prefix
= bad_reg
;
8247 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8248 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8249 reg_prefix
, regname (reg
, 0),
8250 (long)(l
* fc
->data_factor
));
8251 if (*reg_prefix
== '\0')
8253 fc
->col_type
[reg
] = DW_CFA_offset
;
8254 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8258 case DW_CFA_val_offset_sf
:
8261 if (frame_need_space (fc
, reg
) < 0)
8262 reg_prefix
= bad_reg
;
8263 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8264 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8265 reg_prefix
, regname (reg
, 0),
8266 (long)(l
* fc
->data_factor
));
8267 if (*reg_prefix
== '\0')
8269 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8270 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8274 case DW_CFA_def_cfa_sf
:
8275 READ_ULEB (fc
->cfa_reg
);
8276 READ_ULEB (fc
->cfa_offset
);
8277 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8279 if (! do_debug_frames_interp
)
8280 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8281 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8284 case DW_CFA_def_cfa_offset_sf
:
8285 READ_ULEB (fc
->cfa_offset
);
8286 fc
->cfa_offset
*= fc
->data_factor
;
8287 if (! do_debug_frames_interp
)
8288 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8291 case DW_CFA_MIPS_advance_loc8
:
8292 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8293 if (do_debug_frames_interp
)
8294 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8296 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8297 (unsigned long) (ofs
* fc
->code_factor
),
8298 dwarf_vmatoa_1 (NULL
,
8299 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8301 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8304 case DW_CFA_GNU_window_save
:
8305 if (! do_debug_frames_interp
)
8306 printf (" DW_CFA_GNU_window_save\n");
8309 case DW_CFA_GNU_args_size
:
8311 if (! do_debug_frames_interp
)
8312 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8315 case DW_CFA_GNU_negative_offset_extended
:
8319 if (frame_need_space (fc
, reg
) < 0)
8320 reg_prefix
= bad_reg
;
8321 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8322 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8323 reg_prefix
, regname (reg
, 0),
8324 (long)(l
* fc
->data_factor
));
8325 if (*reg_prefix
== '\0')
8327 fc
->col_type
[reg
] = DW_CFA_offset
;
8328 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8333 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8334 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8336 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8341 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8342 if (do_debug_frames_interp
&& ! all_nops
)
8343 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8346 eh_addr_size
= saved_eh_addr_size
;
8357 display_debug_names (struct dwarf_section
*section
, void *file
)
8359 unsigned char *hdrptr
= section
->start
;
8360 dwarf_vma unit_length
;
8361 unsigned char *unit_start
;
8362 const unsigned char *const section_end
= section
->start
+ section
->size
;
8363 unsigned char *unit_end
;
8365 introduce (section
, FALSE
);
8367 load_debug_section_with_follow (str
, file
);
8369 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8371 unsigned int offset_size
;
8372 uint16_t dwarf_version
, padding
;
8373 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8374 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8375 uint32_t augmentation_string_size
;
8377 unsigned long sec_off
;
8379 unit_start
= hdrptr
;
8381 /* Get and check the length of the block. */
8382 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8384 if (unit_length
== 0xffffffff)
8386 /* This section is 64-bit DWARF. */
8387 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8392 unit_end
= hdrptr
+ unit_length
;
8394 sec_off
= hdrptr
- section
->start
;
8395 if (sec_off
+ unit_length
< sec_off
8396 || sec_off
+ unit_length
> section
->size
)
8398 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8400 (unsigned long) (unit_start
- section
->start
),
8401 dwarf_vmatoa ("x", unit_length
));
8405 /* Get and check the version number. */
8406 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8407 printf (_("Version %ld\n"), (long) dwarf_version
);
8409 /* Prior versions did not exist, and future versions may not be
8410 backwards compatible. */
8411 if (dwarf_version
!= 5)
8413 warn (_("Only DWARF version 5 .debug_names "
8414 "is currently supported.\n"));
8418 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8420 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8423 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8424 if (comp_unit_count
== 0)
8425 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8427 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8428 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8429 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8430 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8431 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8433 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8434 if (augmentation_string_size
% 4 != 0)
8436 warn (_("Augmentation string length %u must be rounded up "
8437 "to a multiple of 4 in .debug_names.\n"),
8438 augmentation_string_size
);
8439 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8441 printf (_("Augmentation string:"));
8442 for (i
= 0; i
< augmentation_string_size
; i
++)
8446 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8447 printf (" %02x", uc
);
8452 printf (_("CU table:\n"));
8453 for (i
= 0; i
< comp_unit_count
; i
++)
8457 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8458 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8462 printf (_("TU table:\n"));
8463 for (i
= 0; i
< local_type_unit_count
; i
++)
8467 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8468 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8472 printf (_("Foreign TU table:\n"));
8473 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8477 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8478 printf (_("[%3u] "), i
);
8479 print_dwarf_vma (signature
, 8);
8484 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8485 hdrptr
+= bucket_count
* sizeof (uint32_t);
8486 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8487 hdrptr
+= name_count
* sizeof (uint32_t);
8488 unsigned char *const name_table_string_offsets
= hdrptr
;
8489 hdrptr
+= name_count
* offset_size
;
8490 unsigned char *const name_table_entry_offsets
= hdrptr
;
8491 hdrptr
+= name_count
* offset_size
;
8492 unsigned char *const abbrev_table
= hdrptr
;
8493 hdrptr
+= abbrev_table_size
;
8494 const unsigned char *const abbrev_table_end
= hdrptr
;
8495 unsigned char *const entry_pool
= hdrptr
;
8496 if (hdrptr
> unit_end
)
8498 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8499 "for unit 0x%lx in the debug_names\n"),
8500 (long) (hdrptr
- section
->start
),
8501 (long) (unit_end
- section
->start
),
8502 (long) (unit_start
- section
->start
));
8506 size_t buckets_filled
= 0;
8508 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8510 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8515 printf (ngettext ("Used %zu of %lu bucket.\n",
8516 "Used %zu of %lu buckets.\n",
8518 buckets_filled
, (unsigned long) bucket_count
);
8520 uint32_t hash_prev
= 0;
8521 size_t hash_clash_count
= 0;
8522 size_t longest_clash
= 0;
8523 size_t this_length
= 0;
8525 for (hashi
= 0; hashi
< name_count
; hashi
++)
8527 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8531 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8535 longest_clash
= MAX (longest_clash
, this_length
);
8540 hash_prev
= hash_this
;
8542 printf (_("Out of %lu items there are %zu bucket clashes"
8543 " (longest of %zu entries).\n"),
8544 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
8545 assert (name_count
== buckets_filled
+ hash_clash_count
);
8547 struct abbrev_lookup_entry
8549 dwarf_vma abbrev_tag
;
8550 unsigned char *abbrev_lookup_ptr
;
8552 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
8553 size_t abbrev_lookup_used
= 0;
8554 size_t abbrev_lookup_allocated
= 0;
8556 unsigned char *abbrevptr
= abbrev_table
;
8559 unsigned int bytes_read
;
8560 const dwarf_vma abbrev_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8562 abbrevptr
+= bytes_read
;
8563 if (abbrev_tag
== 0)
8565 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
8567 abbrev_lookup_allocated
= MAX (0x100,
8568 abbrev_lookup_allocated
* 2);
8569 abbrev_lookup
= xrealloc (abbrev_lookup
,
8570 (abbrev_lookup_allocated
8571 * sizeof (*abbrev_lookup
)));
8573 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
8574 struct abbrev_lookup_entry
*entry
;
8575 for (entry
= abbrev_lookup
;
8576 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8578 if (entry
->abbrev_tag
== abbrev_tag
)
8580 warn (_("Duplicate abbreviation tag %lu "
8581 "in unit 0x%lx in the debug_names\n"),
8582 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
8585 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
8586 entry
->abbrev_tag
= abbrev_tag
;
8587 entry
->abbrev_lookup_ptr
= abbrevptr
;
8589 /* Skip DWARF tag. */
8590 read_uleb128 (abbrevptr
, &bytes_read
, abbrev_table_end
);
8591 abbrevptr
+= bytes_read
;
8594 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8597 abbrevptr
+= bytes_read
;
8598 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8600 abbrevptr
+= bytes_read
;
8601 if (xindex
== 0 && form
== 0)
8606 printf (_("\nSymbol table:\n"));
8608 for (namei
= 0; namei
< name_count
; ++namei
)
8610 uint64_t string_offset
, entry_offset
;
8612 SAFE_BYTE_GET (string_offset
,
8613 name_table_string_offsets
+ namei
* offset_size
,
8614 offset_size
, unit_end
);
8615 SAFE_BYTE_GET (entry_offset
,
8616 name_table_entry_offsets
+ namei
* offset_size
,
8617 offset_size
, unit_end
);
8619 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
8620 fetch_indirect_string (string_offset
));
8622 unsigned char *entryptr
= entry_pool
+ entry_offset
;
8624 // We need to scan first whether there is a single or multiple
8625 // entries. TAGNO is -2 for the first entry, it is -1 for the
8626 // initial tag read of the second entry, then it becomes 0 for the
8627 // first entry for real printing etc.
8629 /* Initialize it due to a false compiler warning. */
8630 dwarf_vma second_abbrev_tag
= -1;
8633 unsigned int bytes_read
;
8634 const dwarf_vma abbrev_tag
= read_uleb128 (entryptr
, &bytes_read
,
8636 entryptr
+= bytes_read
;
8639 second_abbrev_tag
= abbrev_tag
;
8641 entryptr
= entry_pool
+ entry_offset
;
8644 if (abbrev_tag
== 0)
8648 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
8649 (unsigned long) abbrev_tag
);
8651 const struct abbrev_lookup_entry
*entry
;
8652 for (entry
= abbrev_lookup
;
8653 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8655 if (entry
->abbrev_tag
== abbrev_tag
)
8657 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
8659 warn (_("Undefined abbreviation tag %lu "
8660 "in unit 0x%lx in the debug_names\n"),
8662 (long) (unit_start
- section
->start
));
8665 abbrevptr
= entry
->abbrev_lookup_ptr
;
8666 const dwarf_vma dwarf_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8668 abbrevptr
+= bytes_read
;
8670 printf (" %s", get_TAG_name (dwarf_tag
));
8673 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8676 abbrevptr
+= bytes_read
;
8677 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8679 abbrevptr
+= bytes_read
;
8680 if (xindex
== 0 && form
== 0)
8684 printf (" %s", get_IDX_name (xindex
));
8685 entryptr
= read_and_display_attr_value (0, form
, 0, entryptr
,
8688 dwarf_version
, NULL
,
8695 printf (_(" <no entries>"));
8699 free (abbrev_lookup
);
8706 display_debug_links (struct dwarf_section
* section
,
8707 void * file ATTRIBUTE_UNUSED
)
8709 const unsigned char * filename
;
8710 unsigned int filelen
;
8712 introduce (section
, FALSE
);
8714 /* The .gnu_debuglink section is formatted as:
8715 (c-string) Filename.
8716 (padding) If needed to reach a 4 byte boundary.
8717 (uint32_t) CRC32 value.
8719 The .gun_debugaltlink section is formatted as:
8720 (c-string) Filename.
8721 (binary) Build-ID. */
8723 filename
= section
->start
;
8724 filelen
= strnlen ((const char *) filename
, section
->size
);
8725 if (filelen
== section
->size
)
8727 warn (_("The debuglink filename is corrupt/missing\n"));
8731 printf (_(" Separate debug info file: %s\n"), filename
);
8733 if (const_strneq (section
->name
, ".gnu_debuglink"))
8736 unsigned int crc_offset
;
8738 crc_offset
= filelen
+ 1;
8739 crc_offset
= (crc_offset
+ 3) & ~3;
8740 if (crc_offset
+ 4 > section
->size
)
8742 warn (_("CRC offset missing/truncated\n"));
8746 crc32
= byte_get (filename
+ crc_offset
, 4);
8748 printf (_(" CRC value: %#x\n"), crc32
);
8750 if (crc_offset
+ 4 < section
->size
)
8752 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
8753 (long)(section
->size
- (crc_offset
+ 4)));
8757 else /* const_strneq (section->name, ".gnu_debugaltlink") */
8759 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
8760 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
8761 bfd_size_type printed
;
8763 /* FIXME: Should we support smaller build-id notes ? */
8764 if (build_id_len
< 0x14)
8766 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
8770 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
8771 display_data (printed
, build_id
, build_id_len
);
8780 display_gdb_index (struct dwarf_section
*section
,
8781 void *file ATTRIBUTE_UNUSED
)
8783 unsigned char *start
= section
->start
;
8785 uint32_t cu_list_offset
, tu_list_offset
;
8786 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
8787 unsigned int cu_list_elements
, tu_list_elements
;
8788 unsigned int address_table_size
, symbol_table_slots
;
8789 unsigned char *cu_list
, *tu_list
;
8790 unsigned char *address_table
, *symbol_table
, *constant_pool
;
8793 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
8795 introduce (section
, FALSE
);
8797 if (section
->size
< 6 * sizeof (uint32_t))
8799 warn (_("Truncated header in the %s section.\n"), section
->name
);
8803 version
= byte_get_little_endian (start
, 4);
8804 printf (_("Version %ld\n"), (long) version
);
8806 /* Prior versions are obsolete, and future versions may not be
8807 backwards compatible. */
8808 if (version
< 3 || version
> 8)
8810 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
8814 warn (_("The address table data in version 3 may be wrong.\n"));
8816 warn (_("Version 4 does not support case insensitive lookups.\n"));
8818 warn (_("Version 5 does not include inlined functions.\n"));
8820 warn (_("Version 6 does not include symbol attributes.\n"));
8821 /* Version 7 indices generated by Gold have bad type unit references,
8822 PR binutils/15021. But we don't know if the index was generated by
8823 Gold or not, so to avoid worrying users with gdb-generated indices
8824 we say nothing for version 7 here. */
8826 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
8827 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
8828 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
8829 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
8830 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
8832 if (cu_list_offset
> section
->size
8833 || tu_list_offset
> section
->size
8834 || address_table_offset
> section
->size
8835 || symbol_table_offset
> section
->size
8836 || constant_pool_offset
> section
->size
)
8838 warn (_("Corrupt header in the %s section.\n"), section
->name
);
8842 /* PR 17531: file: 418d0a8a. */
8843 if (tu_list_offset
< cu_list_offset
)
8845 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
8846 tu_list_offset
, cu_list_offset
);
8850 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
8852 if (address_table_offset
< tu_list_offset
)
8854 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
8855 address_table_offset
, tu_list_offset
);
8859 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
8861 /* PR 17531: file: 18a47d3d. */
8862 if (symbol_table_offset
< address_table_offset
)
8864 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
8865 symbol_table_offset
, address_table_offset
);
8869 address_table_size
= symbol_table_offset
- address_table_offset
;
8871 if (constant_pool_offset
< symbol_table_offset
)
8873 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
8874 constant_pool_offset
, symbol_table_offset
);
8878 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
8880 cu_list
= start
+ cu_list_offset
;
8881 tu_list
= start
+ tu_list_offset
;
8882 address_table
= start
+ address_table_offset
;
8883 symbol_table
= start
+ symbol_table_offset
;
8884 constant_pool
= start
+ constant_pool_offset
;
8886 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
8888 warn (_("Address table extends beyond end of section.\n"));
8892 printf (_("\nCU table:\n"));
8893 for (i
= 0; i
< cu_list_elements
; i
+= 2)
8895 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
8896 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
8898 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
8899 (unsigned long) cu_offset
,
8900 (unsigned long) (cu_offset
+ cu_length
- 1));
8903 printf (_("\nTU table:\n"));
8904 for (i
= 0; i
< tu_list_elements
; i
+= 3)
8906 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
8907 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
8908 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
8910 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
8911 (unsigned long) tu_offset
,
8912 (unsigned long) type_offset
);
8913 print_dwarf_vma (signature
, 8);
8917 printf (_("\nAddress table:\n"));
8918 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
8921 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
8922 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
8923 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
8925 print_dwarf_vma (low
, 8);
8926 print_dwarf_vma (high
, 8);
8927 printf (_("%lu\n"), (unsigned long) cu_index
);
8930 printf (_("\nSymbol table:\n"));
8931 for (i
= 0; i
< symbol_table_slots
; ++i
)
8933 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
8934 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
8935 uint32_t num_cus
, cu
;
8937 if (name_offset
!= 0
8938 || cu_vector_offset
!= 0)
8941 unsigned char * adr
;
8943 adr
= constant_pool
+ name_offset
;
8944 /* PR 17531: file: 5b7b07ad. */
8945 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
8947 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
8948 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
8952 printf ("[%3u] %.*s:", i
,
8953 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
8954 constant_pool
+ name_offset
);
8956 adr
= constant_pool
+ cu_vector_offset
;
8957 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
8959 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
8960 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
8961 cu_vector_offset
, i
);
8965 num_cus
= byte_get_little_endian (adr
, 4);
8967 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
8968 if (num_cus
* 4 < num_cus
8969 || adr
>= section
->start
+ section
->size
8970 || adr
< constant_pool
)
8972 printf ("<invalid number of CUs: %d>\n", num_cus
);
8973 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
8981 for (j
= 0; j
< num_cus
; ++j
)
8984 gdb_index_symbol_kind kind
;
8986 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
8987 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
8988 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
8989 cu
= GDB_INDEX_CU_VALUE (cu
);
8990 /* Convert to TU number if it's for a type unit. */
8991 if (cu
>= cu_list_elements
/ 2)
8992 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
8993 (unsigned long) (cu
- cu_list_elements
/ 2));
8995 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
8997 printf (" [%s, %s]",
8998 is_static
? _("static") : _("global"),
8999 get_gdb_index_symbol_kind_name (kind
));
9011 /* Pre-allocate enough space for the CU/TU sets needed. */
9014 prealloc_cu_tu_list (unsigned int nshndx
)
9016 if (shndx_pool
== NULL
)
9018 shndx_pool_size
= nshndx
;
9019 shndx_pool_used
= 0;
9020 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9021 sizeof (unsigned int));
9025 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9026 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9027 sizeof (unsigned int));
9032 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9034 if (shndx_pool_used
>= shndx_pool_size
)
9036 error (_("Internal error: out of space in the shndx pool.\n"));
9039 shndx_pool
[shndx_pool_used
++] = shndx
;
9043 end_cu_tu_entry (void)
9045 if (shndx_pool_used
>= shndx_pool_size
)
9047 error (_("Internal error: out of space in the shndx pool.\n"));
9050 shndx_pool
[shndx_pool_used
++] = 0;
9053 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9056 get_DW_SECT_short_name (unsigned int dw_sect
)
9058 static char buf
[16];
9066 case DW_SECT_ABBREV
:
9072 case DW_SECT_STR_OFFSETS
:
9074 case DW_SECT_MACINFO
:
9082 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9086 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9087 These sections are extensions for Fission.
9088 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9091 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9093 unsigned char *phdr
= section
->start
;
9094 unsigned char *limit
= phdr
+ section
->size
;
9095 unsigned char *phash
;
9096 unsigned char *pindex
;
9097 unsigned char *ppool
;
9098 unsigned int version
;
9099 unsigned int ncols
= 0;
9101 unsigned int nslots
;
9104 dwarf_vma signature_high
;
9105 dwarf_vma signature_low
;
9108 /* PR 17512: file: 002-168123-0.004. */
9111 warn (_("Section %s is empty\n"), section
->name
);
9114 /* PR 17512: file: 002-376-0.004. */
9115 if (section
->size
< 24)
9117 warn (_("Section %s is too small to contain a CU/TU header\n"),
9122 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9124 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9125 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9126 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9129 pindex
= phash
+ nslots
* 8;
9130 ppool
= pindex
+ nslots
* 4;
9132 /* PR 17531: file: 45d69832. */
9133 if (pindex
< phash
|| ppool
< phdr
|| (pindex
== phash
&& nslots
!= 0))
9135 warn (ngettext ("Section %s is too small for %d slot\n",
9136 "Section %s is too small for %d slots\n",
9138 section
->name
, nslots
);
9144 introduce (section
, FALSE
);
9146 printf (_(" Version: %d\n"), version
);
9148 printf (_(" Number of columns: %d\n"), ncols
);
9149 printf (_(" Number of used entries: %d\n"), nused
);
9150 printf (_(" Number of slots: %d\n\n"), nslots
);
9153 if (ppool
> limit
|| ppool
< phdr
)
9155 warn (_("Section %s too small for %d hash table entries\n"),
9156 section
->name
, nslots
);
9163 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9164 for (i
= 0; i
< nslots
; i
++)
9166 unsigned char *shndx_list
;
9169 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9170 if (signature_high
!= 0 || signature_low
!= 0)
9172 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9173 shndx_list
= ppool
+ j
* 4;
9174 /* PR 17531: file: 705e010d. */
9175 if (shndx_list
< ppool
)
9177 warn (_("Section index pool located before start of section\n"));
9182 printf (_(" [%3d] Signature: 0x%s Sections: "),
9183 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9184 buf
, sizeof (buf
)));
9187 if (shndx_list
>= limit
)
9189 warn (_("Section %s too small for shndx pool\n"),
9193 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9197 printf (" %d", shndx
);
9199 add_shndx_to_cu_tu_entry (shndx
);
9211 else if (version
== 2)
9214 unsigned int dw_sect
;
9215 unsigned char *ph
= phash
;
9216 unsigned char *pi
= pindex
;
9217 unsigned char *poffsets
= ppool
+ ncols
* 4;
9218 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
9219 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
9220 bfd_boolean is_tu_index
;
9221 struct cu_tu_set
*this_set
= NULL
;
9223 unsigned char *prow
;
9225 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9227 /* PR 17531: file: 0dd159bf.
9228 Check for wraparound with an overlarge ncols value. */
9229 if (poffsets
< ppool
|| (unsigned int) ((poffsets
- ppool
) / 4) != ncols
)
9231 warn (_("Overlarge number of columns: %x\n"), ncols
);
9237 warn (_("Section %s too small for offset and size tables\n"),
9244 printf (_(" Offset table\n"));
9245 printf (" slot %-16s ",
9246 is_tu_index
? _("signature") : _("dwo_id"));
9253 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9259 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9266 for (j
= 0; j
< ncols
; j
++)
9268 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9269 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9274 for (i
= 0; i
< nslots
; i
++)
9276 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9278 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9281 /* PR 17531: file: a05f6ab3. */
9284 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9290 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
9292 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9293 /* PR 17531: file: b8ce60a8. */
9294 if (prow
< poffsets
|| prow
> limit
)
9296 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9302 printf (_(" [%3d] 0x%s"),
9303 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9304 buf
, sizeof (buf
)));
9305 for (j
= 0; j
< ncols
; j
++)
9307 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9309 printf (" %8d", val
);
9312 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9314 /* PR 17531: file: 10796eb3. */
9315 if (dw_sect
>= DW_SECT_MAX
)
9316 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9318 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9334 printf (_(" Size table\n"));
9335 printf (" slot %-16s ",
9336 is_tu_index
? _("signature") : _("dwo_id"));
9339 for (j
= 0; j
< ncols
; j
++)
9341 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9343 printf (" %8s", get_DW_SECT_short_name (val
));
9349 for (i
= 0; i
< nslots
; i
++)
9351 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9353 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9356 prow
= psizes
+ (row
- 1) * ncols
* 4;
9359 printf (_(" [%3d] 0x%s"),
9360 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9361 buf
, sizeof (buf
)));
9363 for (j
= 0; j
< ncols
; j
++)
9365 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9367 printf (" %8d", val
);
9370 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9371 if (dw_sect
>= DW_SECT_MAX
)
9372 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9374 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9386 else if (do_display
)
9387 printf (_(" Unsupported version (%d)\n"), version
);
9395 /* Load the CU and TU indexes if present. This will build a list of
9396 section sets that we can use to associate a .debug_info.dwo section
9397 with its associated .debug_abbrev.dwo section in a .dwp file. */
9400 load_cu_tu_indexes (void *file
)
9402 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
9404 /* If we have already loaded (or tried to load) the CU and TU indexes
9405 then do not bother to repeat the task. */
9406 if (cu_tu_indexes_read
== -1)
9408 cu_tu_indexes_read
= TRUE
;
9410 if (load_debug_section_with_follow (dwp_cu_index
, file
))
9411 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
9412 cu_tu_indexes_read
= FALSE
;
9414 if (load_debug_section_with_follow (dwp_tu_index
, file
))
9415 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
9416 cu_tu_indexes_read
= FALSE
;
9419 return (bfd_boolean
) cu_tu_indexes_read
;
9422 /* Find the set of sections that includes section SHNDX. */
9425 find_cu_tu_set (void *file
, unsigned int shndx
)
9429 if (! load_cu_tu_indexes (file
))
9432 /* Find SHNDX in the shndx pool. */
9433 for (i
= 0; i
< shndx_pool_used
; i
++)
9434 if (shndx_pool
[i
] == shndx
)
9437 if (i
>= shndx_pool_used
)
9440 /* Now backup to find the first entry in the set. */
9441 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9444 return shndx_pool
+ i
;
9447 /* Display a .debug_cu_index or .debug_tu_index section. */
9450 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9452 return process_cu_tu_index (section
, 1);
9456 display_debug_not_supported (struct dwarf_section
*section
,
9457 void *file ATTRIBUTE_UNUSED
)
9459 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9465 /* Like malloc, but takes two parameters like calloc.
9466 Verifies that the first parameter is not too large.
9467 Note: does *not* initialise the allocated memory to zero. */
9470 cmalloc (size_t nmemb
, size_t size
)
9472 /* Check for overflow. */
9473 if (nmemb
>= ~(size_t) 0 / size
)
9476 return xmalloc (nmemb
* size
);
9479 /* Like xmalloc, but takes two parameters like calloc.
9480 Verifies that the first parameter is not too large.
9481 Note: does *not* initialise the allocated memory to zero. */
9484 xcmalloc (size_t nmemb
, size_t size
)
9486 /* Check for overflow. */
9487 if (nmemb
>= ~(size_t) 0 / size
)
9490 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9495 return xmalloc (nmemb
* size
);
9498 /* Like xrealloc, but takes three parameters.
9499 Verifies that the second parameter is not too large.
9500 Note: does *not* initialise any new memory to zero. */
9503 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9505 /* Check for overflow. */
9506 if (nmemb
>= ~(size_t) 0 / size
)
9508 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9513 return xrealloc (ptr
, nmemb
* size
);
9516 /* Like xcalloc, but verifies that the first parameter is not too large. */
9519 xcalloc2 (size_t nmemb
, size_t size
)
9521 /* Check for overflow. */
9522 if (nmemb
>= ~(size_t) 0 / size
)
9524 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9529 return xcalloc (nmemb
, size
);
9532 static unsigned long
9533 calc_gnu_debuglink_crc32 (unsigned long crc
,
9534 const unsigned char * buf
,
9537 static const unsigned long crc32_table
[256] =
9539 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
9540 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
9541 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
9542 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
9543 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
9544 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
9545 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
9546 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
9547 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
9548 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
9549 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
9550 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
9551 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
9552 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
9553 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
9554 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
9555 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
9556 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
9557 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
9558 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
9559 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
9560 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
9561 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
9562 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
9563 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
9564 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
9565 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
9566 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
9567 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
9568 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
9569 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
9570 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
9571 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
9572 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
9573 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
9574 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
9575 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
9576 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
9577 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
9578 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
9579 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
9580 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
9581 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
9582 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
9583 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
9584 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
9585 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
9586 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
9587 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
9588 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
9589 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
9592 const unsigned char *end
;
9594 crc
= ~crc
& 0xffffffff;
9595 for (end
= buf
+ len
; buf
< end
; ++ buf
)
9596 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
9597 return ~crc
& 0xffffffff;
9600 typedef bfd_boolean (* check_func_type
) (const char *, void *);
9601 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
9604 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
9606 static unsigned char buffer
[8 * 1024];
9608 bfd_size_type count
;
9609 unsigned long crc
= 0;
9612 sep_data
= open_debug_file (pathname
);
9613 if (sep_data
== NULL
)
9616 /* Yes - we are opening the file twice... */
9617 f
= fopen (pathname
, "rb");
9620 /* Paranoia: This should never happen. */
9621 close_debug_file (sep_data
);
9622 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
9626 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
9627 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
9631 if (crc
!= * (unsigned long *) crc_pointer
)
9633 close_debug_file (sep_data
);
9634 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
9643 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
9646 unsigned int crc_offset
;
9647 unsigned long * crc32
= (unsigned long *) data
;
9649 /* The name is first.
9650 The CRC value is stored after the filename, aligned up to 4 bytes. */
9651 name
= (const char *) section
->start
;
9653 crc_offset
= strnlen (name
, section
->size
) + 1;
9654 crc_offset
= (crc_offset
+ 3) & ~3;
9655 if (crc_offset
+ 4 > section
->size
)
9658 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
9663 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
9665 void * sep_data
= open_debug_file (filename
);
9667 if (sep_data
== NULL
)
9670 /* FIXME: We should now extract the build-id in the separate file
9676 typedef struct build_id_data
9679 const unsigned char * data
;
9683 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
9686 bfd_size_type namelen
;
9687 bfd_size_type id_len
;
9688 Build_id_data
* build_id_data
;
9690 /* The name is first.
9691 The build-id follows immediately, with no padding, up to the section's end. */
9693 name
= (const char *) section
->start
;
9694 namelen
= strnlen (name
, section
->size
) + 1;
9695 if (namelen
>= section
->size
)
9698 id_len
= section
->size
- namelen
;
9702 build_id_data
= calloc (1, sizeof * build_id_data
);
9703 if (build_id_data
== NULL
)
9706 build_id_data
->len
= id_len
;
9707 build_id_data
->data
= section
->start
+ namelen
;
9709 * (Build_id_data
**) data
= build_id_data
;
9715 load_separate_debug_info (const char * main_filename
,
9716 struct dwarf_section
* xlink
,
9717 parse_func_type parse_func
,
9718 check_func_type check_func
,
9721 const char * separate_filename
;
9724 size_t canon_dirlen
;
9727 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
9729 warn (_("Corrupt debuglink section: %s\n"),
9730 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
9734 /* Attempt to locate the separate file.
9735 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
9737 canon_dir
= lrealpath (main_filename
);
9739 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
9740 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
9742 canon_dir
[canon_dirlen
] = '\0';
9745 #define DEBUGDIR "/lib/debug"
9747 #ifndef EXTRA_DEBUG_ROOT1
9748 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
9750 #ifndef EXTRA_DEBUG_ROOT2
9751 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
9754 debugfile
= (char *) malloc (strlen (DEBUGDIR
) + 1
9756 + strlen (".debug/")
9757 #ifdef EXTRA_DEBUG_ROOT1
9758 + strlen (EXTRA_DEBUG_ROOT1
)
9760 #ifdef EXTRA_DEBUG_ROOT2
9761 + strlen (EXTRA_DEBUG_ROOT2
)
9763 + strlen (separate_filename
)
9765 if (debugfile
== NULL
)
9767 warn (_("Out of memory"));
9771 /* First try in the current directory. */
9772 sprintf (debugfile
, "%s", separate_filename
);
9773 if (check_func (debugfile
, func_data
))
9776 /* Then try in a subdirectory called .debug. */
9777 sprintf (debugfile
, ".debug/%s", separate_filename
);
9778 if (check_func (debugfile
, func_data
))
9781 /* Then try in the same directory as the original file. */
9782 sprintf (debugfile
, "%s%s", canon_dir
, separate_filename
);
9783 if (check_func (debugfile
, func_data
))
9786 /* And the .debug subdirectory of that directory. */
9787 sprintf (debugfile
, "%s.debug/%s", canon_dir
, separate_filename
);
9788 if (check_func (debugfile
, func_data
))
9791 #ifdef EXTRA_DEBUG_ROOT1
9792 /* Try the first extra debug file root. */
9793 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
9794 if (check_func (debugfile
, func_data
))
9798 #ifdef EXTRA_DEBUG_ROOT2
9799 /* Try the second extra debug file root. */
9800 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
9801 if (check_func (debugfile
, func_data
))
9805 /* Then try in the global debugfile directory. */
9806 strcpy (debugfile
, DEBUGDIR
);
9807 dirlen
= strlen (DEBUGDIR
) - 1;
9808 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
9809 strcat (debugfile
, "/");
9810 strcat (debugfile
, (const char *) separate_filename
);
9812 if (check_func (debugfile
, func_data
))
9815 /* Failed to find the file. */
9816 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
9817 warn (_("tried: %s\n"), debugfile
);
9819 #ifdef EXTRA_DEBUG_ROOT2
9820 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
9821 warn (_("tried: %s\n"), debugfile
);
9824 #ifdef EXTRA_DEBUG_ROOT1
9825 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
9826 warn (_("tried: %s\n"), debugfile
);
9829 sprintf (debugfile
, "%s.debug/%s", canon_dir
, separate_filename
);
9830 warn (_("tried: %s\n"), debugfile
);
9832 sprintf (debugfile
, "%s%s", canon_dir
, separate_filename
);
9833 warn (_("tried: %s\n"), debugfile
);
9835 sprintf (debugfile
, ".debug/%s", separate_filename
);
9836 warn (_("tried: %s\n"), debugfile
);
9838 sprintf (debugfile
, "%s", separate_filename
);
9839 warn (_("tried: %s\n"), debugfile
);
9848 /* Now open the file.... */
9849 if ((separate_debug_file
= open_debug_file (debugfile
)) == NULL
)
9851 warn (_("failed to open separate debug file: %s\n"), debugfile
);
9856 /* FIXME: We do not check to see if there are any other separate debug info
9857 files that would also match. */
9859 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debugfile
);
9860 separate_debug_filename
= debugfile
;
9862 /* Do not free debugfile - it might be referenced inside
9863 the structure returned by open_debug_file(). */
9864 return separate_debug_file
;
9867 /* Attempt to load a separate dwarf object file. */
9870 load_dwo_file (const char * main_filename
)
9874 /* FIXME: Skip adding / if dwo_dir ends in /. */
9875 filename
= concat (dwo_dir
, "/", dwo_name
, NULL
);
9876 if (filename
== NULL
)
9878 warn (_("Out of memory allocating dwo filename\n"));
9882 if ((separate_debug_file
= open_debug_file (filename
)) == NULL
)
9884 warn (_("Unable to load dwo file: %s\n"), filename
);
9889 /* FIXME: We should check the dwo_id. */
9891 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, filename
);
9892 separate_debug_filename
= filename
;
9893 return separate_debug_file
;
9896 /* Load a separate debug info file, if it exists.
9897 Returns the data pointer that is the result of calling open_debug_file
9898 on the separate debug info file, or NULL if there were problems or there
9902 load_separate_debug_file (void * file
, const char * filename
)
9904 /* Skip this operation if we are not interested in debug links. */
9905 if (! do_follow_links
&& ! do_debug_links
)
9908 /* See if there is a dwo link. */
9909 if (load_debug_section (str
, file
)
9910 && load_debug_section (abbrev
, file
)
9911 && load_debug_section (info
, file
))
9913 dwo_name
= dwo_dir
= NULL
;
9917 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
9919 if (dwo_name
!= NULL
)
9923 printf (_("The %s section contains a link to a dwo file:\n"),
9924 debug_displays
[info
].section
.uncompressed_name
);
9925 printf (_(" Name: %s\n"), dwo_name
);
9926 printf (_(" Directory: %s\n"), dwo_dir
? dwo_dir
: _("<not-found>"));
9928 display_data (printf (_(" ID: ")), dwo_id
, dwo_id_len
);
9930 printf (_(" ID: <unknown>\n"));
9934 /* FIXME: We do not check to see if there are any more dwo links in the file... */
9935 if (do_follow_links
)
9936 return load_dwo_file (filename
);
9941 if (! do_follow_links
)
9942 /* The other debug links will be displayed by display_debug_links()
9943 so we do not need to do any further processing here. */
9946 /* FIXME: We do not check for the presence of both link sections in the same file. */
9947 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
9948 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
9949 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
9951 if (load_debug_section (gnu_debugaltlink
, file
))
9953 Build_id_data
* build_id_data
;
9955 return load_separate_debug_info (filename
,
9956 & debug_displays
[gnu_debugaltlink
].section
,
9957 parse_gnu_debugaltlink
,
9958 check_gnu_debugaltlink
,
9962 if (load_debug_section (gnu_debuglink
, file
))
9964 unsigned long crc32
;
9966 return load_separate_debug_info (filename
,
9967 & debug_displays
[gnu_debuglink
].section
,
9968 parse_gnu_debuglink
,
9969 check_gnu_debuglink
,
9973 do_follow_links
= 0;
9978 free_debug_memory (void)
9984 for (i
= 0; i
< max
; i
++)
9985 free_debug_section ((enum dwarf_section_display_enum
) i
);
9987 if (debug_information
!= NULL
)
9989 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
9991 for (i
= 0; i
< num_debug_info_entries
; i
++)
9993 if (!debug_information
[i
].max_loc_offsets
)
9995 free (debug_information
[i
].loc_offsets
);
9996 free (debug_information
[i
].have_frame_base
);
9998 if (!debug_information
[i
].max_range_lists
)
9999 free (debug_information
[i
].range_lists
);
10002 free (debug_information
);
10003 debug_information
= NULL
;
10004 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
10007 if (separate_debug_file
!= NULL
)
10009 close_debug_file (separate_debug_file
);
10010 separate_debug_file
= NULL
;
10012 free ((void *) separate_debug_filename
);
10013 separate_debug_filename
= NULL
;
10018 dwarf_select_sections_by_names (const char *names
)
10022 const char * option
;
10026 debug_dump_long_opts
;
10028 static const debug_dump_long_opts opts_table
[] =
10030 /* Please keep this table alpha- sorted. */
10031 { "Ranges", & do_debug_ranges
, 1 },
10032 { "abbrev", & do_debug_abbrevs
, 1 },
10033 { "addr", & do_debug_addr
, 1 },
10034 { "aranges", & do_debug_aranges
, 1 },
10035 { "cu_index", & do_debug_cu_index
, 1 },
10036 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10037 { "follow-links", & do_follow_links
, 1 },
10038 { "frames", & do_debug_frames
, 1 },
10039 { "frames-interp", & do_debug_frames_interp
, 1 },
10040 /* The special .gdb_index section. */
10041 { "gdb_index", & do_gdb_index
, 1 },
10042 { "info", & do_debug_info
, 1 },
10043 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10044 { "links", & do_debug_links
, 1 },
10045 { "loc", & do_debug_loc
, 1 },
10046 { "macro", & do_debug_macinfo
, 1 },
10047 { "pubnames", & do_debug_pubnames
, 1 },
10048 { "pubtypes", & do_debug_pubtypes
, 1 },
10049 /* This entry is for compatibility
10050 with earlier versions of readelf. */
10051 { "ranges", & do_debug_aranges
, 1 },
10052 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10053 { "str", & do_debug_str
, 1 },
10054 /* These trace_* sections are used by Itanium VMS. */
10055 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10056 { "trace_aranges", & do_trace_aranges
, 1 },
10057 { "trace_info", & do_trace_info
, 1 },
10066 const debug_dump_long_opts
* entry
;
10068 for (entry
= opts_table
; entry
->option
; entry
++)
10070 size_t len
= strlen (entry
->option
);
10072 if (strncmp (p
, entry
->option
, len
) == 0
10073 && (p
[len
] == ',' || p
[len
] == '\0'))
10075 * entry
->variable
|= entry
->val
;
10077 /* The --debug-dump=frames-interp option also
10078 enables the --debug-dump=frames option. */
10079 if (do_debug_frames_interp
)
10080 do_debug_frames
= 1;
10087 if (entry
->option
== NULL
)
10089 warn (_("Unrecognized debug option '%s'\n"), p
);
10090 p
= strchr (p
, ',');
10101 dwarf_select_sections_by_letters (const char *letters
)
10103 unsigned int lindex
= 0;
10105 while (letters
[lindex
])
10106 switch (letters
[lindex
++])
10108 case 'A': do_debug_addr
= 1; break;
10109 case 'a': do_debug_abbrevs
= 1; break;
10110 case 'c': do_debug_cu_index
= 1; break;
10111 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10112 case 'f': do_debug_frames
= 1; break;
10113 case 'g': do_gdb_index
= 1; break;
10114 case 'i': do_debug_info
= 1; break;
10115 case 'K': do_follow_links
= 1; break;
10116 case 'k': do_debug_links
= 1; break;
10117 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10118 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10119 case 'm': do_debug_macinfo
= 1; break;
10120 case 'o': do_debug_loc
= 1; break;
10121 case 'p': do_debug_pubnames
= 1; break;
10122 case 'R': do_debug_ranges
= 1; break;
10123 case 'r': do_debug_aranges
= 1; break;
10124 case 's': do_debug_str
= 1; break;
10125 case 'T': do_trace_aranges
= 1; break;
10126 case 't': do_debug_pubtypes
= 1; break;
10127 case 'U': do_trace_info
= 1; break;
10128 case 'u': do_trace_abbrevs
= 1; break;
10131 warn (_("Unrecognized debug option '%s'\n"), letters
);
10137 dwarf_select_sections_all (void)
10140 do_debug_abbrevs
= 1;
10141 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10142 do_debug_pubnames
= 1;
10143 do_debug_pubtypes
= 1;
10144 do_debug_aranges
= 1;
10145 do_debug_ranges
= 1;
10146 do_debug_frames
= 1;
10147 do_debug_macinfo
= 1;
10152 do_trace_abbrevs
= 1;
10153 do_trace_aranges
= 1;
10155 do_debug_cu_index
= 1;
10156 do_follow_links
= 1;
10157 do_debug_links
= 1;
10160 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10161 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10163 /* N.B. The order here must match the order in section_display_enum. */
10165 struct dwarf_section_display debug_displays
[] =
10167 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10168 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10169 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10170 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10171 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10172 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10173 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10174 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10175 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10176 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10177 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10178 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10179 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10180 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10181 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10182 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10183 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10184 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10185 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10186 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10187 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10188 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10189 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10190 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10191 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10192 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10193 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10194 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10195 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10196 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10197 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10198 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10199 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10200 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10201 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10202 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10203 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10204 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10205 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10206 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10207 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10208 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10209 /* Separate debug info files can containt their own .debug_str section,
10210 and this might be in *addition* to a .debug_str section already present
10211 in the main file. Hence we need to have two entries for .debug_str. */
10212 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10215 /* A static assertion. */
10216 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];