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_Go
: printf ("(Go)"); break;
2356 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2357 case DW_LANG_C11
: printf ("(C11)"); break;
2358 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2359 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2360 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2361 /* MIPS extension. */
2362 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2363 /* UPC extension. */
2364 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2366 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2367 printf (_("(implementation defined: %s)"),
2368 dwarf_vmatoa ("x", uvalue
));
2370 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2375 case DW_AT_encoding
:
2379 case DW_ATE_void
: printf ("(void)"); break;
2380 case DW_ATE_address
: printf ("(machine address)"); break;
2381 case DW_ATE_boolean
: printf ("(boolean)"); break;
2382 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2383 case DW_ATE_float
: printf ("(float)"); break;
2384 case DW_ATE_signed
: printf ("(signed)"); break;
2385 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2386 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2387 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2388 /* DWARF 2.1 values: */
2389 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2390 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2391 /* DWARF 3 values: */
2392 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2393 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2394 case DW_ATE_edited
: printf ("(edited)"); break;
2395 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2396 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2397 /* DWARF 4 values: */
2398 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2399 /* DWARF 5 values: */
2400 case DW_ATE_UCS
: printf ("(UCS)"); break;
2401 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
2403 /* HP extensions: */
2404 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2405 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2406 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2407 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2408 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2409 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2410 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2413 if (uvalue
>= DW_ATE_lo_user
2414 && uvalue
<= DW_ATE_hi_user
)
2415 printf (_("(user defined type)"));
2417 printf (_("(unknown type)"));
2422 case DW_AT_accessibility
:
2426 case DW_ACCESS_public
: printf ("(public)"); break;
2427 case DW_ACCESS_protected
: printf ("(protected)"); break;
2428 case DW_ACCESS_private
: printf ("(private)"); break;
2430 printf (_("(unknown accessibility)"));
2435 case DW_AT_visibility
:
2439 case DW_VIS_local
: printf ("(local)"); break;
2440 case DW_VIS_exported
: printf ("(exported)"); break;
2441 case DW_VIS_qualified
: printf ("(qualified)"); break;
2442 default: printf (_("(unknown visibility)")); break;
2446 case DW_AT_endianity
:
2450 case DW_END_default
: printf ("(default)"); break;
2451 case DW_END_big
: printf ("(big)"); break;
2452 case DW_END_little
: printf ("(little)"); break;
2454 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
2455 printf (_("(user specified)"));
2457 printf (_("(unknown endianity)"));
2462 case DW_AT_virtuality
:
2466 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2467 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2468 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2469 default: printf (_("(unknown virtuality)")); break;
2473 case DW_AT_identifier_case
:
2477 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2478 case DW_ID_up_case
: printf ("(up_case)"); break;
2479 case DW_ID_down_case
: printf ("(down_case)"); break;
2480 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2481 default: printf (_("(unknown case)")); break;
2485 case DW_AT_calling_convention
:
2489 case DW_CC_normal
: printf ("(normal)"); break;
2490 case DW_CC_program
: printf ("(program)"); break;
2491 case DW_CC_nocall
: printf ("(nocall)"); break;
2492 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
2493 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
2494 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
2495 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
2497 if (uvalue
>= DW_CC_lo_user
2498 && uvalue
<= DW_CC_hi_user
)
2499 printf (_("(user defined)"));
2501 printf (_("(unknown convention)"));
2505 case DW_AT_ordering
:
2510 case -1: printf (_("(undefined)")); break;
2511 case 0: printf ("(row major)"); break;
2512 case 1: printf ("(column major)"); break;
2516 case DW_AT_decimal_sign
:
2520 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
2521 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
2522 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
2523 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
2524 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
2525 default: printf (_("(unrecognised)")); break;
2529 case DW_AT_defaulted
:
2533 case DW_DEFAULTED_no
: printf (_("(no)")); break;
2534 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
2535 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
2536 default: printf (_("(unrecognised)")); break;
2540 case DW_AT_discr_list
:
2544 case DW_DSC_label
: printf (_("(label)")); break;
2545 case DW_DSC_range
: printf (_("(range)")); break;
2546 default: printf (_("(unrecognised)")); break;
2550 case DW_AT_frame_base
:
2551 have_frame_base
= 1;
2553 case DW_AT_location
:
2554 case DW_AT_string_length
:
2555 case DW_AT_return_addr
:
2556 case DW_AT_data_member_location
:
2557 case DW_AT_vtable_elem_location
:
2559 case DW_AT_static_link
:
2560 case DW_AT_use_location
:
2561 case DW_AT_call_value
:
2562 case DW_AT_GNU_call_site_value
:
2563 case DW_AT_call_data_value
:
2564 case DW_AT_GNU_call_site_data_value
:
2565 case DW_AT_call_target
:
2566 case DW_AT_GNU_call_site_target
:
2567 case DW_AT_call_target_clobbered
:
2568 case DW_AT_GNU_call_site_target_clobbered
:
2569 if ((dwarf_version
< 4
2570 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2571 || form
== DW_FORM_sec_offset
)
2572 printf (_(" (location list)"));
2574 case DW_AT_allocated
:
2575 case DW_AT_associated
:
2576 case DW_AT_data_location
:
2578 case DW_AT_upper_bound
:
2579 case DW_AT_lower_bound
:
2582 int need_frame_base
;
2585 need_frame_base
= decode_location_expression (block_start
,
2590 cu_offset
, section
);
2592 if (need_frame_base
&& !have_frame_base
)
2593 printf (_(" [without DW_AT_frame_base]"));
2597 case DW_AT_data_bit_offset
:
2598 case DW_AT_byte_size
:
2599 case DW_AT_bit_size
:
2600 case DW_AT_string_length_byte_size
:
2601 case DW_AT_string_length_bit_size
:
2602 case DW_AT_bit_stride
:
2603 if (form
== DW_FORM_exprloc
)
2606 (void) decode_location_expression (block_start
, pointer_size
,
2607 offset_size
, dwarf_version
,
2608 uvalue
, cu_offset
, section
);
2615 if (form
== DW_FORM_ref_sig8
2616 || form
== DW_FORM_GNU_ref_alt
)
2619 if (form
== DW_FORM_ref1
2620 || form
== DW_FORM_ref2
2621 || form
== DW_FORM_ref4
2622 || form
== DW_FORM_ref_udata
)
2623 uvalue
+= cu_offset
;
2625 if (uvalue
>= section
->size
)
2626 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2627 dwarf_vmatoa ("x", uvalue
),
2628 (unsigned long) (orig_data
- section
->start
));
2631 unsigned long abbrev_number
;
2632 abbrev_entry
* entry
;
2634 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2636 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2637 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2638 use different abbrev table, and we don't track .debug_info chunks
2640 if (form
!= DW_FORM_ref_addr
)
2642 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2643 if (entry
->entry
== abbrev_number
)
2646 printf (" (%s)", get_TAG_name (entry
->tag
));
2660 static unsigned char *
2661 read_and_display_attr (unsigned long attribute
,
2663 dwarf_signed_vma implicit_const
,
2664 unsigned char * data
,
2665 unsigned char * end
,
2666 dwarf_vma cu_offset
,
2667 dwarf_vma pointer_size
,
2668 dwarf_vma offset_size
,
2670 debug_info
* debug_info_p
,
2672 struct dwarf_section
* section
,
2673 struct cu_tu_set
* this_set
)
2676 printf (" %-18s:", get_AT_name (attribute
));
2677 data
= read_and_display_attr_value (attribute
, form
, implicit_const
, data
, end
,
2678 cu_offset
, pointer_size
, offset_size
,
2679 dwarf_version
, debug_info_p
,
2680 do_loc
, section
, this_set
, ' ');
2686 /* Like load_debug_section, but if the ordinary call fails, and we are
2687 following debug links, and we have been able to load a separate debug
2688 info file, then attempt to load the requested section from the separate
2692 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
2695 if (load_debug_section (sec_enum
, data
))
2697 if (data
== separate_debug_file
)
2698 debug_displays
[sec_enum
].section
.filename
= separate_debug_filename
;
2700 /* FIXME: We should check to see if there is a separate debug info file
2701 that also contains this section, and if so, issue a warning. */
2705 if (do_follow_links
&& separate_debug_file
!= NULL
)
2706 if (load_debug_section (sec_enum
, separate_debug_file
))
2708 debug_displays
[sec_enum
].section
.filename
= separate_debug_filename
;
2716 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
2720 if (do_follow_links
&& section
->filename
)
2721 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
2722 section
->name
, section
->filename
);
2724 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
2728 if (do_follow_links
&& section
->filename
)
2729 printf (_("Contents of the %s section (loaded from %s):\n\n"),
2730 section
->name
, section
->filename
);
2732 printf (_("Contents of the %s section:\n\n"), section
->name
);
2736 /* Process the contents of a .debug_info section.
2737 If do_loc is TRUE then we are scanning for location lists and dwo tags
2738 and we do not want to display anything to the user.
2739 If do_types is TRUE, we are processing a .debug_types section instead of
2740 a .debug_info section.
2741 The information displayed is restricted by the values in DWARF_START_DIE
2742 and DWARF_CUTOFF_LEVEL.
2743 Returns TRUE upon success. Otherwise an error or warning message is
2744 printed and FALSE is returned. */
2747 process_debug_info (struct dwarf_section
* section
,
2749 enum dwarf_section_display_enum abbrev_sec
,
2751 bfd_boolean do_types
)
2753 unsigned char *start
= section
->start
;
2754 unsigned char *end
= start
+ section
->size
;
2755 unsigned char *section_begin
;
2757 unsigned int num_units
= 0;
2759 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2760 && num_debug_info_entries
== 0
2765 /* First scan the section to get the number of comp units. */
2766 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2769 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2770 will be the length. For a 64-bit DWARF section, it'll be
2771 the escape code 0xffffffff followed by an 8 byte length. */
2772 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2774 if (length
== 0xffffffff)
2776 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2777 section_begin
+= length
+ 12;
2779 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2781 warn (_("Reserved length value (0x%s) found in section %s\n"),
2782 dwarf_vmatoa ("x", length
), section
->name
);
2786 section_begin
+= length
+ 4;
2788 /* Negative values are illegal, they may even cause infinite
2789 looping. This can happen if we can't accurately apply
2790 relocations to an object file, or if the file is corrupt. */
2791 if ((signed long) length
<= 0 || section_begin
< start
)
2793 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2794 dwarf_vmatoa ("x", length
), section
->name
);
2801 error (_("No comp units in %s section ?\n"), section
->name
);
2805 /* Then allocate an array to hold the information. */
2806 debug_information
= (debug_info
*) cmalloc (num_units
,
2807 sizeof (* debug_information
));
2808 if (debug_information
== NULL
)
2810 error (_("Not enough memory for a debug info array of %u entries\n"),
2812 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
2816 /* PR 17531: file: 92ca3797.
2817 We cannot rely upon the debug_information array being initialised
2818 before it is used. A corrupt file could easily contain references
2819 to a unit for which information has not been made available. So
2820 we ensure that the array is zeroed here. */
2821 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
2823 alloc_num_debug_info_entries
= num_units
;
2828 load_debug_section_with_follow (str
, file
);
2829 load_debug_section_with_follow (line_str
, file
);
2830 load_debug_section_with_follow (str_dwo
, file
);
2831 load_debug_section_with_follow (str_index
, file
);
2832 load_debug_section_with_follow (str_index_dwo
, file
);
2833 load_debug_section_with_follow (debug_addr
, file
);
2836 load_debug_section_with_follow (abbrev_sec
, file
);
2837 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2839 warn (_("Unable to locate %s section!\n"),
2840 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
2844 if (!do_loc
&& dwarf_start_die
== 0)
2845 introduce (section
, FALSE
);
2847 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2849 DWARF2_Internal_CompUnit compunit
;
2850 unsigned char *hdrptr
;
2851 unsigned char *tags
;
2852 int level
, last_level
, saved_level
;
2853 dwarf_vma cu_offset
;
2854 unsigned long sec_off
;
2855 unsigned int offset_size
;
2856 unsigned int initial_length_size
;
2857 dwarf_vma signature_high
= 0;
2858 dwarf_vma signature_low
= 0;
2859 dwarf_vma type_offset
= 0;
2860 struct cu_tu_set
*this_set
;
2861 dwarf_vma abbrev_base
;
2866 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2868 if (compunit
.cu_length
== 0xffffffff)
2870 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2872 initial_length_size
= 12;
2877 initial_length_size
= 4;
2880 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2882 cu_offset
= start
- section_begin
;
2884 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2886 if (compunit
.cu_version
< 5)
2888 compunit
.cu_unit_type
= DW_UT_compile
;
2889 /* Initialize it due to a false compiler warning. */
2890 compunit
.cu_pointer_size
= -1;
2894 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
2895 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
2897 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2900 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2902 if (this_set
== NULL
)
2905 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2909 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2910 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2913 if (compunit
.cu_version
< 5)
2914 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2916 /* PR 17512: file: 001-108546-0.001:0.1. */
2917 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2919 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2920 compunit
.cu_pointer_size
, offset_size
);
2921 compunit
.cu_pointer_size
= offset_size
;
2926 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2928 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2931 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
2932 + initial_length_size
))
2934 start
= section_begin
+ cu_offset
+ compunit
.cu_length
2935 + initial_length_size
;
2939 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2940 && num_debug_info_entries
== 0
2943 debug_information
[unit
].cu_offset
= cu_offset
;
2944 debug_information
[unit
].pointer_size
2945 = compunit
.cu_pointer_size
;
2946 debug_information
[unit
].offset_size
= offset_size
;
2947 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2948 debug_information
[unit
].base_address
= 0;
2949 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2950 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2951 debug_information
[unit
].loc_offsets
= NULL
;
2952 debug_information
[unit
].have_frame_base
= NULL
;
2953 debug_information
[unit
].max_loc_offsets
= 0;
2954 debug_information
[unit
].num_loc_offsets
= 0;
2955 debug_information
[unit
].range_lists
= NULL
;
2956 debug_information
[unit
].max_range_lists
= 0;
2957 debug_information
[unit
].num_range_lists
= 0;
2960 if (!do_loc
&& dwarf_start_die
== 0)
2962 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2963 dwarf_vmatoa ("x", cu_offset
));
2964 printf (_(" Length: 0x%s (%s)\n"),
2965 dwarf_vmatoa ("x", compunit
.cu_length
),
2966 offset_size
== 8 ? "64-bit" : "32-bit");
2967 printf (_(" Version: %d\n"), compunit
.cu_version
);
2968 printf (_(" Abbrev Offset: 0x%s\n"),
2969 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2970 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2975 printf (_(" Signature: 0x%s\n"),
2976 dwarf_vmatoa64 (signature_high
, signature_low
,
2977 buf
, sizeof (buf
)));
2978 printf (_(" Type Offset: 0x%s\n"),
2979 dwarf_vmatoa ("x", type_offset
));
2981 if (this_set
!= NULL
)
2983 dwarf_vma
*offsets
= this_set
->section_offsets
;
2984 size_t *sizes
= this_set
->section_sizes
;
2986 printf (_(" Section contributions:\n"));
2987 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2988 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2989 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2990 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2991 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2992 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2993 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2994 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2995 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2996 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2997 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2998 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3002 sec_off
= cu_offset
+ initial_length_size
;
3003 if (sec_off
+ compunit
.cu_length
< sec_off
3004 || sec_off
+ compunit
.cu_length
> section
->size
)
3006 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3008 (unsigned long) cu_offset
,
3009 dwarf_vmatoa ("x", compunit
.cu_length
));
3015 start
+= compunit
.cu_length
+ initial_length_size
;
3017 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3019 warn (_("CU at offset %s contains corrupt or "
3020 "unsupported version number: %d.\n"),
3021 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3025 if (compunit
.cu_unit_type
!= DW_UT_compile
3026 && compunit
.cu_unit_type
!= DW_UT_type
)
3028 warn (_("CU at offset %s contains corrupt or "
3029 "unsupported unit type: %d.\n"),
3030 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3036 /* Process the abbrevs used by this compilation unit. */
3037 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3038 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3039 (unsigned long) compunit
.cu_abbrev_offset
,
3040 (unsigned long) abbrev_size
);
3041 /* PR 17531: file:4bcd9ce9. */
3042 else if ((abbrev_base
+ abbrev_size
)
3043 > debug_displays
[abbrev_sec
].section
.size
)
3044 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3045 (unsigned long) abbrev_base
+ abbrev_size
,
3046 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3048 process_abbrev_section
3049 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3050 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3051 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3052 + abbrev_base
+ abbrev_size
));
3057 while (tags
< start
)
3059 unsigned int bytes_read
;
3060 unsigned long abbrev_number
;
3061 unsigned long die_offset
;
3062 abbrev_entry
*entry
;
3064 int do_printing
= 1;
3066 die_offset
= tags
- section_begin
;
3068 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
3071 /* A null DIE marks the end of a list of siblings or it may also be
3072 a section padding. */
3073 if (abbrev_number
== 0)
3075 /* Check if it can be a section padding for the last CU. */
3076 if (level
== 0 && start
== end
)
3080 for (chk
= tags
; chk
< start
; chk
++)
3087 if (!do_loc
&& die_offset
>= dwarf_start_die
3088 && (dwarf_cutoff_level
== -1
3089 || level
< dwarf_cutoff_level
))
3090 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3096 static unsigned num_bogus_warns
= 0;
3098 if (num_bogus_warns
< 3)
3100 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3101 die_offset
, section
->name
);
3103 if (num_bogus_warns
== 3)
3104 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3107 if (dwarf_start_die
!= 0 && level
< saved_level
)
3114 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3118 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3119 saved_level
= level
;
3120 do_printing
= (dwarf_cutoff_level
== -1
3121 || level
< dwarf_cutoff_level
);
3123 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3124 level
, die_offset
, abbrev_number
);
3125 else if (dwarf_cutoff_level
== -1
3126 || last_level
< dwarf_cutoff_level
)
3127 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3132 /* Scan through the abbreviation list until we reach the
3134 for (entry
= first_abbrev
;
3135 entry
&& entry
->entry
!= abbrev_number
;
3136 entry
= entry
->next
)
3141 if (!do_loc
&& do_printing
)
3146 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3147 die_offset
, abbrev_number
);
3151 if (!do_loc
&& do_printing
)
3152 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3157 need_base_address
= 0;
3159 case DW_TAG_compile_unit
:
3160 need_base_address
= 1;
3161 need_dwo_info
= do_loc
;
3163 case DW_TAG_entry_point
:
3164 case DW_TAG_subprogram
:
3165 need_base_address
= 0;
3166 /* Assuming that there is no DW_AT_frame_base. */
3167 have_frame_base
= 0;
3171 debug_info
*debug_info_p
=
3172 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3173 ? debug_information
+ unit
: NULL
;
3175 assert (!debug_info_p
3176 || (debug_info_p
->num_loc_offsets
3177 == debug_info_p
->num_loc_views
));
3179 for (attr
= entry
->first_attr
;
3180 attr
&& attr
->attribute
;
3183 if (! do_loc
&& do_printing
)
3184 /* Show the offset from where the tag was extracted. */
3185 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3187 tags
= read_and_display_attr (attr
->attribute
,
3189 attr
->implicit_const
,
3193 compunit
.cu_pointer_size
,
3195 compunit
.cu_version
,
3197 do_loc
|| ! do_printing
,
3202 /* If a locview attribute appears before a location one,
3203 make sure we don't associate it with an earlier
3206 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3209 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3210 debug_info_p
->num_loc_views
++;
3211 assert (debug_info_p
->num_loc_views
3212 == debug_info_p
->num_loc_offsets
);
3219 warn(_("DIE has locviews without loclist\n"));
3220 debug_info_p
->num_loc_views
--;
3227 if (entry
->children
)
3232 /* Set num_debug_info_entries here so that it can be used to check if
3233 we need to process .debug_loc and .debug_ranges sections. */
3234 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3235 && num_debug_info_entries
== 0
3238 if (num_units
> alloc_num_debug_info_entries
)
3239 num_debug_info_entries
= alloc_num_debug_info_entries
;
3241 num_debug_info_entries
= num_units
;
3250 /* Locate and scan the .debug_info section in the file and record the pointer
3251 sizes and offsets for the compilation units in it. Usually an executable
3252 will have just one pointer size, but this is not guaranteed, and so we try
3253 not to make any assumptions. Returns zero upon failure, or the number of
3254 compilation units upon success. */
3257 load_debug_info (void * file
)
3259 /* If we have already tried and failed to load the .debug_info
3260 section then do not bother to repeat the task. */
3261 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3264 /* If we already have the information there is nothing else to do. */
3265 if (num_debug_info_entries
> 0)
3266 return num_debug_info_entries
;
3268 /* If this is a DWARF package file, load the CU and TU indexes. */
3269 (void) load_cu_tu_indexes (file
);
3271 if (load_debug_section_with_follow (info
, file
)
3272 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
3273 return num_debug_info_entries
;
3275 if (load_debug_section_with_follow (info_dwo
, file
)
3276 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3277 abbrev_dwo
, TRUE
, FALSE
))
3278 return num_debug_info_entries
;
3280 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3284 /* Read a DWARF .debug_line section header starting at DATA.
3285 Upon success returns an updated DATA pointer and the LINFO
3286 structure and the END_OF_SEQUENCE pointer will be filled in.
3287 Otherwise returns NULL. */
3289 static unsigned char *
3290 read_debug_line_header (struct dwarf_section
* section
,
3291 unsigned char * data
,
3292 unsigned char * end
,
3293 DWARF2_Internal_LineInfo
* linfo
,
3294 unsigned char ** end_of_sequence
)
3296 unsigned char *hdrptr
;
3297 unsigned int initial_length_size
;
3298 unsigned char address_size
, segment_selector_size
;
3300 /* Extract information from the Line Number Program Header.
3301 (section 6.2.4 in the Dwarf3 doc). */
3304 /* Get and check the length of the block. */
3305 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3307 if (linfo
->li_length
== 0xffffffff)
3309 /* This section is 64-bit DWARF 3. */
3310 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3311 linfo
->li_offset_size
= 8;
3312 initial_length_size
= 12;
3316 linfo
->li_offset_size
= 4;
3317 initial_length_size
= 4;
3320 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3322 /* If the length field has a relocation against it, then we should
3323 not complain if it is inaccurate (and probably negative). This
3324 happens in object files when the .debug_line section is actually
3325 comprised of several different .debug_line.* sections, (some of
3326 which may be removed by linker garbage collection), and a relocation
3327 is used to compute the correct length once that is done. */
3328 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3330 linfo
->li_length
= (end
- data
) - initial_length_size
;
3334 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3335 (long) linfo
->li_length
);
3340 /* Get and check the version number. */
3341 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3343 if (linfo
->li_version
!= 2
3344 && linfo
->li_version
!= 3
3345 && linfo
->li_version
!= 4
3346 && linfo
->li_version
!= 5)
3348 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3349 "is currently supported.\n"));
3353 if (linfo
->li_version
>= 5)
3355 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
3357 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
3358 if (segment_selector_size
!= 0)
3360 warn (_("The %s section contains "
3361 "unsupported segment selector size: %d.\n"),
3362 section
->name
, segment_selector_size
);
3367 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3368 linfo
->li_offset_size
, end
);
3369 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3371 if (linfo
->li_version
>= 4)
3373 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3375 if (linfo
->li_max_ops_per_insn
== 0)
3377 warn (_("Invalid maximum operations per insn.\n"));
3382 linfo
->li_max_ops_per_insn
= 1;
3384 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3385 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3386 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3387 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3389 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3390 /* PR 17512: file:002-117414-0.004. */
3391 if (* end_of_sequence
> end
)
3393 warn (_("Line length %s extends beyond end of section\n"),
3394 dwarf_vmatoa ("u", linfo
->li_length
));
3395 * end_of_sequence
= end
;
3402 static unsigned char *
3403 display_formatted_table (unsigned char * data
,
3404 unsigned char * start
,
3405 unsigned char * end
,
3406 const DWARF2_Internal_LineInfo
* linfo
,
3407 struct dwarf_section
* section
,
3410 unsigned char *format_start
, format_count
, *format
, formati
;
3411 dwarf_vma data_count
, datai
;
3412 unsigned int bytes_read
, namepass
, last_entry
= 0;
3414 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3415 format_start
= data
;
3416 for (formati
= 0; formati
< format_count
; formati
++)
3418 read_uleb128 (data
, & bytes_read
, end
);
3420 read_uleb128 (data
, & bytes_read
, end
);
3424 warn (_("Corrupt %s format table entry\n"), what
);
3429 data_count
= read_uleb128 (data
, & bytes_read
, end
);
3433 warn (_("Corrupt %s list\n"), what
);
3437 if (data_count
== 0)
3439 printf (_("\n The %s Table is empty.\n"), what
);
3443 printf (_("\n The %s Table (offset 0x%lx):\n"), what
,
3444 (long)(data
- start
));
3446 printf (_(" Entry"));
3447 /* Delay displaying name as the last entry for better screen layout. */
3448 for (namepass
= 0; namepass
< 2; namepass
++)
3450 format
= format_start
;
3451 for (formati
= 0; formati
< format_count
; formati
++)
3453 dwarf_vma content_type
;
3455 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3456 format
+= bytes_read
;
3457 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3458 switch (content_type
)
3461 printf (_("\tName"));
3463 case DW_LNCT_directory_index
:
3464 printf (_("\tDir"));
3466 case DW_LNCT_timestamp
:
3467 printf (_("\tTime"));
3470 printf (_("\tSize"));
3473 printf (_("\tMD5"));
3476 printf (_("\t(Unknown format content type %s)"),
3477 dwarf_vmatoa ("u", content_type
));
3479 read_uleb128 (format
, & bytes_read
, end
);
3480 format
+= bytes_read
;
3485 for (datai
= 0; datai
< data_count
; datai
++)
3487 unsigned char *datapass
= data
;
3489 printf (" %d", last_entry
++);
3490 /* Delay displaying name as the last entry for better screen layout. */
3491 for (namepass
= 0; namepass
< 2; namepass
++)
3493 format
= format_start
;
3495 for (formati
= 0; formati
< format_count
; formati
++)
3497 dwarf_vma content_type
, form
;
3499 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3500 format
+= bytes_read
;
3501 form
= read_uleb128 (format
, & bytes_read
, end
);
3502 format
+= bytes_read
;
3503 data
= read_and_display_attr_value (0, form
, 0, data
, end
, 0, 0,
3504 linfo
->li_offset_size
,
3505 linfo
->li_version
, NULL
,
3506 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3507 section
, NULL
, '\t');
3512 warn (_("Corrupt %s entries list\n"), what
);
3521 display_debug_lines_raw (struct dwarf_section
* section
,
3522 unsigned char * data
,
3523 unsigned char * end
,
3526 unsigned char *start
= section
->start
;
3527 int verbose_view
= 0;
3529 introduce (section
, TRUE
);
3533 static DWARF2_Internal_LineInfo saved_linfo
;
3534 DWARF2_Internal_LineInfo linfo
;
3535 unsigned char *standard_opcodes
;
3536 unsigned char *end_of_sequence
;
3539 if (const_strneq (section
->name
, ".debug_line.")
3540 /* Note: the following does not apply to .debug_line.dwo sections.
3541 These are full debug_line sections. */
3542 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3544 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3545 section containing just the Line Number Statements. They are
3546 created by the assembler and intended to be used alongside gcc's
3547 -ffunction-sections command line option. When the linker's
3548 garbage collection decides to discard a .text.<foo> section it
3549 can then also discard the line number information in .debug_line.<foo>.
3551 Since the section is a fragment it does not have the details
3552 needed to fill out a LineInfo structure, so instead we use the
3553 details from the last full debug_line section that we processed. */
3554 end_of_sequence
= end
;
3555 standard_opcodes
= NULL
;
3556 linfo
= saved_linfo
;
3557 /* PR 17531: file: 0522b371. */
3558 if (linfo
.li_line_range
== 0)
3560 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3563 reset_state_machine (linfo
.li_default_is_stmt
);
3567 unsigned char * hdrptr
;
3569 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3570 & end_of_sequence
)) == NULL
)
3573 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3574 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3575 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3576 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3577 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3578 if (linfo
.li_version
>= 4)
3579 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3580 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3581 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3582 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3583 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3585 /* PR 17512: file: 1665-6428-0.004. */
3586 if (linfo
.li_line_range
== 0)
3588 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3589 linfo
.li_line_range
= 1;
3592 reset_state_machine (linfo
.li_default_is_stmt
);
3594 /* Display the contents of the Opcodes table. */
3595 standard_opcodes
= hdrptr
;
3597 /* PR 17512: file: 002-417945-0.004. */
3598 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3600 warn (_("Line Base extends beyond end of section\n"));
3604 printf (_("\n Opcodes:\n"));
3606 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3607 printf (ngettext (" Opcode %d has %d arg\n",
3608 " Opcode %d has %d args\n",
3609 standard_opcodes
[i
- 1]),
3610 i
, standard_opcodes
[i
- 1]);
3612 /* Display the contents of the Directory table. */
3613 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3615 if (linfo
.li_version
>= 5)
3617 load_debug_section_with_follow (line_str
, file
);
3619 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3621 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3627 printf (_("\n The Directory Table is empty.\n"));
3630 unsigned int last_dir_entry
= 0;
3632 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3633 (long)(data
- start
));
3635 while (data
< end
&& *data
!= 0)
3637 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
3639 data
+= strnlen ((char *) data
, end
- data
) + 1;
3642 /* PR 17512: file: 002-132094-0.004. */
3643 if (data
>= end
- 1)
3647 /* Skip the NUL at the end of the table. */
3650 /* Display the contents of the File Name table. */
3652 printf (_("\n The File Name Table is empty.\n"));
3655 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3656 (long)(data
- start
));
3657 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3659 while (data
< end
&& *data
!= 0)
3661 unsigned char *name
;
3662 unsigned int bytes_read
;
3664 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
3666 data
+= strnlen ((char *) data
, end
- data
) + 1;
3669 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3672 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3675 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3677 printf ("%.*s\n", (int)(end
- name
), name
);
3681 warn (_("Corrupt file name table entry\n"));
3687 /* Skip the NUL at the end of the table. */
3692 saved_linfo
= linfo
;
3695 /* Now display the statements. */
3696 if (data
>= end_of_sequence
)
3697 printf (_(" No Line Number Statements.\n"));
3700 printf (_(" Line Number Statements:\n"));
3702 while (data
< end_of_sequence
)
3704 unsigned char op_code
;
3705 dwarf_signed_vma adv
;
3707 unsigned int bytes_read
;
3709 printf (" [0x%08lx]", (long)(data
- start
));
3713 if (op_code
>= linfo
.li_opcode_base
)
3715 op_code
-= linfo
.li_opcode_base
;
3716 uladv
= (op_code
/ linfo
.li_line_range
);
3717 if (linfo
.li_max_ops_per_insn
== 1)
3719 uladv
*= linfo
.li_min_insn_length
;
3720 state_machine_regs
.address
+= uladv
;
3722 state_machine_regs
.view
= 0;
3723 printf (_(" Special opcode %d: "
3724 "advance Address by %s to 0x%s%s"),
3725 op_code
, dwarf_vmatoa ("u", uladv
),
3726 dwarf_vmatoa ("x", state_machine_regs
.address
),
3727 verbose_view
&& uladv
3728 ? _(" (reset view)") : "");
3733 = ((state_machine_regs
.op_index
+ uladv
)
3734 / linfo
.li_max_ops_per_insn
)
3735 * linfo
.li_min_insn_length
;
3737 state_machine_regs
.address
+= addrdelta
;
3738 state_machine_regs
.op_index
3739 = (state_machine_regs
.op_index
+ uladv
)
3740 % linfo
.li_max_ops_per_insn
;
3742 state_machine_regs
.view
= 0;
3743 printf (_(" Special opcode %d: "
3744 "advance Address by %s to 0x%s[%d]%s"),
3745 op_code
, dwarf_vmatoa ("u", uladv
),
3746 dwarf_vmatoa ("x", state_machine_regs
.address
),
3747 state_machine_regs
.op_index
,
3748 verbose_view
&& addrdelta
3749 ? _(" (reset view)") : "");
3751 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3752 state_machine_regs
.line
+= adv
;
3753 printf (_(" and Line by %s to %d"),
3754 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
3755 if (verbose_view
|| state_machine_regs
.view
)
3756 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3759 state_machine_regs
.view
++;
3761 else switch (op_code
)
3763 case DW_LNS_extended_op
:
3764 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3768 printf (_(" Copy"));
3769 if (verbose_view
|| state_machine_regs
.view
)
3770 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3773 state_machine_regs
.view
++;
3776 case DW_LNS_advance_pc
:
3777 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3779 if (linfo
.li_max_ops_per_insn
== 1)
3781 uladv
*= linfo
.li_min_insn_length
;
3782 state_machine_regs
.address
+= uladv
;
3784 state_machine_regs
.view
= 0;
3785 printf (_(" Advance PC by %s to 0x%s%s\n"),
3786 dwarf_vmatoa ("u", uladv
),
3787 dwarf_vmatoa ("x", state_machine_regs
.address
),
3788 verbose_view
&& uladv
3789 ? _(" (reset view)") : "");
3794 = ((state_machine_regs
.op_index
+ uladv
)
3795 / linfo
.li_max_ops_per_insn
)
3796 * linfo
.li_min_insn_length
;
3797 state_machine_regs
.address
3799 state_machine_regs
.op_index
3800 = (state_machine_regs
.op_index
+ uladv
)
3801 % linfo
.li_max_ops_per_insn
;
3803 state_machine_regs
.view
= 0;
3804 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
3805 dwarf_vmatoa ("u", uladv
),
3806 dwarf_vmatoa ("x", state_machine_regs
.address
),
3807 state_machine_regs
.op_index
,
3808 verbose_view
&& addrdelta
3809 ? _(" (reset view)") : "");
3813 case DW_LNS_advance_line
:
3814 adv
= read_sleb128 (data
, & bytes_read
, end
);
3816 state_machine_regs
.line
+= adv
;
3817 printf (_(" Advance Line by %s to %d\n"),
3818 dwarf_vmatoa ("d", adv
),
3819 state_machine_regs
.line
);
3822 case DW_LNS_set_file
:
3823 adv
= read_uleb128 (data
, & bytes_read
, end
);
3825 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3826 dwarf_vmatoa ("d", adv
));
3827 state_machine_regs
.file
= adv
;
3830 case DW_LNS_set_column
:
3831 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3833 printf (_(" Set column to %s\n"),
3834 dwarf_vmatoa ("u", uladv
));
3835 state_machine_regs
.column
= uladv
;
3838 case DW_LNS_negate_stmt
:
3839 adv
= state_machine_regs
.is_stmt
;
3841 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3842 state_machine_regs
.is_stmt
= adv
;
3845 case DW_LNS_set_basic_block
:
3846 printf (_(" Set basic block\n"));
3847 state_machine_regs
.basic_block
= 1;
3850 case DW_LNS_const_add_pc
:
3851 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3852 if (linfo
.li_max_ops_per_insn
)
3854 uladv
*= linfo
.li_min_insn_length
;
3855 state_machine_regs
.address
+= uladv
;
3857 state_machine_regs
.view
= 0;
3858 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
3859 dwarf_vmatoa ("u", uladv
),
3860 dwarf_vmatoa ("x", state_machine_regs
.address
),
3861 verbose_view
&& uladv
3862 ? _(" (reset view)") : "");
3867 = ((state_machine_regs
.op_index
+ uladv
)
3868 / linfo
.li_max_ops_per_insn
)
3869 * linfo
.li_min_insn_length
;
3870 state_machine_regs
.address
3872 state_machine_regs
.op_index
3873 = (state_machine_regs
.op_index
+ uladv
)
3874 % linfo
.li_max_ops_per_insn
;
3876 state_machine_regs
.view
= 0;
3877 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
3878 dwarf_vmatoa ("u", uladv
),
3879 dwarf_vmatoa ("x", state_machine_regs
.address
),
3880 state_machine_regs
.op_index
,
3881 verbose_view
&& addrdelta
3882 ? _(" (reset view)") : "");
3886 case DW_LNS_fixed_advance_pc
:
3887 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3888 state_machine_regs
.address
+= uladv
;
3889 state_machine_regs
.op_index
= 0;
3890 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3891 dwarf_vmatoa ("u", uladv
),
3892 dwarf_vmatoa ("x", state_machine_regs
.address
));
3893 /* Do NOT reset view. */
3896 case DW_LNS_set_prologue_end
:
3897 printf (_(" Set prologue_end to true\n"));
3900 case DW_LNS_set_epilogue_begin
:
3901 printf (_(" Set epilogue_begin to true\n"));
3904 case DW_LNS_set_isa
:
3905 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3907 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3911 printf (_(" Unknown opcode %d with operands: "), op_code
);
3913 if (standard_opcodes
!= NULL
)
3914 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3916 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3918 i
== 1 ? "" : ", ");
3934 unsigned char *name
;
3935 unsigned int directory_index
;
3936 unsigned int modification_date
;
3937 unsigned int length
;
3940 /* Output a decoded representation of the .debug_line section. */
3943 display_debug_lines_decoded (struct dwarf_section
* section
,
3944 unsigned char * data
,
3945 unsigned char * end
,
3948 static DWARF2_Internal_LineInfo saved_linfo
;
3950 introduce (section
, FALSE
);
3954 /* This loop amounts to one iteration per compilation unit. */
3955 DWARF2_Internal_LineInfo linfo
;
3956 unsigned char *standard_opcodes
;
3957 unsigned char *end_of_sequence
;
3959 File_Entry
*file_table
= NULL
;
3960 unsigned int n_files
= 0;
3961 unsigned char **directory_table
= NULL
;
3962 dwarf_vma n_directories
= 0;
3964 if (const_strneq (section
->name
, ".debug_line.")
3965 /* Note: the following does not apply to .debug_line.dwo sections.
3966 These are full debug_line sections. */
3967 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3969 /* See comment in display_debug_lines_raw(). */
3970 end_of_sequence
= end
;
3971 standard_opcodes
= NULL
;
3972 linfo
= saved_linfo
;
3973 /* PR 17531: file: 0522b371. */
3974 if (linfo
.li_line_range
== 0)
3976 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3979 reset_state_machine (linfo
.li_default_is_stmt
);
3983 unsigned char *hdrptr
;
3985 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3986 & end_of_sequence
)) == NULL
)
3989 /* PR 17531: file: 0522b371. */
3990 if (linfo
.li_line_range
== 0)
3992 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3993 linfo
.li_line_range
= 1;
3995 reset_state_machine (linfo
.li_default_is_stmt
);
3997 /* Save a pointer to the contents of the Opcodes table. */
3998 standard_opcodes
= hdrptr
;
4000 /* Traverse the Directory table just to count entries. */
4001 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4005 warn (_("opcode base of %d extends beyond end of section\n"),
4006 linfo
.li_opcode_base
);
4010 if (linfo
.li_version
>= 5)
4012 unsigned char *format_start
, format_count
, *format
;
4013 dwarf_vma formati
, entryi
;
4014 unsigned int bytes_read
;
4016 load_debug_section_with_follow (line_str
, fileptr
);
4018 /* Skip directories format. */
4019 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4020 format_start
= data
;
4021 for (formati
= 0; formati
< format_count
; formati
++)
4023 read_uleb128 (data
, & bytes_read
, end
);
4025 read_uleb128 (data
, & bytes_read
, end
);
4029 n_directories
= read_uleb128 (data
, & bytes_read
, end
);
4033 warn (_("Corrupt directories list\n"));
4037 directory_table
= (unsigned char **)
4038 xmalloc (n_directories
* sizeof (unsigned char *));
4040 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4042 unsigned char **pathp
= &directory_table
[entryi
];
4044 format
= format_start
;
4045 for (formati
= 0; formati
< format_count
; formati
++)
4047 dwarf_vma content_type
, form
;
4050 content_type
= read_uleb128 (format
, & bytes_read
, end
);
4051 format
+= bytes_read
;
4052 form
= read_uleb128 (format
, & bytes_read
, end
);
4053 format
+= bytes_read
;
4056 warn (_("Corrupt directories list\n"));
4059 switch (content_type
)
4064 case DW_FORM_string
:
4067 case DW_FORM_line_strp
:
4068 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4070 /* Remove const by the cast. */
4071 *pathp
= (unsigned char *)
4072 fetch_indirect_line_string (uvalue
);
4077 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
4079 linfo
.li_offset_size
,
4086 warn (_("Corrupt directories list\n"));
4091 /* Skip files format. */
4092 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4093 format_start
= data
;
4094 for (formati
= 0; formati
< format_count
; formati
++)
4096 read_uleb128 (data
, & bytes_read
, end
);
4098 read_uleb128 (data
, & bytes_read
, end
);
4102 n_files
= read_uleb128 (data
, & bytes_read
, end
);
4106 warn (_("Corrupt file name list\n"));
4110 file_table
= (File_Entry
*) xcalloc (1, n_files
4111 * sizeof (File_Entry
));
4113 for (entryi
= 0; entryi
< n_files
; entryi
++)
4115 File_Entry
*file
= &file_table
[entryi
];
4117 format
= format_start
;
4118 for (formati
= 0; formati
< format_count
; formati
++)
4120 dwarf_vma content_type
, form
;
4123 content_type
= read_uleb128 (format
, & bytes_read
, end
);
4124 format
+= bytes_read
;
4125 form
= read_uleb128 (format
, & bytes_read
, end
);
4126 format
+= bytes_read
;
4129 warn (_("Corrupt file name list\n"));
4132 switch (content_type
)
4137 case DW_FORM_string
:
4140 case DW_FORM_line_strp
:
4141 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4143 /* Remove const by the cast. */
4144 file
->name
= (unsigned char *)
4145 fetch_indirect_line_string (uvalue
);
4149 case DW_LNCT_directory_index
:
4153 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4157 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4161 file
->directory_index
= read_uleb128 (data
, NULL
,
4167 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
4169 linfo
.li_offset_size
,
4176 warn (_("Corrupt file name list\n"));
4185 unsigned char *ptr_directory_table
= data
;
4187 while (data
< end
&& *data
!= 0)
4189 data
+= strnlen ((char *) data
, end
- data
) + 1;
4196 warn (_("directory table ends unexpectedly\n"));
4201 /* Go through the directory table again to save the directories. */
4202 directory_table
= (unsigned char **)
4203 xmalloc (n_directories
* sizeof (unsigned char *));
4206 while (*ptr_directory_table
!= 0)
4208 directory_table
[i
] = ptr_directory_table
;
4209 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
4210 ptr_directory_table
- end
) + 1;
4214 /* Skip the NUL at the end of the table. */
4217 /* Traverse the File Name table just to count the entries. */
4218 if (data
< end
&& *data
!= 0)
4220 unsigned char *ptr_file_name_table
= data
;
4222 while (data
< end
&& *data
!= 0)
4224 unsigned int bytes_read
;
4226 /* Skip Name, directory index, last modification time and length
4228 data
+= strnlen ((char *) data
, end
- data
) + 1;
4229 read_uleb128 (data
, & bytes_read
, end
);
4231 read_uleb128 (data
, & bytes_read
, end
);
4233 read_uleb128 (data
, & bytes_read
, end
);
4241 warn (_("file table ends unexpectedly\n"));
4246 /* Go through the file table again to save the strings. */
4247 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
4250 while (*ptr_file_name_table
!= 0)
4252 unsigned int bytes_read
;
4254 file_table
[i
].name
= ptr_file_name_table
;
4255 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
4256 end
- ptr_file_name_table
) + 1;
4258 /* We are not interested in directory, time or size. */
4259 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
4261 ptr_file_name_table
+= bytes_read
;
4262 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
4264 ptr_file_name_table
+= bytes_read
;
4265 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
4266 ptr_file_name_table
+= bytes_read
;
4272 /* Skip the NUL at the end of the table. */
4276 /* Print the Compilation Unit's name and a header. */
4277 if (file_table
== NULL
)
4279 else if (directory_table
== NULL
)
4280 printf (_("CU: %s:\n"), file_table
[0].name
);
4283 unsigned int ix
= file_table
[0].directory_index
;
4284 const char *directory
;
4289 else if (n_directories
== 0)
4290 directory
= _("<unknown>");
4291 else if (ix
> n_directories
)
4293 warn (_("directory index %u > number of directories %s\n"),
4294 ix
, dwarf_vmatoa ("u", n_directories
));
4295 directory
= _("<corrupt>");
4298 directory
= (char *) directory_table
[ix
- 1];
4300 if (do_wide
|| strlen (directory
) < 76)
4301 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4303 printf ("%s:\n", file_table
[0].name
);
4306 printf (_("File name Line number Starting address View\n"));
4307 saved_linfo
= linfo
;
4310 /* This loop iterates through the Dwarf Line Number Program. */
4311 while (data
< end_of_sequence
)
4313 unsigned char op_code
;
4316 unsigned long int uladv
;
4317 unsigned int bytes_read
;
4318 int is_special_opcode
= 0;
4323 if (op_code
>= linfo
.li_opcode_base
)
4325 op_code
-= linfo
.li_opcode_base
;
4326 uladv
= (op_code
/ linfo
.li_line_range
);
4327 if (linfo
.li_max_ops_per_insn
== 1)
4329 uladv
*= linfo
.li_min_insn_length
;
4330 state_machine_regs
.address
+= uladv
;
4332 state_machine_regs
.view
= 0;
4337 = ((state_machine_regs
.op_index
+ uladv
)
4338 / linfo
.li_max_ops_per_insn
)
4339 * linfo
.li_min_insn_length
;
4340 state_machine_regs
.address
4342 state_machine_regs
.op_index
4343 = (state_machine_regs
.op_index
+ uladv
)
4344 % linfo
.li_max_ops_per_insn
;
4346 state_machine_regs
.view
= 0;
4349 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4350 state_machine_regs
.line
+= adv
;
4351 is_special_opcode
= 1;
4352 /* Increment view after printing this row. */
4354 else switch (op_code
)
4356 case DW_LNS_extended_op
:
4358 unsigned int ext_op_code_len
;
4359 unsigned char ext_op_code
;
4360 unsigned char *op_code_data
= data
;
4362 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
4364 op_code_data
+= bytes_read
;
4366 if (ext_op_code_len
== 0)
4368 warn (_("Badly formed extended line op encountered!\n"));
4371 ext_op_code_len
+= bytes_read
;
4372 ext_op_code
= *op_code_data
++;
4376 switch (ext_op_code
)
4378 case DW_LNE_end_sequence
:
4379 /* Reset stuff after printing this row. */
4381 case DW_LNE_set_address
:
4382 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4384 ext_op_code_len
- bytes_read
- 1,
4386 state_machine_regs
.op_index
= 0;
4387 state_machine_regs
.view
= 0;
4389 case DW_LNE_define_file
:
4391 file_table
= (File_Entry
*) xrealloc
4392 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4394 ++state_machine_regs
.last_file_entry
;
4395 /* Source file name. */
4396 file_table
[n_files
].name
= op_code_data
;
4397 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4398 /* Directory index. */
4399 file_table
[n_files
].directory_index
=
4400 read_uleb128 (op_code_data
, & bytes_read
,
4402 op_code_data
+= bytes_read
;
4403 /* Last modification time. */
4404 file_table
[n_files
].modification_date
=
4405 read_uleb128 (op_code_data
, & bytes_read
,
4407 op_code_data
+= bytes_read
;
4409 file_table
[n_files
].length
=
4410 read_uleb128 (op_code_data
, & bytes_read
,
4416 case DW_LNE_set_discriminator
:
4417 case DW_LNE_HP_set_sequence
:
4418 /* Simply ignored. */
4422 printf (_("UNKNOWN (%u): length %d\n"),
4423 ext_op_code
, ext_op_code_len
- bytes_read
);
4426 data
+= ext_op_code_len
;
4430 /* Increment view after printing this row. */
4433 case DW_LNS_advance_pc
:
4434 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4436 if (linfo
.li_max_ops_per_insn
== 1)
4438 uladv
*= linfo
.li_min_insn_length
;
4439 state_machine_regs
.address
+= uladv
;
4441 state_machine_regs
.view
= 0;
4446 = ((state_machine_regs
.op_index
+ uladv
)
4447 / linfo
.li_max_ops_per_insn
)
4448 * linfo
.li_min_insn_length
;
4449 state_machine_regs
.address
4451 state_machine_regs
.op_index
4452 = (state_machine_regs
.op_index
+ uladv
)
4453 % linfo
.li_max_ops_per_insn
;
4455 state_machine_regs
.view
= 0;
4459 case DW_LNS_advance_line
:
4460 adv
= read_sleb128 (data
, & bytes_read
, end
);
4462 state_machine_regs
.line
+= adv
;
4465 case DW_LNS_set_file
:
4466 adv
= read_uleb128 (data
, & bytes_read
, end
);
4468 state_machine_regs
.file
= adv
;
4471 unsigned file
= state_machine_regs
.file
- 1;
4474 if (file_table
== NULL
|| n_files
== 0)
4475 printf (_("\n [Use file table entry %d]\n"), file
);
4477 else if (file
>= n_files
)
4479 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4480 printf (_("\n <over large file table index %u>"), file
);
4482 else if ((dir
= file_table
[file
].directory_index
) == 0)
4483 /* If directory index is 0, that means current directory. */
4484 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4485 else if (directory_table
== NULL
|| n_directories
== 0)
4486 printf (_("\n [Use file %s in directory table entry %d]\n"),
4487 file_table
[file
].name
, dir
);
4489 else if (dir
> n_directories
)
4491 warn (_("directory index %u > number of directories %s\n"),
4492 dir
, dwarf_vmatoa ("u", n_directories
));
4493 printf (_("\n <over large directory table entry %u>\n"), dir
);
4496 printf ("\n%s/%s:\n",
4497 /* The directory index starts counting at 1. */
4498 directory_table
[dir
- 1], file_table
[file
].name
);
4502 case DW_LNS_set_column
:
4503 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4505 state_machine_regs
.column
= uladv
;
4508 case DW_LNS_negate_stmt
:
4509 adv
= state_machine_regs
.is_stmt
;
4511 state_machine_regs
.is_stmt
= adv
;
4514 case DW_LNS_set_basic_block
:
4515 state_machine_regs
.basic_block
= 1;
4518 case DW_LNS_const_add_pc
:
4519 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4520 if (linfo
.li_max_ops_per_insn
== 1)
4522 uladv
*= linfo
.li_min_insn_length
;
4523 state_machine_regs
.address
+= uladv
;
4525 state_machine_regs
.view
= 0;
4530 = ((state_machine_regs
.op_index
+ uladv
)
4531 / linfo
.li_max_ops_per_insn
)
4532 * linfo
.li_min_insn_length
;
4533 state_machine_regs
.address
4535 state_machine_regs
.op_index
4536 = (state_machine_regs
.op_index
+ uladv
)
4537 % linfo
.li_max_ops_per_insn
;
4539 state_machine_regs
.view
= 0;
4543 case DW_LNS_fixed_advance_pc
:
4544 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4545 state_machine_regs
.address
+= uladv
;
4546 state_machine_regs
.op_index
= 0;
4547 /* Do NOT reset view. */
4550 case DW_LNS_set_prologue_end
:
4553 case DW_LNS_set_epilogue_begin
:
4556 case DW_LNS_set_isa
:
4557 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4559 printf (_(" Set ISA to %lu\n"), uladv
);
4563 printf (_(" Unknown opcode %d with operands: "), op_code
);
4565 if (standard_opcodes
!= NULL
)
4566 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4568 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
4570 i
== 1 ? "" : ", ");
4577 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4578 to the DWARF address/line matrix. */
4579 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4580 || (xop
== DW_LNS_copy
))
4582 const unsigned int MAX_FILENAME_LENGTH
= 35;
4584 char *newFileName
= NULL
;
4585 size_t fileNameLength
;
4589 unsigned indx
= state_machine_regs
.file
- 1;
4591 if (indx
>= n_files
)
4593 warn (_("corrupt file index %u encountered\n"), indx
);
4594 fileName
= _("<corrupt>");
4597 fileName
= (char *) file_table
[indx
].name
;
4600 fileName
= _("<unknown>");
4602 fileNameLength
= strlen (fileName
);
4604 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4606 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4607 /* Truncate file name */
4608 strncpy (newFileName
,
4609 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4610 MAX_FILENAME_LENGTH
+ 1);
4614 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4615 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4618 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4620 if (linfo
.li_max_ops_per_insn
== 1)
4621 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4622 newFileName
, state_machine_regs
.line
,
4623 state_machine_regs
.address
);
4625 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4626 newFileName
, state_machine_regs
.line
,
4627 state_machine_regs
.address
,
4628 state_machine_regs
.op_index
);
4632 if (linfo
.li_max_ops_per_insn
== 1)
4633 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
4634 newFileName
, state_machine_regs
.line
,
4635 state_machine_regs
.address
);
4637 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4638 newFileName
, state_machine_regs
.line
,
4639 state_machine_regs
.address
,
4640 state_machine_regs
.op_index
);
4643 if (state_machine_regs
.view
)
4644 printf (" %6u\n", state_machine_regs
.view
);
4647 state_machine_regs
.view
++;
4649 if (xop
== -DW_LNE_end_sequence
)
4651 reset_state_machine (linfo
.li_default_is_stmt
);
4666 if (directory_table
)
4668 free (directory_table
);
4669 directory_table
= NULL
;
4680 display_debug_lines (struct dwarf_section
*section
, void *file
)
4682 unsigned char *data
= section
->start
;
4683 unsigned char *end
= data
+ section
->size
;
4685 int retValDecoded
= 1;
4687 if (do_debug_lines
== 0)
4688 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
4690 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
4691 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
4693 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
4694 retValDecoded
= display_debug_lines_decoded (section
, data
, end
, file
);
4696 if (!retValRaw
|| !retValDecoded
)
4703 find_debug_info_for_offset (unsigned long offset
)
4707 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4710 for (i
= 0; i
< num_debug_info_entries
; i
++)
4711 if (debug_information
[i
].cu_offset
== offset
)
4712 return debug_information
+ i
;
4718 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
4720 /* See gdb/gdb-index.h. */
4721 static const char * const kinds
[] =
4733 return _ (kinds
[kind
]);
4737 display_debug_pubnames_worker (struct dwarf_section
*section
,
4738 void *file ATTRIBUTE_UNUSED
,
4741 DWARF2_Internal_PubNames names
;
4742 unsigned char *start
= section
->start
;
4743 unsigned char *end
= start
+ section
->size
;
4745 /* It does not matter if this load fails,
4746 we test for that later on. */
4747 load_debug_info (file
);
4749 introduce (section
, FALSE
);
4753 unsigned char *data
;
4754 unsigned long sec_off
;
4755 unsigned int offset_size
, initial_length_size
;
4757 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
4758 if (names
.pn_length
== 0xffffffff)
4760 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
4762 initial_length_size
= 12;
4767 initial_length_size
= 4;
4770 sec_off
= start
- section
->start
;
4771 if (sec_off
+ names
.pn_length
< sec_off
4772 || sec_off
+ names
.pn_length
> section
->size
)
4774 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
4776 sec_off
- initial_length_size
,
4777 dwarf_vmatoa ("x", names
.pn_length
));
4782 start
+= names
.pn_length
;
4784 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
4785 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
4787 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4788 && num_debug_info_entries
> 0
4789 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
4790 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4791 (unsigned long) names
.pn_offset
, section
->name
);
4793 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
4795 printf (_(" Length: %ld\n"),
4796 (long) names
.pn_length
);
4797 printf (_(" Version: %d\n"),
4799 printf (_(" Offset into .debug_info section: 0x%lx\n"),
4800 (unsigned long) names
.pn_offset
);
4801 printf (_(" Size of area in .debug_info section: %ld\n"),
4802 (long) names
.pn_size
);
4804 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
4806 static int warned
= 0;
4810 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
4818 printf (_("\n Offset Kind Name\n"));
4820 printf (_("\n Offset\tName\n"));
4824 bfd_size_type maxprint
;
4827 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
4832 data
+= offset_size
;
4835 maxprint
= (end
- data
) - 1;
4839 unsigned int kind_data
;
4840 gdb_index_symbol_kind kind
;
4841 const char *kind_name
;
4844 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
4847 /* GCC computes the kind as the upper byte in the CU index
4848 word, and then right shifts it by the CU index size.
4849 Left shift KIND to where the gdb-index.h accessor macros
4851 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
4852 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
4853 kind_name
= get_gdb_index_symbol_kind_name (kind
);
4854 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
4855 printf (" %-6lx %s,%-10s %.*s\n",
4856 (unsigned long) offset
, is_static
? _("s") : _("g"),
4857 kind_name
, (int) maxprint
, data
);
4860 printf (" %-6lx\t%.*s\n",
4861 (unsigned long) offset
, (int) maxprint
, data
);
4863 data
+= strnlen ((char *) data
, maxprint
) + 1;
4874 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
4876 return display_debug_pubnames_worker (section
, file
, 0);
4880 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
4882 return display_debug_pubnames_worker (section
, file
, 1);
4886 display_debug_macinfo (struct dwarf_section
*section
,
4887 void *file ATTRIBUTE_UNUSED
)
4889 unsigned char *start
= section
->start
;
4890 unsigned char *end
= start
+ section
->size
;
4891 unsigned char *curr
= start
;
4892 unsigned int bytes_read
;
4893 enum dwarf_macinfo_record_type op
;
4895 introduce (section
, FALSE
);
4899 unsigned int lineno
;
4900 const unsigned char *string
;
4902 op
= (enum dwarf_macinfo_record_type
) *curr
;
4907 case DW_MACINFO_start_file
:
4909 unsigned int filenum
;
4911 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4913 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
4916 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
4921 case DW_MACINFO_end_file
:
4922 printf (_(" DW_MACINFO_end_file\n"));
4925 case DW_MACINFO_define
:
4926 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4929 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4930 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
4934 case DW_MACINFO_undef
:
4935 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4938 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4939 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
4943 case DW_MACINFO_vendor_ext
:
4945 unsigned int constant
;
4947 constant
= read_uleb128 (curr
, & bytes_read
, end
);
4950 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4951 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
4961 /* Given LINE_OFFSET into the .debug_line section, attempt to return
4962 filename and dirname corresponding to file name table entry with index
4963 FILEIDX. Return NULL on failure. */
4965 static unsigned char *
4966 get_line_filename_and_dirname (dwarf_vma line_offset
,
4968 unsigned char **dir_name
)
4970 struct dwarf_section
*section
= &debug_displays
[line
].section
;
4971 unsigned char *hdrptr
, *dirtable
, *file_name
;
4972 unsigned int offset_size
, initial_length_size
;
4973 unsigned int version
, opcode_base
, bytes_read
;
4974 dwarf_vma length
, diridx
;
4975 const unsigned char * end
;
4978 if (section
->start
== NULL
4979 || line_offset
>= section
->size
4983 hdrptr
= section
->start
+ line_offset
;
4984 end
= section
->start
+ section
->size
;
4986 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
4987 if (length
== 0xffffffff)
4989 /* This section is 64-bit DWARF 3. */
4990 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
4992 initial_length_size
= 12;
4997 initial_length_size
= 4;
4999 if (length
+ initial_length_size
< length
5000 || length
+ initial_length_size
> section
->size
)
5003 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5004 if (version
!= 2 && version
!= 3 && version
!= 4)
5006 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5008 hdrptr
++; /* Skip max_ops_per_insn. */
5009 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5011 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5012 if (opcode_base
== 0)
5015 hdrptr
+= opcode_base
- 1;
5020 /* Skip over dirname table. */
5021 while (*hdrptr
!= '\0')
5023 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5027 hdrptr
++; /* Skip the NUL at the end of the table. */
5029 /* Now skip over preceding filename table entries. */
5030 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5032 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5033 read_uleb128 (hdrptr
, &bytes_read
, end
);
5034 hdrptr
+= bytes_read
;
5035 read_uleb128 (hdrptr
, &bytes_read
, end
);
5036 hdrptr
+= bytes_read
;
5037 read_uleb128 (hdrptr
, &bytes_read
, end
);
5038 hdrptr
+= bytes_read
;
5040 if (hdrptr
>= end
|| *hdrptr
== '\0')
5044 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5047 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
5050 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5051 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5052 if (dirtable
>= end
|| *dirtable
== '\0')
5054 *dir_name
= dirtable
;
5059 display_debug_macro (struct dwarf_section
*section
,
5062 unsigned char *start
= section
->start
;
5063 unsigned char *end
= start
+ section
->size
;
5064 unsigned char *curr
= start
;
5065 unsigned char *extended_op_buf
[256];
5066 unsigned int bytes_read
;
5068 load_debug_section_with_follow (str
, file
);
5069 load_debug_section_with_follow (line
, file
);
5071 introduce (section
, FALSE
);
5075 unsigned int lineno
, version
, flags
;
5076 unsigned int offset_size
= 4;
5077 const unsigned char *string
;
5078 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5079 unsigned char **extended_ops
= NULL
;
5081 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5082 if (version
!= 4 && version
!= 5)
5084 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5089 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5092 printf (_(" Offset: 0x%lx\n"),
5093 (unsigned long) sec_offset
);
5094 printf (_(" Version: %d\n"), version
);
5095 printf (_(" Offset size: %d\n"), offset_size
);
5098 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5099 printf (_(" Offset into .debug_line: 0x%lx\n"),
5100 (unsigned long) line_offset
);
5104 unsigned int i
, count
, op
;
5107 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5109 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5110 extended_ops
= extended_op_buf
;
5113 printf (_(" Extension opcode arguments:\n"));
5114 for (i
= 0; i
< count
; i
++)
5116 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5117 extended_ops
[op
] = curr
;
5118 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
5121 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5124 printf (_(" DW_MACRO_%02x arguments: "), op
);
5125 for (n
= 0; n
< nargs
; n
++)
5129 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5130 printf ("%s%s", get_FORM_name (form
),
5131 n
== nargs
- 1 ? "\n" : ", ");
5141 case DW_FORM_block1
:
5142 case DW_FORM_block2
:
5143 case DW_FORM_block4
:
5145 case DW_FORM_string
:
5147 case DW_FORM_sec_offset
:
5150 error (_("Invalid extension opcode form %s\n"),
5151 get_FORM_name (form
));
5167 error (_(".debug_macro section not zero terminated\n"));
5171 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5177 case DW_MACRO_start_file
:
5179 unsigned int filenum
;
5180 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
5182 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5184 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
5187 if ((flags
& 2) == 0)
5188 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
5191 = get_line_filename_and_dirname (line_offset
, filenum
,
5193 if (file_name
== NULL
)
5194 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
5197 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
5199 dir_name
!= NULL
? (const char *) dir_name
: "",
5200 dir_name
!= NULL
? "/" : "", file_name
);
5204 case DW_MACRO_end_file
:
5205 printf (_(" DW_MACRO_end_file\n"));
5208 case DW_MACRO_define
:
5209 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5212 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5213 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5217 case DW_MACRO_undef
:
5218 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5221 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5222 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
5226 case DW_MACRO_define_strp
:
5227 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5229 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5230 string
= fetch_indirect_string (offset
);
5231 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
5235 case DW_MACRO_undef_strp
:
5236 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5238 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5239 string
= fetch_indirect_string (offset
);
5240 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
5244 case DW_MACRO_import
:
5245 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5246 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
5247 (unsigned long) offset
);
5250 case DW_MACRO_define_sup
:
5251 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5253 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5254 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
5255 lineno
, (unsigned long) offset
);
5258 case DW_MACRO_undef_sup
:
5259 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
5261 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5262 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5263 lineno
, (unsigned long) offset
);
5266 case DW_MACRO_import_sup
:
5267 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5268 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5269 (unsigned long) offset
);
5273 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5275 error (_(" Unknown macro opcode %02x seen\n"), op
);
5280 /* Skip over unhandled opcodes. */
5282 unsigned char *desc
= extended_ops
[op
];
5283 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
5287 printf (_(" DW_MACRO_%02x\n"), op
);
5290 printf (_(" DW_MACRO_%02x -"), op
);
5291 for (n
= 0; n
< nargs
; n
++)
5295 /* DW_FORM_implicit_const is not expected here. */
5296 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5298 = read_and_display_attr_value (0, val
, 0,
5299 curr
, end
, 0, 0, offset_size
,
5300 version
, NULL
, 0, NULL
,
5318 display_debug_abbrev (struct dwarf_section
*section
,
5319 void *file ATTRIBUTE_UNUSED
)
5321 abbrev_entry
*entry
;
5322 unsigned char *start
= section
->start
;
5323 unsigned char *end
= start
+ section
->size
;
5325 introduce (section
, FALSE
);
5329 unsigned char *last
;
5334 start
= process_abbrev_section (start
, end
);
5336 if (first_abbrev
== NULL
)
5339 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5341 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5345 printf (" %ld %s [%s]\n",
5347 get_TAG_name (entry
->tag
),
5348 entry
->children
? _("has children") : _("no children"));
5350 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5352 printf (" %-18s %s",
5353 get_AT_name (attr
->attribute
),
5354 get_FORM_name (attr
->form
));
5355 if (attr
->form
== DW_FORM_implicit_const
)
5356 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5368 /* Return true when ADDR is the maximum address, when addresses are
5369 POINTER_SIZE bytes long. */
5372 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5374 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5375 return ((addr
& mask
) == mask
);
5378 /* Display a view pair list starting at *VSTART_PTR and ending at
5379 VLISTEND within SECTION. */
5382 display_view_pair_list (struct dwarf_section
*section
,
5383 unsigned char **vstart_ptr
,
5384 unsigned int debug_info_entry
,
5385 unsigned char *vlistend
)
5387 unsigned char *vstart
= *vstart_ptr
;
5388 unsigned char *section_end
= section
->start
+ section
->size
;
5389 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5391 if (vlistend
< section_end
)
5392 section_end
= vlistend
;
5396 while (vstart
< section_end
)
5398 dwarf_vma off
= vstart
- section
->start
;
5399 dwarf_vma vbegin
, vend
;
5401 unsigned int bytes_read
;
5402 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5403 vstart
+= bytes_read
;
5404 if (vstart
== section_end
)
5406 vstart
-= bytes_read
;
5410 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5411 vstart
+= bytes_read
;
5413 printf (" %8.8lx ", (unsigned long) off
);
5415 print_dwarf_view (vbegin
, pointer_size
, 1);
5416 print_dwarf_view (vend
, pointer_size
, 1);
5417 printf (_("location view pair\n"));
5421 *vstart_ptr
= vstart
;
5424 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5427 display_loc_list (struct dwarf_section
*section
,
5428 unsigned char **start_ptr
,
5429 unsigned int debug_info_entry
,
5431 dwarf_vma base_address
,
5432 unsigned char **vstart_ptr
,
5435 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5436 unsigned char *section_end
= section
->start
+ section
->size
;
5437 unsigned long cu_offset
;
5438 unsigned int pointer_size
;
5439 unsigned int offset_size
;
5444 unsigned short length
;
5445 int need_frame_base
;
5447 if (debug_info_entry
>= num_debug_info_entries
)
5449 warn (_("No debug information available for loc lists of entry: %u\n"),
5454 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5455 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5456 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5457 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5459 if (pointer_size
< 2 || pointer_size
> 8)
5461 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5462 pointer_size
, debug_info_entry
);
5468 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5469 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5471 if (start
+ 2 * pointer_size
> section_end
)
5473 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5474 (unsigned long) offset
);
5478 printf (" %8.8lx ", (unsigned long) off
);
5480 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5481 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5483 if (begin
== 0 && end
== 0)
5485 /* PR 18374: In a object file we can have a location list that
5486 starts with a begin and end of 0 because there are relocations
5487 that need to be applied to the addresses. Actually applying
5488 the relocations now does not help as they will probably resolve
5489 to 0, since the object file has not been fully linked. Real
5490 end of list markers will not have any relocations against them. */
5491 if (! reloc_at (section
, off
)
5492 && ! reloc_at (section
, off
+ pointer_size
))
5494 printf (_("<End of list>\n"));
5499 /* Check base address specifiers. */
5500 if (is_max_address (begin
, pointer_size
)
5501 && !is_max_address (end
, pointer_size
))
5504 print_dwarf_vma (begin
, pointer_size
);
5505 print_dwarf_vma (end
, pointer_size
);
5506 printf (_("(base address)\n"));
5512 unsigned int bytes_read
;
5514 off
= offset
+ (vstart
- *start_ptr
);
5516 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5517 vstart
+= bytes_read
;
5518 print_dwarf_view (vbegin
, pointer_size
, 1);
5520 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5521 vstart
+= bytes_read
;
5522 print_dwarf_view (vend
, pointer_size
, 1);
5524 printf (_("views at %8.8lx for:\n %*s "),
5525 (unsigned long) off
, 8, "");
5528 if (start
+ 2 > section_end
)
5530 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5531 (unsigned long) offset
);
5535 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5537 if (start
+ length
> section_end
)
5539 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5540 (unsigned long) offset
);
5544 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5545 print_dwarf_vma (end
+ base_address
, pointer_size
);
5548 need_frame_base
= decode_location_expression (start
,
5553 cu_offset
, section
);
5556 if (need_frame_base
&& !has_frame_base
)
5557 printf (_(" [without DW_AT_frame_base]"));
5559 if (begin
== end
&& vbegin
== vend
)
5560 fputs (_(" (start == end)"), stdout
);
5561 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5562 fputs (_(" (start > end)"), stdout
);
5570 *vstart_ptr
= vstart
;
5573 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5576 display_loclists_list (struct dwarf_section
*section
,
5577 unsigned char **start_ptr
,
5578 unsigned int debug_info_entry
,
5580 dwarf_vma base_address
,
5581 unsigned char **vstart_ptr
,
5584 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5585 unsigned char *section_end
= section
->start
+ section
->size
;
5586 unsigned long cu_offset
;
5587 unsigned int pointer_size
;
5588 unsigned int offset_size
;
5590 unsigned int bytes_read
;
5592 /* Initialize it due to a false compiler warning. */
5593 dwarf_vma begin
= -1, vbegin
= -1;
5594 dwarf_vma end
= -1, vend
= -1;
5596 int need_frame_base
;
5598 if (debug_info_entry
>= num_debug_info_entries
)
5600 warn (_("No debug information available for "
5601 "loclists lists of entry: %u\n"),
5606 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5607 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5608 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5609 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5611 if (pointer_size
< 2 || pointer_size
> 8)
5613 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5614 pointer_size
, debug_info_entry
);
5620 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5621 enum dwarf_location_list_entry_type llet
;
5623 if (start
+ 1 > section_end
)
5625 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5626 (unsigned long) offset
);
5630 printf (" %8.8lx ", (unsigned long) off
);
5632 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5634 if (vstart
&& llet
== DW_LLE_offset_pair
)
5636 off
= offset
+ (vstart
- *start_ptr
);
5638 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5639 vstart
+= bytes_read
;
5640 print_dwarf_view (vbegin
, pointer_size
, 1);
5642 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5643 vstart
+= bytes_read
;
5644 print_dwarf_view (vend
, pointer_size
, 1);
5646 printf (_("views at %8.8lx for:\n %*s "),
5647 (unsigned long) off
, 8, "");
5652 case DW_LLE_end_of_list
:
5653 printf (_("<End of list>\n"));
5655 case DW_LLE_offset_pair
:
5656 begin
= read_uleb128 (start
, &bytes_read
, section_end
);
5657 start
+= bytes_read
;
5658 end
= read_uleb128 (start
, &bytes_read
, section_end
);
5659 start
+= bytes_read
;
5661 case DW_LLE_base_address
:
5662 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
5664 print_dwarf_vma (base_address
, pointer_size
);
5665 printf (_("(base address)\n"));
5667 #ifdef DW_LLE_view_pair
5668 case DW_LLE_view_pair
:
5670 printf (_("View pair entry in loclist with locviews attribute\n"));
5671 vbegin
= read_uleb128 (start
, &bytes_read
, section_end
);
5672 start
+= bytes_read
;
5673 print_dwarf_view (vbegin
, pointer_size
, 1);
5675 vend
= read_uleb128 (start
, &bytes_read
, section_end
);
5676 start
+= bytes_read
;
5677 print_dwarf_view (vend
, pointer_size
, 1);
5679 printf (_("views for:\n"));
5683 error (_("Invalid location list entry type %d\n"), llet
);
5686 if (llet
== DW_LLE_end_of_list
)
5688 if (llet
!= DW_LLE_offset_pair
)
5691 if (start
+ 2 > section_end
)
5693 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5694 (unsigned long) offset
);
5698 length
= read_uleb128 (start
, &bytes_read
, section_end
);
5699 start
+= bytes_read
;
5701 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5702 print_dwarf_vma (end
+ base_address
, pointer_size
);
5705 need_frame_base
= decode_location_expression (start
,
5710 cu_offset
, section
);
5713 if (need_frame_base
&& !has_frame_base
)
5714 printf (_(" [without DW_AT_frame_base]"));
5716 if (begin
== end
&& vbegin
== vend
)
5717 fputs (_(" (start == end)"), stdout
);
5718 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5719 fputs (_(" (start > end)"), stdout
);
5727 if (vbegin
!= vm1
|| vend
!= vm1
)
5728 printf (_("Trailing view pair not used in a range"));
5731 *vstart_ptr
= vstart
;
5734 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
5735 right-adjusted in a field of length LEN, and followed by a space. */
5738 print_addr_index (unsigned int idx
, unsigned int len
)
5740 static char buf
[15];
5741 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
5742 printf ("%*s ", len
, buf
);
5745 /* Display a location list from a .dwo section. It uses address indexes rather
5746 than embedded addresses. This code closely follows display_loc_list, but the
5747 two are sufficiently different that combining things is very ugly. */
5750 display_loc_list_dwo (struct dwarf_section
*section
,
5751 unsigned char **start_ptr
,
5752 unsigned int debug_info_entry
,
5754 unsigned char **vstart_ptr
,
5757 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5758 unsigned char *section_end
= section
->start
+ section
->size
;
5759 unsigned long cu_offset
;
5760 unsigned int pointer_size
;
5761 unsigned int offset_size
;
5764 unsigned short length
;
5765 int need_frame_base
;
5767 unsigned int bytes_read
;
5769 if (debug_info_entry
>= num_debug_info_entries
)
5771 warn (_("No debug information for loc lists of entry: %u\n"),
5776 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5777 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5778 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5779 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5781 if (pointer_size
< 2 || pointer_size
> 8)
5783 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5784 pointer_size
, debug_info_entry
);
5790 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
5792 if (start
>= section_end
)
5794 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5795 (unsigned long) offset
);
5799 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
5812 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
5814 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5815 vstart
+= bytes_read
;
5816 print_dwarf_view (view
, 8, 1);
5818 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5819 vstart
+= bytes_read
;
5820 print_dwarf_view (view
, 8, 1);
5822 printf (_("views at %8.8lx for:\n %*s "),
5823 (unsigned long) off
, 8, "");
5831 case 0: /* A terminating entry. */
5833 *vstart_ptr
= vstart
;
5834 printf (_("<End of list>\n"));
5836 case 1: /* A base-address entry. */
5837 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5838 start
+= bytes_read
;
5839 print_addr_index (idx
, 8);
5840 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
5841 printf (_("(base address selection entry)\n"));
5843 case 2: /* A start/end entry. */
5844 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5845 start
+= bytes_read
;
5846 print_addr_index (idx
, 8);
5847 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5848 start
+= bytes_read
;
5849 print_addr_index (idx
, 8);
5851 case 3: /* A start/length entry. */
5852 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5853 start
+= bytes_read
;
5854 print_addr_index (idx
, 8);
5855 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5856 printf ("%08x ", idx
);
5858 case 4: /* An offset pair entry. */
5859 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5860 printf ("%08x ", idx
);
5861 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5862 printf ("%08x ", idx
);
5865 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
5867 *vstart_ptr
= vstart
;
5871 if (start
+ 2 > section_end
)
5873 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5874 (unsigned long) offset
);
5878 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5879 if (start
+ length
> section_end
)
5881 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5882 (unsigned long) offset
);
5887 need_frame_base
= decode_location_expression (start
,
5892 cu_offset
, section
);
5895 if (need_frame_base
&& !has_frame_base
)
5896 printf (_(" [without DW_AT_frame_base]"));
5904 *vstart_ptr
= vstart
;
5907 /* Sort array of indexes in ascending order of loc_offsets[idx] and
5910 static dwarf_vma
*loc_offsets
, *loc_views
;
5913 loc_offsets_compar (const void *ap
, const void *bp
)
5915 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
5916 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
5918 int ret
= (a
> b
) - (b
> a
);
5922 a
= loc_views
[*(const unsigned int *) ap
];
5923 b
= loc_views
[*(const unsigned int *) bp
];
5925 ret
= (a
> b
) - (b
> a
);
5931 display_debug_loc (struct dwarf_section
*section
, void *file
)
5933 unsigned char *start
= section
->start
, *vstart
= NULL
;
5934 unsigned long bytes
;
5935 unsigned char *section_begin
= start
;
5936 unsigned int num_loc_list
= 0;
5937 unsigned long last_offset
= 0;
5938 unsigned long last_view
= 0;
5939 unsigned int first
= 0;
5942 int seen_first_offset
= 0;
5943 int locs_sorted
= 1;
5944 unsigned char *next
= start
, *vnext
= vstart
;
5945 unsigned int *array
= NULL
;
5946 const char *suffix
= strrchr (section
->name
, '.');
5948 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
5949 dwarf_vma expected_start
= 0;
5951 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
5954 bytes
= section
->size
;
5958 printf (_("\nThe %s section is empty.\n"), section
->name
);
5964 unsigned char *hdrptr
= section_begin
;
5965 dwarf_vma ll_length
;
5966 unsigned short ll_version
;
5967 unsigned char *end
= section_begin
+ section
->size
;
5968 unsigned char address_size
, segment_selector_size
;
5969 uint32_t offset_entry_count
;
5971 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
5972 if (ll_length
== 0xffffffff)
5973 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
5975 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
5976 if (ll_version
!= 5)
5978 warn (_("The %s section contains corrupt or "
5979 "unsupported version number: %d.\n"),
5980 section
->name
, ll_version
);
5984 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
5986 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
5987 if (segment_selector_size
!= 0)
5989 warn (_("The %s section contains "
5990 "unsupported segment selector size: %d.\n"),
5991 section
->name
, segment_selector_size
);
5995 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
5996 if (offset_entry_count
!= 0)
5998 warn (_("The %s section contains "
5999 "unsupported offset entry count: %d.\n"),
6000 section
->name
, offset_entry_count
);
6004 expected_start
= hdrptr
- section_begin
;
6007 if (load_debug_info (file
) == 0)
6009 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6014 /* Check the order of location list in .debug_info section. If
6015 offsets of location lists are in the ascending order, we can
6016 use `debug_information' directly. */
6017 for (i
= 0; i
< num_debug_info_entries
; i
++)
6021 num
= debug_information
[i
].num_loc_offsets
;
6022 if (num
> num_loc_list
)
6025 /* Check if we can use `debug_information' directly. */
6026 if (locs_sorted
&& num
!= 0)
6028 if (!seen_first_offset
)
6030 /* This is the first location list. */
6031 last_offset
= debug_information
[i
].loc_offsets
[0];
6032 last_view
= debug_information
[i
].loc_views
[0];
6034 seen_first_offset
= 1;
6040 for (; j
< num
; j
++)
6043 debug_information
[i
].loc_offsets
[j
]
6044 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6045 && last_view
> debug_information
[i
].loc_views
[j
]))
6050 last_offset
= debug_information
[i
].loc_offsets
[j
];
6051 last_view
= debug_information
[i
].loc_views
[j
];
6056 if (!seen_first_offset
)
6057 error (_("No location lists in .debug_info section!\n"));
6059 if (debug_information
[first
].num_loc_offsets
> 0
6060 && debug_information
[first
].loc_offsets
[0] != expected_start
6061 && debug_information
[first
].loc_views
[0] != expected_start
)
6062 warn (_("Location lists in %s section start at 0x%s\n"),
6064 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6067 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6069 introduce (section
, FALSE
);
6071 if (reloc_at (section
, 0))
6072 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6074 printf (_(" Offset Begin End Expression\n"));
6076 seen_first_offset
= 0;
6077 for (i
= first
; i
< num_debug_info_entries
; i
++)
6079 dwarf_vma offset
, voffset
;
6080 dwarf_vma base_address
;
6086 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6088 loc_offsets
= debug_information
[i
].loc_offsets
;
6089 loc_views
= debug_information
[i
].loc_views
;
6090 qsort (array
, debug_information
[i
].num_loc_offsets
,
6091 sizeof (*array
), loc_offsets_compar
);
6094 int adjacent_view_loclists
= 1;
6095 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6097 j
= locs_sorted
? k
: array
[k
];
6099 && (debug_information
[i
].loc_offsets
[locs_sorted
6100 ? k
- 1 : array
[k
- 1]]
6101 == debug_information
[i
].loc_offsets
[j
])
6102 && (debug_information
[i
].loc_views
[locs_sorted
6103 ? k
- 1 : array
[k
- 1]]
6104 == debug_information
[i
].loc_views
[j
]))
6106 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6107 offset
= debug_information
[i
].loc_offsets
[j
];
6108 next
= section_begin
+ offset
;
6109 voffset
= debug_information
[i
].loc_views
[j
];
6111 vnext
= section_begin
+ voffset
;
6114 base_address
= debug_information
[i
].base_address
;
6116 if (vnext
&& vnext
< next
)
6119 display_view_pair_list (section
, &vstart
, i
, next
);
6124 if (!seen_first_offset
|| !adjacent_view_loclists
)
6125 seen_first_offset
= 1;
6129 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6130 (unsigned long) (start
- section_begin
),
6131 (unsigned long) offset
);
6132 else if (start
> next
)
6133 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6134 (unsigned long) (start
- section_begin
),
6135 (unsigned long) offset
);
6140 if (offset
>= bytes
)
6142 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6143 (unsigned long) offset
);
6147 if (vnext
&& voffset
>= bytes
)
6149 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6150 (unsigned long) voffset
);
6157 display_loc_list_dwo (section
, &start
, i
, offset
,
6158 &vstart
, has_frame_base
);
6160 display_loc_list (section
, &start
, i
, offset
, base_address
,
6161 &vstart
, has_frame_base
);
6166 warn (_("DWO is not yet supported.\n"));
6168 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6169 &vstart
, has_frame_base
);
6172 /* FIXME: this arrangement is quite simplistic. Nothing
6173 requires locview lists to be adjacent to corresponding
6174 loclists, and a single loclist could be augmented by
6175 different locview lists, and vice-versa, unlikely as it
6176 is that it would make sense to do so. Hopefully we'll
6177 have view pair support built into loclists before we ever
6178 need to address all these possibilities. */
6179 if (adjacent_view_loclists
&& vnext
6180 && vnext
!= start
&& vstart
!= next
)
6182 adjacent_view_loclists
= 0;
6183 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
6186 if (vnext
&& vnext
== start
)
6187 display_view_pair_list (section
, &start
, i
, vstart
);
6191 if (start
< section
->start
+ section
->size
)
6192 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
6193 "There are %ld unused bytes at the end of section %s\n",
6194 (long) (section
->start
+ section
->size
- start
)),
6195 (long) (section
->start
+ section
->size
- start
), section
->name
);
6202 display_debug_str (struct dwarf_section
*section
,
6203 void *file ATTRIBUTE_UNUSED
)
6205 unsigned char *start
= section
->start
;
6206 unsigned long bytes
= section
->size
;
6207 dwarf_vma addr
= section
->address
;
6211 printf (_("\nThe %s section is empty.\n"), section
->name
);
6215 introduce (section
, FALSE
);
6223 lbytes
= (bytes
> 16 ? 16 : bytes
);
6225 printf (" 0x%8.8lx ", (unsigned long) addr
);
6227 for (j
= 0; j
< 16; j
++)
6230 printf ("%2.2x", start
[j
]);
6238 for (j
= 0; j
< lbytes
; j
++)
6241 if (k
>= ' ' && k
< 0x80)
6260 display_debug_info (struct dwarf_section
*section
, void *file
)
6262 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
6266 display_debug_types (struct dwarf_section
*section
, void *file
)
6268 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6272 display_trace_info (struct dwarf_section
*section
, void *file
)
6274 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
6278 display_debug_aranges (struct dwarf_section
*section
,
6279 void *file ATTRIBUTE_UNUSED
)
6281 unsigned char *start
= section
->start
;
6282 unsigned char *end
= start
+ section
->size
;
6284 introduce (section
, FALSE
);
6286 /* It does not matter if this load fails,
6287 we test for that later on. */
6288 load_debug_info (file
);
6292 unsigned char *hdrptr
;
6293 DWARF2_Internal_ARange arange
;
6294 unsigned char *addr_ranges
;
6297 unsigned long sec_off
;
6298 unsigned char address_size
;
6300 unsigned int offset_size
;
6301 unsigned int initial_length_size
;
6305 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6306 if (arange
.ar_length
== 0xffffffff)
6308 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6310 initial_length_size
= 12;
6315 initial_length_size
= 4;
6318 sec_off
= hdrptr
- section
->start
;
6319 if (sec_off
+ arange
.ar_length
< sec_off
6320 || sec_off
+ arange
.ar_length
> section
->size
)
6322 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6324 sec_off
- initial_length_size
,
6325 dwarf_vmatoa ("x", arange
.ar_length
));
6329 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6330 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6332 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6333 && num_debug_info_entries
> 0
6334 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6335 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6336 (unsigned long) arange
.ar_info_offset
, section
->name
);
6338 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6339 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6341 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6343 /* PR 19872: A version number of 0 probably means that there is
6344 padding at the end of the .debug_aranges section. Gold puts
6345 it there when performing an incremental link, for example.
6346 So do not generate a warning in this case. */
6347 if (arange
.ar_version
)
6348 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6352 printf (_(" Length: %ld\n"),
6353 (long) arange
.ar_length
);
6354 printf (_(" Version: %d\n"), arange
.ar_version
);
6355 printf (_(" Offset into .debug_info: 0x%lx\n"),
6356 (unsigned long) arange
.ar_info_offset
);
6357 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6358 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6360 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6362 /* PR 17512: file: 001-108546-0.001:0.1. */
6363 if (address_size
== 0 || address_size
> 8)
6365 error (_("Invalid address size in %s section!\n"),
6370 /* The DWARF spec does not require that the address size be a power
6371 of two, but we do. This will have to change if we ever encounter
6372 an uneven architecture. */
6373 if ((address_size
& (address_size
- 1)) != 0)
6375 warn (_("Pointer size + Segment size is not a power of two.\n"));
6379 if (address_size
> 4)
6380 printf (_("\n Address Length\n"));
6382 printf (_("\n Address Length\n"));
6384 addr_ranges
= hdrptr
;
6386 /* Must pad to an alignment boundary that is twice the address size. */
6387 excess
= (hdrptr
- start
) % (2 * address_size
);
6389 addr_ranges
+= (2 * address_size
) - excess
;
6391 start
+= arange
.ar_length
+ initial_length_size
;
6393 while (addr_ranges
+ 2 * address_size
<= start
)
6395 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6396 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6399 print_dwarf_vma (address
, address_size
);
6400 print_dwarf_vma (length
, address_size
);
6410 /* Comparison function for qsort. */
6412 comp_addr_base (const void * v0
, const void * v1
)
6414 debug_info
* info0
= (debug_info
*) v0
;
6415 debug_info
* info1
= (debug_info
*) v1
;
6416 return info0
->addr_base
- info1
->addr_base
;
6419 /* Display the debug_addr section. */
6421 display_debug_addr (struct dwarf_section
*section
,
6424 debug_info
**debug_addr_info
;
6425 unsigned char *entry
;
6430 if (section
->size
== 0)
6432 printf (_("\nThe %s section is empty.\n"), section
->name
);
6436 if (load_debug_info (file
) == 0)
6438 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6443 introduce (section
, FALSE
);
6445 /* PR 17531: file: cf38d01b.
6446 We use xcalloc because a corrupt file may not have initialised all of the
6447 fields in the debug_info structure, which means that the sort below might
6448 try to move uninitialised data. */
6449 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6450 sizeof (debug_info
*));
6453 for (i
= 0; i
< num_debug_info_entries
; i
++)
6454 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6456 /* PR 17531: file: cf38d01b. */
6457 if (debug_information
[i
].addr_base
>= section
->size
)
6458 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6459 (unsigned long) debug_information
[i
].addr_base
, i
);
6461 debug_addr_info
[count
++] = debug_information
+ i
;
6464 /* Add a sentinel to make iteration convenient. */
6465 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6466 debug_addr_info
[count
]->addr_base
= section
->size
;
6467 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6469 for (i
= 0; i
< count
; i
++)
6472 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6474 printf (_(" For compilation unit at offset 0x%s:\n"),
6475 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6477 printf (_("\tIndex\tAddress\n"));
6478 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6479 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6483 dwarf_vma base
= byte_get (entry
, address_size
);
6484 printf (_("\t%d:\t"), idx
);
6485 print_dwarf_vma (base
, address_size
);
6487 entry
+= address_size
;
6493 free (debug_addr_info
);
6497 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6499 display_debug_str_offsets (struct dwarf_section
*section
,
6500 void *file ATTRIBUTE_UNUSED
)
6502 if (section
->size
== 0)
6504 printf (_("\nThe %s section is empty.\n"), section
->name
);
6507 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6508 what the offset size is for this section. */
6512 /* Each debug_information[x].range_lists[y] gets this representation for
6513 sorting purposes. */
6517 /* The debug_information[x].range_lists[y] value. */
6518 dwarf_vma ranges_offset
;
6520 /* Original debug_information to find parameters of the data. */
6521 debug_info
*debug_info_p
;
6524 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6527 range_entry_compar (const void *ap
, const void *bp
)
6529 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6530 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6531 const dwarf_vma a
= a_re
->ranges_offset
;
6532 const dwarf_vma b
= b_re
->ranges_offset
;
6534 return (a
> b
) - (b
> a
);
6538 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6539 unsigned int pointer_size
, unsigned long offset
,
6540 unsigned long base_address
)
6542 while (start
< finish
)
6547 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6548 if (start
>= finish
)
6550 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6553 printf (" %8.8lx ", offset
);
6555 if (begin
== 0 && end
== 0)
6557 printf (_("<End of list>\n"));
6561 /* Check base address specifiers. */
6562 if (is_max_address (begin
, pointer_size
)
6563 && !is_max_address (end
, pointer_size
))
6566 print_dwarf_vma (begin
, pointer_size
);
6567 print_dwarf_vma (end
, pointer_size
);
6568 printf ("(base address)\n");
6572 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6573 print_dwarf_vma (end
+ base_address
, pointer_size
);
6576 fputs (_("(start == end)"), stdout
);
6577 else if (begin
> end
)
6578 fputs (_("(start > end)"), stdout
);
6585 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
6586 unsigned int pointer_size
, unsigned long offset
,
6587 unsigned long base_address
)
6589 unsigned char *next
= start
;
6593 unsigned long off
= offset
+ (start
- next
);
6594 enum dwarf_range_list_entry rlet
;
6595 /* Initialize it due to a false compiler warning. */
6596 dwarf_vma begin
= -1, length
, end
= -1;
6597 unsigned int bytes_read
;
6599 if (start
+ 1 > finish
)
6601 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6606 printf (" %8.8lx ", off
);
6608 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
6612 case DW_RLE_end_of_list
:
6613 printf (_("<End of list>\n"));
6615 case DW_RLE_base_address
:
6616 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
6617 print_dwarf_vma (base_address
, pointer_size
);
6618 printf (_("(base address)\n"));
6620 case DW_RLE_start_length
:
6621 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6622 length
= read_uleb128 (start
, &bytes_read
, finish
);
6623 start
+= bytes_read
;
6624 end
= begin
+ length
;
6626 case DW_RLE_offset_pair
:
6627 begin
= read_uleb128 (start
, &bytes_read
, finish
);
6628 start
+= bytes_read
;
6629 end
= read_uleb128 (start
, &bytes_read
, finish
);
6630 start
+= bytes_read
;
6632 case DW_RLE_start_end
:
6633 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6634 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6637 error (_("Invalid range list entry type %d\n"), rlet
);
6638 rlet
= DW_RLE_end_of_list
;
6641 if (rlet
== DW_RLE_end_of_list
)
6643 if (rlet
== DW_RLE_base_address
)
6646 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6647 print_dwarf_vma (end
+ base_address
, pointer_size
);
6650 fputs (_("(start == end)"), stdout
);
6651 else if (begin
> end
)
6652 fputs (_("(start > end)"), stdout
);
6659 display_debug_ranges (struct dwarf_section
*section
,
6660 void *file ATTRIBUTE_UNUSED
)
6662 unsigned char *start
= section
->start
;
6663 unsigned char *last_start
= start
;
6664 unsigned long bytes
= section
->size
;
6665 unsigned char *section_begin
= start
;
6666 unsigned char *finish
= start
+ bytes
;
6667 unsigned int num_range_list
, i
;
6668 struct range_entry
*range_entries
, *range_entry_fill
;
6669 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
6670 /* Initialize it due to a false compiler warning. */
6671 unsigned char address_size
= 0;
6675 printf (_("\nThe %s section is empty.\n"), section
->name
);
6681 dwarf_vma initial_length
;
6682 unsigned int initial_length_size
;
6683 unsigned char segment_selector_size
;
6684 unsigned int offset_size
, offset_entry_count
;
6685 unsigned short version
;
6687 /* Get and check the length of the block. */
6688 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
6690 if (initial_length
== 0xffffffff)
6692 /* This section is 64-bit DWARF 3. */
6693 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
6695 initial_length_size
= 12;
6700 initial_length_size
= 4;
6703 if (initial_length
+ initial_length_size
> section
->size
)
6705 /* If the length field has a relocation against it, then we should
6706 not complain if it is inaccurate (and probably negative).
6707 It is copied from .debug_line handling code. */
6708 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
6710 initial_length
= (finish
- start
) - initial_length_size
;
6714 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6715 (long) initial_length
);
6720 /* Get and check the version number. */
6721 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
6725 warn (_("Only DWARF version 5 debug_rnglists info "
6726 "is currently supported.\n"));
6730 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
6732 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
6733 if (segment_selector_size
!= 0)
6735 warn (_("The %s section contains "
6736 "unsupported segment selector size: %d.\n"),
6737 section
->name
, segment_selector_size
);
6741 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
6742 if (offset_entry_count
!= 0)
6744 warn (_("The %s section contains "
6745 "unsupported offset entry count: %u.\n"),
6746 section
->name
, offset_entry_count
);
6751 if (load_debug_info (file
) == 0)
6753 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6759 for (i
= 0; i
< num_debug_info_entries
; i
++)
6760 num_range_list
+= debug_information
[i
].num_range_lists
;
6762 if (num_range_list
== 0)
6764 /* This can happen when the file was compiled with -gsplit-debug
6765 which removes references to range lists from the primary .o file. */
6766 printf (_("No range lists in .debug_info section.\n"));
6770 range_entries
= (struct range_entry
*)
6771 xmalloc (sizeof (*range_entries
) * num_range_list
);
6772 range_entry_fill
= range_entries
;
6774 for (i
= 0; i
< num_debug_info_entries
; i
++)
6776 debug_info
*debug_info_p
= &debug_information
[i
];
6779 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
6781 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
6782 range_entry_fill
->debug_info_p
= debug_info_p
;
6787 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
6788 range_entry_compar
);
6790 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
6791 warn (_("Range lists in %s section start at 0x%lx\n"),
6792 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
6794 introduce (section
, FALSE
);
6796 printf (_(" Offset Begin End\n"));
6798 for (i
= 0; i
< num_range_list
; i
++)
6800 struct range_entry
*range_entry
= &range_entries
[i
];
6801 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
6802 unsigned int pointer_size
;
6804 unsigned char *next
;
6805 dwarf_vma base_address
;
6807 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
6808 offset
= range_entry
->ranges_offset
;
6809 next
= section_begin
+ offset
;
6810 base_address
= debug_info_p
->base_address
;
6812 /* PR 17512: file: 001-101485-0.001:0.1. */
6813 if (pointer_size
< 2 || pointer_size
> 8)
6815 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
6816 pointer_size
, (unsigned long) offset
);
6820 if (next
< section_begin
|| next
>= finish
)
6822 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
6823 (unsigned long) offset
, i
);
6827 if (dwarf_check
!= 0 && i
> 0)
6830 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
6831 (unsigned long) (start
- section_begin
),
6832 (unsigned long) (next
- section_begin
), section
->name
);
6833 else if (start
> next
)
6835 if (next
== last_start
)
6837 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
6838 (unsigned long) (start
- section_begin
),
6839 (unsigned long) (next
- section_begin
), section
->name
);
6846 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
6847 (start
, finish
, pointer_size
, offset
, base_address
);
6851 free (range_entries
);
6856 typedef struct Frame_Chunk
6858 struct Frame_Chunk
*next
;
6859 unsigned char *chunk_start
;
6861 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6862 short int *col_type
;
6865 unsigned int code_factor
;
6869 unsigned int cfa_reg
;
6870 dwarf_vma cfa_offset
;
6872 unsigned char fde_encoding
;
6873 unsigned char cfa_exp
;
6874 unsigned char ptr_size
;
6875 unsigned char segment_size
;
6879 static const char *const *dwarf_regnames
;
6880 static unsigned int dwarf_regnames_count
;
6882 /* A marker for a col_type that means this column was never referenced
6883 in the frame info. */
6884 #define DW_CFA_unreferenced (-1)
6886 /* Return 0 if no more space is needed, 1 if more space is needed,
6887 -1 for invalid reg. */
6890 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
6892 unsigned int prev
= fc
->ncols
;
6894 if (reg
< (unsigned int) fc
->ncols
)
6897 if (dwarf_regnames_count
6898 && reg
> dwarf_regnames_count
)
6901 fc
->ncols
= reg
+ 1;
6902 /* PR 17512: file: 10450-2643-0.004.
6903 If reg == -1 then this can happen... */
6907 /* PR 17512: file: 2844a11d. */
6908 if (fc
->ncols
> 1024)
6910 error (_("Unfeasibly large register number: %u\n"), reg
);
6912 /* FIXME: 1024 is an arbitrary limit. Increase it if
6913 we ever encounter a valid binary that exceeds it. */
6917 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
6918 sizeof (short int));
6919 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
6920 /* PR 17512: file:002-10025-0.005. */
6921 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
6923 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
6929 while (prev
< fc
->ncols
)
6931 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
6932 fc
->col_offset
[prev
] = 0;
6938 static const char *const dwarf_regnames_i386
[] =
6940 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6941 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6942 "eip", "eflags", NULL
, /* 8 - 10 */
6943 "st0", "st1", "st2", "st3", /* 11 - 14 */
6944 "st4", "st5", "st6", "st7", /* 15 - 18 */
6945 NULL
, NULL
, /* 19 - 20 */
6946 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
6947 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
6948 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
6949 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
6950 "fcw", "fsw", "mxcsr", /* 37 - 39 */
6951 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
6952 "tr", "ldtr", /* 48 - 49 */
6953 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
6954 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
6955 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
6956 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
6957 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
6958 NULL
, NULL
, NULL
, /* 90 - 92 */
6959 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
6962 static const char *const dwarf_regnames_iamcu
[] =
6964 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6965 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6966 "eip", "eflags", NULL
, /* 8 - 10 */
6967 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
6968 NULL
, NULL
, /* 19 - 20 */
6969 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
6970 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
6971 NULL
, NULL
, NULL
, /* 37 - 39 */
6972 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
6973 "tr", "ldtr", /* 48 - 49 */
6974 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
6975 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
6976 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
6977 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
6978 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
6979 NULL
, NULL
, NULL
, /* 90 - 92 */
6980 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
6984 init_dwarf_regnames_i386 (void)
6986 dwarf_regnames
= dwarf_regnames_i386
;
6987 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
6991 init_dwarf_regnames_iamcu (void)
6993 dwarf_regnames
= dwarf_regnames_iamcu
;
6994 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
6997 static const char *const dwarf_regnames_x86_64
[] =
6999 "rax", "rdx", "rcx", "rbx",
7000 "rsi", "rdi", "rbp", "rsp",
7001 "r8", "r9", "r10", "r11",
7002 "r12", "r13", "r14", "r15",
7004 "xmm0", "xmm1", "xmm2", "xmm3",
7005 "xmm4", "xmm5", "xmm6", "xmm7",
7006 "xmm8", "xmm9", "xmm10", "xmm11",
7007 "xmm12", "xmm13", "xmm14", "xmm15",
7008 "st0", "st1", "st2", "st3",
7009 "st4", "st5", "st6", "st7",
7010 "mm0", "mm1", "mm2", "mm3",
7011 "mm4", "mm5", "mm6", "mm7",
7013 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7014 "fs.base", "gs.base", NULL
, NULL
,
7016 "mxcsr", "fcw", "fsw",
7017 "xmm16", "xmm17", "xmm18", "xmm19",
7018 "xmm20", "xmm21", "xmm22", "xmm23",
7019 "xmm24", "xmm25", "xmm26", "xmm27",
7020 "xmm28", "xmm29", "xmm30", "xmm31",
7021 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7022 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7023 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7024 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7025 NULL
, NULL
, NULL
, /* 115 - 117 */
7026 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7030 init_dwarf_regnames_x86_64 (void)
7032 dwarf_regnames
= dwarf_regnames_x86_64
;
7033 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7036 static const char *const dwarf_regnames_aarch64
[] =
7038 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7039 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7040 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7041 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7042 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7043 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7044 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7045 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7046 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7047 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7048 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7049 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7053 init_dwarf_regnames_aarch64 (void)
7055 dwarf_regnames
= dwarf_regnames_aarch64
;
7056 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7059 static const char *const dwarf_regnames_s390
[] =
7061 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7062 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7063 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7064 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7065 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7066 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7067 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7068 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7069 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7072 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7073 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7077 init_dwarf_regnames_s390 (void)
7079 dwarf_regnames
= dwarf_regnames_s390
;
7080 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7083 static const char *const dwarf_regnames_riscv
[] =
7085 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7086 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7087 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7088 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
7089 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
7090 "fs0", "fs1", /* 40 - 41 */
7091 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
7092 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
7093 "fs10", "fs11", /* 58 - 59 */
7094 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
7098 init_dwarf_regnames_riscv (void)
7100 dwarf_regnames
= dwarf_regnames_riscv
;
7101 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_riscv
);
7105 init_dwarf_regnames (unsigned int e_machine
)
7110 init_dwarf_regnames_i386 ();
7114 init_dwarf_regnames_iamcu ();
7120 init_dwarf_regnames_x86_64 ();
7124 init_dwarf_regnames_aarch64 ();
7128 init_dwarf_regnames_s390 ();
7132 init_dwarf_regnames_riscv ();
7141 regname (unsigned int regno
, int row
)
7143 static char reg
[64];
7146 && regno
< dwarf_regnames_count
7147 && dwarf_regnames
[regno
] != NULL
)
7150 return dwarf_regnames
[regno
];
7151 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
7152 dwarf_regnames
[regno
]);
7155 snprintf (reg
, sizeof (reg
), "r%d", regno
);
7160 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
7165 if (*max_regs
!= fc
->ncols
)
7166 *max_regs
= fc
->ncols
;
7168 if (*need_col_headers
)
7170 static const char *sloc
= " LOC";
7172 *need_col_headers
= 0;
7174 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
7176 for (r
= 0; r
< *max_regs
; r
++)
7177 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7182 printf ("%-5s ", regname (r
, 1));
7188 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
7190 strcpy (tmp
, "exp");
7192 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
7193 printf ("%-8s ", tmp
);
7195 for (r
= 0; r
< fc
->ncols
; r
++)
7197 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7199 switch (fc
->col_type
[r
])
7201 case DW_CFA_undefined
:
7204 case DW_CFA_same_value
:
7208 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7210 case DW_CFA_val_offset
:
7211 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
7213 case DW_CFA_register
:
7214 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
7216 case DW_CFA_expression
:
7217 strcpy (tmp
, "exp");
7219 case DW_CFA_val_expression
:
7220 strcpy (tmp
, "vexp");
7223 strcpy (tmp
, "n/a");
7226 printf ("%-5s ", tmp
);
7232 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
7234 static unsigned char *
7235 read_cie (unsigned char *start
, unsigned char *end
,
7236 Frame_Chunk
**p_cie
, int *p_version
,
7237 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
7241 unsigned int length_return
;
7242 unsigned char *augmentation_data
= NULL
;
7243 bfd_size_type augmentation_data_len
= 0;
7246 /* PR 17512: file: 001-228113-0.004. */
7250 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7251 memset (fc
, 0, sizeof (Frame_Chunk
));
7253 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7254 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7258 fc
->augmentation
= (char *) start
;
7259 /* PR 17512: file: 001-228113-0.004.
7260 Skip past augmentation name, but avoid running off the end of the data. */
7262 if (* start
++ == '\0')
7266 warn (_("No terminator for augmentation name\n"));
7270 if (strcmp (fc
->augmentation
, "eh") == 0)
7271 start
+= eh_addr_size
;
7275 GET (fc
->ptr_size
, 1);
7276 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
7278 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
7282 GET (fc
->segment_size
, 1);
7283 /* PR 17512: file: e99d2804. */
7284 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
7286 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
7290 eh_addr_size
= fc
->ptr_size
;
7294 fc
->ptr_size
= eh_addr_size
;
7295 fc
->segment_size
= 0;
7297 READ_ULEB (fc
->code_factor
);
7298 READ_SLEB (fc
->data_factor
);
7308 if (fc
->augmentation
[0] == 'z')
7310 READ_ULEB (augmentation_data_len
);
7311 augmentation_data
= start
;
7312 /* PR 17512: file: 11042-2589-0.004. */
7313 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
7315 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
7316 dwarf_vmatoa ("x", augmentation_data_len
),
7317 (unsigned long) (end
- start
));
7320 start
+= augmentation_data_len
;
7323 if (augmentation_data_len
)
7327 unsigned char *qend
;
7329 p
= (unsigned char *) fc
->augmentation
+ 1;
7330 q
= augmentation_data
;
7331 qend
= q
+ augmentation_data_len
;
7333 while (p
< end
&& q
< qend
)
7338 q
+= 1 + size_of_encoded_value (*q
);
7340 fc
->fde_encoding
= *q
++;
7347 /* Note - it is OK if this loop terminates with q < qend.
7348 Padding may have been inserted to align the end of the CIE. */
7353 *p_version
= version
;
7356 *p_aug_len
= augmentation_data_len
;
7357 *p_aug
= augmentation_data
;
7362 /* Prints out the contents on the DATA array formatted as unsigned bytes.
7363 If do_wide is not enabled, then formats the output to fit into 80 columns.
7364 PRINTED contains the number of characters already written to the current
7368 display_data (bfd_size_type printed
,
7369 const unsigned char * data
,
7370 const bfd_size_type len
)
7372 if (do_wide
|| len
< ((80 - printed
) / 3))
7373 for (printed
= 0; printed
< len
; ++printed
)
7374 printf (" %02x", data
[printed
]);
7377 for (printed
= 0; printed
< len
; ++printed
)
7379 if (printed
% (80 / 3) == 0)
7381 printf (" %02x", data
[printed
]);
7386 /* Prints out the contents on the augmentation data array.
7387 If do_wide is not enabled, then formats the output to fit into 80 columns. */
7390 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
7394 i
= printf (_(" Augmentation data: "));
7395 display_data (i
, data
, len
);
7399 display_debug_frames (struct dwarf_section
*section
,
7400 void *file ATTRIBUTE_UNUSED
)
7402 unsigned char *start
= section
->start
;
7403 unsigned char *end
= start
+ section
->size
;
7404 unsigned char *section_start
= start
;
7405 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
7406 Frame_Chunk
*remembered_state
= 0;
7408 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7409 unsigned int length_return
;
7410 unsigned int max_regs
= 0;
7411 const char *bad_reg
= _("bad register: ");
7412 unsigned int saved_eh_addr_size
= eh_addr_size
;
7414 introduce (section
, FALSE
);
7418 unsigned char *saved_start
;
7419 unsigned char *block_end
;
7424 int need_col_headers
= 1;
7425 unsigned char *augmentation_data
= NULL
;
7426 bfd_size_type augmentation_data_len
= 0;
7427 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7428 unsigned int offset_size
;
7429 unsigned int initial_length_size
;
7430 bfd_boolean all_nops
;
7432 saved_start
= start
;
7434 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7438 printf ("\n%08lx ZERO terminator\n\n",
7439 (unsigned long)(saved_start
- section_start
));
7440 /* Skip any zero terminators that directly follow.
7441 A corrupt section size could have loaded a whole
7442 slew of zero filled memory bytes. eg
7443 PR 17512: file: 070-19381-0.004. */
7444 while (start
< end
&& * start
== 0)
7449 if (length
== 0xffffffff)
7451 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7453 initial_length_size
= 12;
7458 initial_length_size
= 4;
7461 block_end
= saved_start
+ length
+ initial_length_size
;
7462 if (block_end
> end
|| block_end
< start
)
7464 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7465 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7466 (unsigned long) (saved_start
- section_start
));
7470 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7472 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7473 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7478 start
= read_cie (start
, end
, &cie
, &version
,
7479 &augmentation_data_len
, &augmentation_data
);
7480 /* PR 17512: file: 027-135133-0.005. */
7487 fc
->chunk_start
= saved_start
;
7488 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7491 if (frame_need_space (fc
, mreg
) < 0)
7493 if (fc
->fde_encoding
)
7494 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7496 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7497 print_dwarf_vma (length
, fc
->ptr_size
);
7498 print_dwarf_vma (cie_id
, offset_size
);
7500 if (do_debug_frames_interp
)
7502 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7503 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7508 printf (" Version: %d\n", version
);
7509 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7512 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7513 printf (" Segment Size: %u\n", fc
->segment_size
);
7515 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7516 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7517 printf (" Return address column: %d\n", fc
->ra
);
7519 if (augmentation_data_len
)
7520 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7527 unsigned char *look_for
;
7528 static Frame_Chunk fde_fc
;
7529 unsigned long segment_selector
;
7533 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7534 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7537 look_for
= section_start
+ cie_id
;
7539 if (look_for
<= saved_start
)
7541 for (cie
= chunks
; cie
; cie
= cie
->next
)
7542 if (cie
->chunk_start
== look_for
)
7547 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7548 if (cie
->chunk_start
== look_for
)
7552 unsigned int off_size
;
7553 unsigned char *cie_scan
;
7555 cie_scan
= look_for
;
7557 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7558 if (length
== 0xffffffff)
7560 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7567 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7570 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7571 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7576 read_cie (cie_scan
, end
, &cie
, &version
,
7577 &augmentation_data_len
, &augmentation_data
);
7578 /* PR 17512: file: 3450-2098-0.004. */
7581 warn (_("Failed to read CIE information\n"));
7584 cie
->next
= forward_refs
;
7586 cie
->chunk_start
= look_for
;
7587 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7590 if (frame_need_space (cie
, mreg
) < 0)
7592 warn (_("Invalid max register\n"));
7595 if (cie
->fde_encoding
)
7597 = size_of_encoded_value (cie
->fde_encoding
);
7604 memset (fc
, 0, sizeof (Frame_Chunk
));
7608 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7609 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7610 (unsigned long) (saved_start
- section_start
));
7612 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7613 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7614 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
7616 warn (_("Invalid max register\n"));
7620 fc
->augmentation
= "";
7621 fc
->fde_encoding
= 0;
7622 fc
->ptr_size
= eh_addr_size
;
7623 fc
->segment_size
= 0;
7627 fc
->ncols
= cie
->ncols
;
7628 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
7629 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
7630 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
7631 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
7632 fc
->augmentation
= cie
->augmentation
;
7633 fc
->ptr_size
= cie
->ptr_size
;
7634 eh_addr_size
= cie
->ptr_size
;
7635 fc
->segment_size
= cie
->segment_size
;
7636 fc
->code_factor
= cie
->code_factor
;
7637 fc
->data_factor
= cie
->data_factor
;
7638 fc
->cfa_reg
= cie
->cfa_reg
;
7639 fc
->cfa_offset
= cie
->cfa_offset
;
7641 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
7643 warn (_("Invalid max register\n"));
7646 fc
->fde_encoding
= cie
->fde_encoding
;
7649 if (fc
->fde_encoding
)
7650 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7652 segment_selector
= 0;
7653 if (fc
->segment_size
)
7655 if (fc
->segment_size
> sizeof (segment_selector
))
7657 /* PR 17512: file: 9e196b3e. */
7658 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
7659 fc
->segment_size
= 4;
7661 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
7664 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
7666 /* FIXME: It appears that sometimes the final pc_range value is
7667 encoded in less than encoded_ptr_size bytes. See the x86_64
7668 run of the "objcopy on compressed debug sections" test for an
7670 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
7672 if (cie
->augmentation
[0] == 'z')
7674 READ_ULEB (augmentation_data_len
);
7675 augmentation_data
= start
;
7676 start
+= augmentation_data_len
;
7677 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
7679 || ((bfd_signed_vma
) augmentation_data_len
) < 0
7680 || augmentation_data
> start
)
7682 warn (_("Corrupt augmentation data length: 0x%s\n"),
7683 dwarf_vmatoa ("x", augmentation_data_len
));
7685 augmentation_data
= NULL
;
7686 augmentation_data_len
= 0;
7690 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
7691 (unsigned long)(saved_start
- section_start
),
7692 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
7693 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7694 (unsigned long)(cie
->chunk_start
- section_start
));
7696 if (fc
->segment_size
)
7697 printf ("%04lx:", segment_selector
);
7700 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
7701 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
7703 if (! do_debug_frames_interp
&& augmentation_data_len
)
7705 display_augmentation_data (augmentation_data
, augmentation_data_len
);
7710 /* At this point, fc is the current chunk, cie (if any) is set, and
7711 we're about to interpret instructions for the chunk. */
7712 /* ??? At present we need to do this always, since this sizes the
7713 fc->col_type and fc->col_offset arrays, which we write into always.
7714 We should probably split the interpreted and non-interpreted bits
7715 into two different routines, since there's so much that doesn't
7716 really overlap between them. */
7717 if (1 || do_debug_frames_interp
)
7719 /* Start by making a pass over the chunk, allocating storage
7720 and taking note of what registers are used. */
7721 unsigned char *tmp
= start
;
7723 while (start
< block_end
)
7725 unsigned int reg
, op
, opa
;
7727 unsigned char * new_start
;
7734 /* Warning: if you add any more cases to this switch, be
7735 sure to add them to the corresponding switch below. */
7738 case DW_CFA_advance_loc
:
7742 if (frame_need_space (fc
, opa
) >= 0)
7743 fc
->col_type
[opa
] = DW_CFA_undefined
;
7745 case DW_CFA_restore
:
7746 if (frame_need_space (fc
, opa
) >= 0)
7747 fc
->col_type
[opa
] = DW_CFA_undefined
;
7749 case DW_CFA_set_loc
:
7750 start
+= encoded_ptr_size
;
7752 case DW_CFA_advance_loc1
:
7755 case DW_CFA_advance_loc2
:
7758 case DW_CFA_advance_loc4
:
7761 case DW_CFA_offset_extended
:
7762 case DW_CFA_val_offset
:
7765 if (frame_need_space (fc
, reg
) >= 0)
7766 fc
->col_type
[reg
] = DW_CFA_undefined
;
7768 case DW_CFA_restore_extended
:
7770 if (frame_need_space (fc
, reg
) >= 0)
7771 fc
->col_type
[reg
] = DW_CFA_undefined
;
7773 case DW_CFA_undefined
:
7775 if (frame_need_space (fc
, reg
) >= 0)
7776 fc
->col_type
[reg
] = DW_CFA_undefined
;
7778 case DW_CFA_same_value
:
7780 if (frame_need_space (fc
, reg
) >= 0)
7781 fc
->col_type
[reg
] = DW_CFA_undefined
;
7783 case DW_CFA_register
:
7786 if (frame_need_space (fc
, reg
) >= 0)
7787 fc
->col_type
[reg
] = DW_CFA_undefined
;
7789 case DW_CFA_def_cfa
:
7793 case DW_CFA_def_cfa_register
:
7796 case DW_CFA_def_cfa_offset
:
7799 case DW_CFA_def_cfa_expression
:
7801 new_start
= start
+ temp
;
7802 if (new_start
< start
)
7804 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
7810 case DW_CFA_expression
:
7811 case DW_CFA_val_expression
:
7814 new_start
= start
+ temp
;
7815 if (new_start
< start
)
7817 /* PR 17512: file:306-192417-0.005. */
7818 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
7823 if (frame_need_space (fc
, reg
) >= 0)
7824 fc
->col_type
[reg
] = DW_CFA_undefined
;
7826 case DW_CFA_offset_extended_sf
:
7827 case DW_CFA_val_offset_sf
:
7830 if (frame_need_space (fc
, reg
) >= 0)
7831 fc
->col_type
[reg
] = DW_CFA_undefined
;
7833 case DW_CFA_def_cfa_sf
:
7837 case DW_CFA_def_cfa_offset_sf
:
7840 case DW_CFA_MIPS_advance_loc8
:
7843 case DW_CFA_GNU_args_size
:
7846 case DW_CFA_GNU_negative_offset_extended
:
7849 if (frame_need_space (fc
, reg
) >= 0)
7850 fc
->col_type
[reg
] = DW_CFA_undefined
;
7861 /* Now we know what registers are used, make a second pass over
7862 the chunk, this time actually printing out the info. */
7864 while (start
< block_end
)
7866 unsigned char * tmp
;
7868 unsigned long ul
, roffs
;
7869 /* Note: It is tempting to use an unsigned long for 'reg' but there
7870 are various functions, notably frame_space_needed() that assume that
7871 reg is an unsigned int. */
7876 const char *reg_prefix
= "";
7883 /* Make a note if something other than DW_CFA_nop happens. */
7884 if (op
!= DW_CFA_nop
)
7887 /* Warning: if you add any more cases to this switch, be
7888 sure to add them to the corresponding switch above. */
7891 case DW_CFA_advance_loc
:
7892 if (do_debug_frames_interp
)
7893 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7895 printf (" DW_CFA_advance_loc: %d to %s\n",
7896 opa
* fc
->code_factor
,
7897 dwarf_vmatoa_1 (NULL
,
7898 fc
->pc_begin
+ opa
* fc
->code_factor
,
7900 fc
->pc_begin
+= opa
* fc
->code_factor
;
7905 if (opa
>= (unsigned int) fc
->ncols
)
7906 reg_prefix
= bad_reg
;
7907 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7908 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
7909 reg_prefix
, regname (opa
, 0),
7910 roffs
* fc
->data_factor
);
7911 if (*reg_prefix
== '\0')
7913 fc
->col_type
[opa
] = DW_CFA_offset
;
7914 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
7918 case DW_CFA_restore
:
7919 if (opa
>= (unsigned int) fc
->ncols
)
7920 reg_prefix
= bad_reg
;
7921 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7922 printf (" DW_CFA_restore: %s%s\n",
7923 reg_prefix
, regname (opa
, 0));
7924 if (*reg_prefix
!= '\0')
7927 if (opa
>= (unsigned int) cie
->ncols
7928 || (do_debug_frames_interp
7929 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
7931 fc
->col_type
[opa
] = DW_CFA_undefined
;
7932 fc
->col_offset
[opa
] = 0;
7936 fc
->col_type
[opa
] = cie
->col_type
[opa
];
7937 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
7941 case DW_CFA_set_loc
:
7942 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
7943 if (do_debug_frames_interp
)
7944 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7946 printf (" DW_CFA_set_loc: %s\n",
7947 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
7951 case DW_CFA_advance_loc1
:
7952 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
7953 if (do_debug_frames_interp
)
7954 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7956 printf (" DW_CFA_advance_loc1: %ld to %s\n",
7957 (unsigned long) (ofs
* fc
->code_factor
),
7958 dwarf_vmatoa_1 (NULL
,
7959 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7961 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7964 case DW_CFA_advance_loc2
:
7965 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
7966 if (do_debug_frames_interp
)
7967 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7969 printf (" DW_CFA_advance_loc2: %ld to %s\n",
7970 (unsigned long) (ofs
* fc
->code_factor
),
7971 dwarf_vmatoa_1 (NULL
,
7972 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7974 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7977 case DW_CFA_advance_loc4
:
7978 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
7979 if (do_debug_frames_interp
)
7980 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7982 printf (" DW_CFA_advance_loc4: %ld to %s\n",
7983 (unsigned long) (ofs
* fc
->code_factor
),
7984 dwarf_vmatoa_1 (NULL
,
7985 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7987 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7990 case DW_CFA_offset_extended
:
7993 if (reg
>= (unsigned int) fc
->ncols
)
7994 reg_prefix
= bad_reg
;
7995 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7996 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
7997 reg_prefix
, regname (reg
, 0),
7998 roffs
* fc
->data_factor
);
7999 if (*reg_prefix
== '\0')
8001 fc
->col_type
[reg
] = DW_CFA_offset
;
8002 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8006 case DW_CFA_val_offset
:
8009 if (reg
>= (unsigned int) fc
->ncols
)
8010 reg_prefix
= bad_reg
;
8011 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8012 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
8013 reg_prefix
, regname (reg
, 0),
8014 roffs
* fc
->data_factor
);
8015 if (*reg_prefix
== '\0')
8017 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8018 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8022 case DW_CFA_restore_extended
:
8024 if (reg
>= (unsigned int) fc
->ncols
)
8025 reg_prefix
= bad_reg
;
8026 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8027 printf (" DW_CFA_restore_extended: %s%s\n",
8028 reg_prefix
, regname (reg
, 0));
8029 if (*reg_prefix
!= '\0')
8032 if (reg
>= (unsigned int) cie
->ncols
)
8034 fc
->col_type
[reg
] = DW_CFA_undefined
;
8035 fc
->col_offset
[reg
] = 0;
8039 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8040 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8044 case DW_CFA_undefined
:
8046 if (reg
>= (unsigned int) fc
->ncols
)
8047 reg_prefix
= bad_reg
;
8048 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8049 printf (" DW_CFA_undefined: %s%s\n",
8050 reg_prefix
, regname (reg
, 0));
8051 if (*reg_prefix
== '\0')
8053 fc
->col_type
[reg
] = DW_CFA_undefined
;
8054 fc
->col_offset
[reg
] = 0;
8058 case DW_CFA_same_value
:
8060 if (reg
>= (unsigned int) fc
->ncols
)
8061 reg_prefix
= bad_reg
;
8062 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8063 printf (" DW_CFA_same_value: %s%s\n",
8064 reg_prefix
, regname (reg
, 0));
8065 if (*reg_prefix
== '\0')
8067 fc
->col_type
[reg
] = DW_CFA_same_value
;
8068 fc
->col_offset
[reg
] = 0;
8072 case DW_CFA_register
:
8075 if (reg
>= (unsigned int) fc
->ncols
)
8076 reg_prefix
= bad_reg
;
8077 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8079 printf (" DW_CFA_register: %s%s in ",
8080 reg_prefix
, regname (reg
, 0));
8081 puts (regname (roffs
, 0));
8083 if (*reg_prefix
== '\0')
8085 fc
->col_type
[reg
] = DW_CFA_register
;
8086 fc
->col_offset
[reg
] = roffs
;
8090 case DW_CFA_remember_state
:
8091 if (! do_debug_frames_interp
)
8092 printf (" DW_CFA_remember_state\n");
8093 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8094 rs
->cfa_offset
= fc
->cfa_offset
;
8095 rs
->cfa_reg
= fc
->cfa_reg
;
8097 rs
->cfa_exp
= fc
->cfa_exp
;
8098 rs
->ncols
= fc
->ncols
;
8099 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
8100 sizeof (* rs
->col_type
));
8101 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
8102 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
8103 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
8104 rs
->next
= remembered_state
;
8105 remembered_state
= rs
;
8108 case DW_CFA_restore_state
:
8109 if (! do_debug_frames_interp
)
8110 printf (" DW_CFA_restore_state\n");
8111 rs
= remembered_state
;
8114 remembered_state
= rs
->next
;
8115 fc
->cfa_offset
= rs
->cfa_offset
;
8116 fc
->cfa_reg
= rs
->cfa_reg
;
8118 fc
->cfa_exp
= rs
->cfa_exp
;
8119 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
8121 warn (_("Invalid column number in saved frame state\n"));
8125 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
8126 memcpy (fc
->col_offset
, rs
->col_offset
,
8127 rs
->ncols
* sizeof (* rs
->col_offset
));
8128 free (rs
->col_type
);
8129 free (rs
->col_offset
);
8132 else if (do_debug_frames_interp
)
8133 printf ("Mismatched DW_CFA_restore_state\n");
8136 case DW_CFA_def_cfa
:
8137 READ_ULEB (fc
->cfa_reg
);
8138 READ_ULEB (fc
->cfa_offset
);
8140 if (! do_debug_frames_interp
)
8141 printf (" DW_CFA_def_cfa: %s ofs %d\n",
8142 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8145 case DW_CFA_def_cfa_register
:
8146 READ_ULEB (fc
->cfa_reg
);
8148 if (! do_debug_frames_interp
)
8149 printf (" DW_CFA_def_cfa_register: %s\n",
8150 regname (fc
->cfa_reg
, 0));
8153 case DW_CFA_def_cfa_offset
:
8154 READ_ULEB (fc
->cfa_offset
);
8155 if (! do_debug_frames_interp
)
8156 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
8160 if (! do_debug_frames_interp
)
8161 printf (" DW_CFA_nop\n");
8164 case DW_CFA_def_cfa_expression
:
8166 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
8168 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
8171 if (! do_debug_frames_interp
)
8173 printf (" DW_CFA_def_cfa_expression (");
8174 decode_location_expression (start
, eh_addr_size
, 0, -1,
8182 case DW_CFA_expression
:
8185 if (reg
>= (unsigned int) fc
->ncols
)
8186 reg_prefix
= bad_reg
;
8187 /* PR 17512: file: 069-133014-0.006. */
8188 /* PR 17512: file: 98c02eb4. */
8190 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8192 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
8195 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8197 printf (" DW_CFA_expression: %s%s (",
8198 reg_prefix
, regname (reg
, 0));
8199 decode_location_expression (start
, eh_addr_size
, 0, -1,
8203 if (*reg_prefix
== '\0')
8204 fc
->col_type
[reg
] = DW_CFA_expression
;
8208 case DW_CFA_val_expression
:
8211 if (reg
>= (unsigned int) fc
->ncols
)
8212 reg_prefix
= bad_reg
;
8214 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
8216 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
8219 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8221 printf (" DW_CFA_val_expression: %s%s (",
8222 reg_prefix
, regname (reg
, 0));
8223 decode_location_expression (start
, eh_addr_size
, 0, -1,
8227 if (*reg_prefix
== '\0')
8228 fc
->col_type
[reg
] = DW_CFA_val_expression
;
8232 case DW_CFA_offset_extended_sf
:
8235 if (frame_need_space (fc
, reg
) < 0)
8236 reg_prefix
= bad_reg
;
8237 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8238 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
8239 reg_prefix
, regname (reg
, 0),
8240 (long)(l
* fc
->data_factor
));
8241 if (*reg_prefix
== '\0')
8243 fc
->col_type
[reg
] = DW_CFA_offset
;
8244 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8248 case DW_CFA_val_offset_sf
:
8251 if (frame_need_space (fc
, reg
) < 0)
8252 reg_prefix
= bad_reg
;
8253 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8254 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
8255 reg_prefix
, regname (reg
, 0),
8256 (long)(l
* fc
->data_factor
));
8257 if (*reg_prefix
== '\0')
8259 fc
->col_type
[reg
] = DW_CFA_val_offset
;
8260 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8264 case DW_CFA_def_cfa_sf
:
8265 READ_ULEB (fc
->cfa_reg
);
8266 READ_ULEB (fc
->cfa_offset
);
8267 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
8269 if (! do_debug_frames_interp
)
8270 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
8271 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
8274 case DW_CFA_def_cfa_offset_sf
:
8275 READ_ULEB (fc
->cfa_offset
);
8276 fc
->cfa_offset
*= fc
->data_factor
;
8277 if (! do_debug_frames_interp
)
8278 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
8281 case DW_CFA_MIPS_advance_loc8
:
8282 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
8283 if (do_debug_frames_interp
)
8284 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8286 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
8287 (unsigned long) (ofs
* fc
->code_factor
),
8288 dwarf_vmatoa_1 (NULL
,
8289 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8291 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8294 case DW_CFA_GNU_window_save
:
8295 if (! do_debug_frames_interp
)
8296 printf (" DW_CFA_GNU_window_save\n");
8299 case DW_CFA_GNU_args_size
:
8301 if (! do_debug_frames_interp
)
8302 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8305 case DW_CFA_GNU_negative_offset_extended
:
8309 if (frame_need_space (fc
, reg
) < 0)
8310 reg_prefix
= bad_reg
;
8311 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8312 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
8313 reg_prefix
, regname (reg
, 0),
8314 (long)(l
* fc
->data_factor
));
8315 if (*reg_prefix
== '\0')
8317 fc
->col_type
[reg
] = DW_CFA_offset
;
8318 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8323 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
8324 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
8326 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8331 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8332 if (do_debug_frames_interp
&& ! all_nops
)
8333 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8336 eh_addr_size
= saved_eh_addr_size
;
8347 display_debug_names (struct dwarf_section
*section
, void *file
)
8349 unsigned char *hdrptr
= section
->start
;
8350 dwarf_vma unit_length
;
8351 unsigned char *unit_start
;
8352 const unsigned char *const section_end
= section
->start
+ section
->size
;
8353 unsigned char *unit_end
;
8355 introduce (section
, FALSE
);
8357 load_debug_section_with_follow (str
, file
);
8359 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8361 unsigned int offset_size
;
8362 uint16_t dwarf_version
, padding
;
8363 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8364 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8365 uint32_t augmentation_string_size
;
8367 unsigned long sec_off
;
8369 unit_start
= hdrptr
;
8371 /* Get and check the length of the block. */
8372 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8374 if (unit_length
== 0xffffffff)
8376 /* This section is 64-bit DWARF. */
8377 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8382 unit_end
= hdrptr
+ unit_length
;
8384 sec_off
= hdrptr
- section
->start
;
8385 if (sec_off
+ unit_length
< sec_off
8386 || sec_off
+ unit_length
> section
->size
)
8388 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8390 (unsigned long) (unit_start
- section
->start
),
8391 dwarf_vmatoa ("x", unit_length
));
8395 /* Get and check the version number. */
8396 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8397 printf (_("Version %ld\n"), (long) dwarf_version
);
8399 /* Prior versions did not exist, and future versions may not be
8400 backwards compatible. */
8401 if (dwarf_version
!= 5)
8403 warn (_("Only DWARF version 5 .debug_names "
8404 "is currently supported.\n"));
8408 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8410 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8413 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8414 if (comp_unit_count
== 0)
8415 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8417 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8418 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8419 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8420 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8421 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8423 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8424 if (augmentation_string_size
% 4 != 0)
8426 warn (_("Augmentation string length %u must be rounded up "
8427 "to a multiple of 4 in .debug_names.\n"),
8428 augmentation_string_size
);
8429 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8431 printf (_("Augmentation string:"));
8432 for (i
= 0; i
< augmentation_string_size
; i
++)
8436 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8437 printf (" %02x", uc
);
8442 printf (_("CU table:\n"));
8443 for (i
= 0; i
< comp_unit_count
; i
++)
8447 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8448 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8452 printf (_("TU table:\n"));
8453 for (i
= 0; i
< local_type_unit_count
; i
++)
8457 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8458 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8462 printf (_("Foreign TU table:\n"));
8463 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8467 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8468 printf (_("[%3u] "), i
);
8469 print_dwarf_vma (signature
, 8);
8474 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8475 hdrptr
+= bucket_count
* sizeof (uint32_t);
8476 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8477 hdrptr
+= name_count
* sizeof (uint32_t);
8478 unsigned char *const name_table_string_offsets
= hdrptr
;
8479 hdrptr
+= name_count
* offset_size
;
8480 unsigned char *const name_table_entry_offsets
= hdrptr
;
8481 hdrptr
+= name_count
* offset_size
;
8482 unsigned char *const abbrev_table
= hdrptr
;
8483 hdrptr
+= abbrev_table_size
;
8484 const unsigned char *const abbrev_table_end
= hdrptr
;
8485 unsigned char *const entry_pool
= hdrptr
;
8486 if (hdrptr
> unit_end
)
8488 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8489 "for unit 0x%lx in the debug_names\n"),
8490 (long) (hdrptr
- section
->start
),
8491 (long) (unit_end
- section
->start
),
8492 (long) (unit_start
- section
->start
));
8496 size_t buckets_filled
= 0;
8498 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8500 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8505 printf (ngettext ("Used %zu of %lu bucket.\n",
8506 "Used %zu of %lu buckets.\n",
8508 buckets_filled
, (unsigned long) bucket_count
);
8510 uint32_t hash_prev
= 0;
8511 size_t hash_clash_count
= 0;
8512 size_t longest_clash
= 0;
8513 size_t this_length
= 0;
8515 for (hashi
= 0; hashi
< name_count
; hashi
++)
8517 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8521 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8525 longest_clash
= MAX (longest_clash
, this_length
);
8530 hash_prev
= hash_this
;
8532 printf (_("Out of %lu items there are %zu bucket clashes"
8533 " (longest of %zu entries).\n"),
8534 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
8535 assert (name_count
== buckets_filled
+ hash_clash_count
);
8537 struct abbrev_lookup_entry
8539 dwarf_vma abbrev_tag
;
8540 unsigned char *abbrev_lookup_ptr
;
8542 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
8543 size_t abbrev_lookup_used
= 0;
8544 size_t abbrev_lookup_allocated
= 0;
8546 unsigned char *abbrevptr
= abbrev_table
;
8549 unsigned int bytes_read
;
8550 const dwarf_vma abbrev_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8552 abbrevptr
+= bytes_read
;
8553 if (abbrev_tag
== 0)
8555 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
8557 abbrev_lookup_allocated
= MAX (0x100,
8558 abbrev_lookup_allocated
* 2);
8559 abbrev_lookup
= xrealloc (abbrev_lookup
,
8560 (abbrev_lookup_allocated
8561 * sizeof (*abbrev_lookup
)));
8563 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
8564 struct abbrev_lookup_entry
*entry
;
8565 for (entry
= abbrev_lookup
;
8566 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8568 if (entry
->abbrev_tag
== abbrev_tag
)
8570 warn (_("Duplicate abbreviation tag %lu "
8571 "in unit 0x%lx in the debug_names\n"),
8572 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
8575 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
8576 entry
->abbrev_tag
= abbrev_tag
;
8577 entry
->abbrev_lookup_ptr
= abbrevptr
;
8579 /* Skip DWARF tag. */
8580 read_uleb128 (abbrevptr
, &bytes_read
, abbrev_table_end
);
8581 abbrevptr
+= bytes_read
;
8584 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8587 abbrevptr
+= bytes_read
;
8588 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8590 abbrevptr
+= bytes_read
;
8591 if (xindex
== 0 && form
== 0)
8596 printf (_("\nSymbol table:\n"));
8598 for (namei
= 0; namei
< name_count
; ++namei
)
8600 uint64_t string_offset
, entry_offset
;
8602 SAFE_BYTE_GET (string_offset
,
8603 name_table_string_offsets
+ namei
* offset_size
,
8604 offset_size
, unit_end
);
8605 SAFE_BYTE_GET (entry_offset
,
8606 name_table_entry_offsets
+ namei
* offset_size
,
8607 offset_size
, unit_end
);
8609 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
8610 fetch_indirect_string (string_offset
));
8612 unsigned char *entryptr
= entry_pool
+ entry_offset
;
8614 // We need to scan first whether there is a single or multiple
8615 // entries. TAGNO is -2 for the first entry, it is -1 for the
8616 // initial tag read of the second entry, then it becomes 0 for the
8617 // first entry for real printing etc.
8619 /* Initialize it due to a false compiler warning. */
8620 dwarf_vma second_abbrev_tag
= -1;
8623 unsigned int bytes_read
;
8624 const dwarf_vma abbrev_tag
= read_uleb128 (entryptr
, &bytes_read
,
8626 entryptr
+= bytes_read
;
8629 second_abbrev_tag
= abbrev_tag
;
8631 entryptr
= entry_pool
+ entry_offset
;
8634 if (abbrev_tag
== 0)
8638 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
8639 (unsigned long) abbrev_tag
);
8641 const struct abbrev_lookup_entry
*entry
;
8642 for (entry
= abbrev_lookup
;
8643 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8645 if (entry
->abbrev_tag
== abbrev_tag
)
8647 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
8649 warn (_("Undefined abbreviation tag %lu "
8650 "in unit 0x%lx in the debug_names\n"),
8652 (long) (unit_start
- section
->start
));
8655 abbrevptr
= entry
->abbrev_lookup_ptr
;
8656 const dwarf_vma dwarf_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8658 abbrevptr
+= bytes_read
;
8660 printf (" %s", get_TAG_name (dwarf_tag
));
8663 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8666 abbrevptr
+= bytes_read
;
8667 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8669 abbrevptr
+= bytes_read
;
8670 if (xindex
== 0 && form
== 0)
8674 printf (" %s", get_IDX_name (xindex
));
8675 entryptr
= read_and_display_attr_value (0, form
, 0, entryptr
,
8678 dwarf_version
, NULL
,
8685 printf (_(" <no entries>"));
8689 free (abbrev_lookup
);
8696 display_debug_links (struct dwarf_section
* section
,
8697 void * file ATTRIBUTE_UNUSED
)
8699 const unsigned char * filename
;
8700 unsigned int filelen
;
8702 introduce (section
, FALSE
);
8704 /* The .gnu_debuglink section is formatted as:
8705 (c-string) Filename.
8706 (padding) If needed to reach a 4 byte boundary.
8707 (uint32_t) CRC32 value.
8709 The .gun_debugaltlink section is formatted as:
8710 (c-string) Filename.
8711 (binary) Build-ID. */
8713 filename
= section
->start
;
8714 filelen
= strnlen ((const char *) filename
, section
->size
);
8715 if (filelen
== section
->size
)
8717 warn (_("The debuglink filename is corrupt/missing\n"));
8721 printf (_(" Separate debug info file: %s\n"), filename
);
8723 if (const_strneq (section
->name
, ".gnu_debuglink"))
8726 unsigned int crc_offset
;
8728 crc_offset
= filelen
+ 1;
8729 crc_offset
= (crc_offset
+ 3) & ~3;
8730 if (crc_offset
+ 4 > section
->size
)
8732 warn (_("CRC offset missing/truncated\n"));
8736 crc32
= byte_get (filename
+ crc_offset
, 4);
8738 printf (_(" CRC value: %#x\n"), crc32
);
8740 if (crc_offset
+ 4 < section
->size
)
8742 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
8743 (long)(section
->size
- (crc_offset
+ 4)));
8747 else /* const_strneq (section->name, ".gnu_debugaltlink") */
8749 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
8750 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
8751 bfd_size_type printed
;
8753 /* FIXME: Should we support smaller build-id notes ? */
8754 if (build_id_len
< 0x14)
8756 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
8760 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
8761 display_data (printed
, build_id
, build_id_len
);
8770 display_gdb_index (struct dwarf_section
*section
,
8771 void *file ATTRIBUTE_UNUSED
)
8773 unsigned char *start
= section
->start
;
8775 uint32_t cu_list_offset
, tu_list_offset
;
8776 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
8777 unsigned int cu_list_elements
, tu_list_elements
;
8778 unsigned int address_table_size
, symbol_table_slots
;
8779 unsigned char *cu_list
, *tu_list
;
8780 unsigned char *address_table
, *symbol_table
, *constant_pool
;
8783 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
8785 introduce (section
, FALSE
);
8787 if (section
->size
< 6 * sizeof (uint32_t))
8789 warn (_("Truncated header in the %s section.\n"), section
->name
);
8793 version
= byte_get_little_endian (start
, 4);
8794 printf (_("Version %ld\n"), (long) version
);
8796 /* Prior versions are obsolete, and future versions may not be
8797 backwards compatible. */
8798 if (version
< 3 || version
> 8)
8800 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
8804 warn (_("The address table data in version 3 may be wrong.\n"));
8806 warn (_("Version 4 does not support case insensitive lookups.\n"));
8808 warn (_("Version 5 does not include inlined functions.\n"));
8810 warn (_("Version 6 does not include symbol attributes.\n"));
8811 /* Version 7 indices generated by Gold have bad type unit references,
8812 PR binutils/15021. But we don't know if the index was generated by
8813 Gold or not, so to avoid worrying users with gdb-generated indices
8814 we say nothing for version 7 here. */
8816 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
8817 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
8818 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
8819 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
8820 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
8822 if (cu_list_offset
> section
->size
8823 || tu_list_offset
> section
->size
8824 || address_table_offset
> section
->size
8825 || symbol_table_offset
> section
->size
8826 || constant_pool_offset
> section
->size
)
8828 warn (_("Corrupt header in the %s section.\n"), section
->name
);
8832 /* PR 17531: file: 418d0a8a. */
8833 if (tu_list_offset
< cu_list_offset
)
8835 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
8836 tu_list_offset
, cu_list_offset
);
8840 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
8842 if (address_table_offset
< tu_list_offset
)
8844 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
8845 address_table_offset
, tu_list_offset
);
8849 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
8851 /* PR 17531: file: 18a47d3d. */
8852 if (symbol_table_offset
< address_table_offset
)
8854 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
8855 symbol_table_offset
, address_table_offset
);
8859 address_table_size
= symbol_table_offset
- address_table_offset
;
8861 if (constant_pool_offset
< symbol_table_offset
)
8863 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
8864 constant_pool_offset
, symbol_table_offset
);
8868 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
8870 cu_list
= start
+ cu_list_offset
;
8871 tu_list
= start
+ tu_list_offset
;
8872 address_table
= start
+ address_table_offset
;
8873 symbol_table
= start
+ symbol_table_offset
;
8874 constant_pool
= start
+ constant_pool_offset
;
8876 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
8878 warn (_("Address table extends beyond end of section.\n"));
8882 printf (_("\nCU table:\n"));
8883 for (i
= 0; i
< cu_list_elements
; i
+= 2)
8885 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
8886 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
8888 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
8889 (unsigned long) cu_offset
,
8890 (unsigned long) (cu_offset
+ cu_length
- 1));
8893 printf (_("\nTU table:\n"));
8894 for (i
= 0; i
< tu_list_elements
; i
+= 3)
8896 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
8897 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
8898 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
8900 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
8901 (unsigned long) tu_offset
,
8902 (unsigned long) type_offset
);
8903 print_dwarf_vma (signature
, 8);
8907 printf (_("\nAddress table:\n"));
8908 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
8911 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
8912 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
8913 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
8915 print_dwarf_vma (low
, 8);
8916 print_dwarf_vma (high
, 8);
8917 printf (_("%lu\n"), (unsigned long) cu_index
);
8920 printf (_("\nSymbol table:\n"));
8921 for (i
= 0; i
< symbol_table_slots
; ++i
)
8923 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
8924 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
8925 uint32_t num_cus
, cu
;
8927 if (name_offset
!= 0
8928 || cu_vector_offset
!= 0)
8931 unsigned char * adr
;
8933 adr
= constant_pool
+ name_offset
;
8934 /* PR 17531: file: 5b7b07ad. */
8935 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
8937 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
8938 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
8942 printf ("[%3u] %.*s:", i
,
8943 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
8944 constant_pool
+ name_offset
);
8946 adr
= constant_pool
+ cu_vector_offset
;
8947 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
8949 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
8950 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
8951 cu_vector_offset
, i
);
8955 num_cus
= byte_get_little_endian (adr
, 4);
8957 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
8958 if (num_cus
* 4 < num_cus
8959 || adr
>= section
->start
+ section
->size
8960 || adr
< constant_pool
)
8962 printf ("<invalid number of CUs: %d>\n", num_cus
);
8963 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
8971 for (j
= 0; j
< num_cus
; ++j
)
8974 gdb_index_symbol_kind kind
;
8976 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
8977 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
8978 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
8979 cu
= GDB_INDEX_CU_VALUE (cu
);
8980 /* Convert to TU number if it's for a type unit. */
8981 if (cu
>= cu_list_elements
/ 2)
8982 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
8983 (unsigned long) (cu
- cu_list_elements
/ 2));
8985 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
8987 printf (" [%s, %s]",
8988 is_static
? _("static") : _("global"),
8989 get_gdb_index_symbol_kind_name (kind
));
9001 /* Pre-allocate enough space for the CU/TU sets needed. */
9004 prealloc_cu_tu_list (unsigned int nshndx
)
9006 if (shndx_pool
== NULL
)
9008 shndx_pool_size
= nshndx
;
9009 shndx_pool_used
= 0;
9010 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
9011 sizeof (unsigned int));
9015 shndx_pool_size
= shndx_pool_used
+ nshndx
;
9016 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
9017 sizeof (unsigned int));
9022 add_shndx_to_cu_tu_entry (unsigned int shndx
)
9024 if (shndx_pool_used
>= shndx_pool_size
)
9026 error (_("Internal error: out of space in the shndx pool.\n"));
9029 shndx_pool
[shndx_pool_used
++] = shndx
;
9033 end_cu_tu_entry (void)
9035 if (shndx_pool_used
>= shndx_pool_size
)
9037 error (_("Internal error: out of space in the shndx pool.\n"));
9040 shndx_pool
[shndx_pool_used
++] = 0;
9043 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
9046 get_DW_SECT_short_name (unsigned int dw_sect
)
9048 static char buf
[16];
9056 case DW_SECT_ABBREV
:
9062 case DW_SECT_STR_OFFSETS
:
9064 case DW_SECT_MACINFO
:
9072 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
9076 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
9077 These sections are extensions for Fission.
9078 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
9081 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
9083 unsigned char *phdr
= section
->start
;
9084 unsigned char *limit
= phdr
+ section
->size
;
9085 unsigned char *phash
;
9086 unsigned char *pindex
;
9087 unsigned char *ppool
;
9088 unsigned int version
;
9089 unsigned int ncols
= 0;
9091 unsigned int nslots
;
9094 dwarf_vma signature_high
;
9095 dwarf_vma signature_low
;
9098 /* PR 17512: file: 002-168123-0.004. */
9101 warn (_("Section %s is empty\n"), section
->name
);
9104 /* PR 17512: file: 002-376-0.004. */
9105 if (section
->size
< 24)
9107 warn (_("Section %s is too small to contain a CU/TU header\n"),
9112 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
9114 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
9115 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
9116 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
9119 pindex
= phash
+ nslots
* 8;
9120 ppool
= pindex
+ nslots
* 4;
9122 /* PR 17531: file: 45d69832. */
9123 if (pindex
< phash
|| ppool
< phdr
|| (pindex
== phash
&& nslots
!= 0))
9125 warn (ngettext ("Section %s is too small for %d slot\n",
9126 "Section %s is too small for %d slots\n",
9128 section
->name
, nslots
);
9134 introduce (section
, FALSE
);
9136 printf (_(" Version: %d\n"), version
);
9138 printf (_(" Number of columns: %d\n"), ncols
);
9139 printf (_(" Number of used entries: %d\n"), nused
);
9140 printf (_(" Number of slots: %d\n\n"), nslots
);
9143 if (ppool
> limit
|| ppool
< phdr
)
9145 warn (_("Section %s too small for %d hash table entries\n"),
9146 section
->name
, nslots
);
9153 prealloc_cu_tu_list ((limit
- ppool
) / 4);
9154 for (i
= 0; i
< nslots
; i
++)
9156 unsigned char *shndx_list
;
9159 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
9160 if (signature_high
!= 0 || signature_low
!= 0)
9162 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
9163 shndx_list
= ppool
+ j
* 4;
9164 /* PR 17531: file: 705e010d. */
9165 if (shndx_list
< ppool
)
9167 warn (_("Section index pool located before start of section\n"));
9172 printf (_(" [%3d] Signature: 0x%s Sections: "),
9173 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9174 buf
, sizeof (buf
)));
9177 if (shndx_list
>= limit
)
9179 warn (_("Section %s too small for shndx pool\n"),
9183 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
9187 printf (" %d", shndx
);
9189 add_shndx_to_cu_tu_entry (shndx
);
9201 else if (version
== 2)
9204 unsigned int dw_sect
;
9205 unsigned char *ph
= phash
;
9206 unsigned char *pi
= pindex
;
9207 unsigned char *poffsets
= ppool
+ ncols
* 4;
9208 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
9209 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
9210 bfd_boolean is_tu_index
;
9211 struct cu_tu_set
*this_set
= NULL
;
9213 unsigned char *prow
;
9215 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
9217 /* PR 17531: file: 0dd159bf.
9218 Check for wraparound with an overlarge ncols value. */
9219 if (poffsets
< ppool
|| (unsigned int) ((poffsets
- ppool
) / 4) != ncols
)
9221 warn (_("Overlarge number of columns: %x\n"), ncols
);
9227 warn (_("Section %s too small for offset and size tables\n"),
9234 printf (_(" Offset table\n"));
9235 printf (" slot %-16s ",
9236 is_tu_index
? _("signature") : _("dwo_id"));
9243 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9249 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
9256 for (j
= 0; j
< ncols
; j
++)
9258 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9259 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
9264 for (i
= 0; i
< nslots
; i
++)
9266 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9268 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9271 /* PR 17531: file: a05f6ab3. */
9274 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
9280 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
9282 prow
= poffsets
+ (row
- 1) * ncols
* 4;
9283 /* PR 17531: file: b8ce60a8. */
9284 if (prow
< poffsets
|| prow
> limit
)
9286 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
9292 printf (_(" [%3d] 0x%s"),
9293 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9294 buf
, sizeof (buf
)));
9295 for (j
= 0; j
< ncols
; j
++)
9297 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9299 printf (" %8d", val
);
9302 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9304 /* PR 17531: file: 10796eb3. */
9305 if (dw_sect
>= DW_SECT_MAX
)
9306 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9308 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
9324 printf (_(" Size table\n"));
9325 printf (" slot %-16s ",
9326 is_tu_index
? _("signature") : _("dwo_id"));
9329 for (j
= 0; j
< ncols
; j
++)
9331 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
9333 printf (" %8s", get_DW_SECT_short_name (val
));
9339 for (i
= 0; i
< nslots
; i
++)
9341 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
9343 SAFE_BYTE_GET (row
, pi
, 4, limit
);
9346 prow
= psizes
+ (row
- 1) * ncols
* 4;
9349 printf (_(" [%3d] 0x%s"),
9350 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
9351 buf
, sizeof (buf
)));
9353 for (j
= 0; j
< ncols
; j
++)
9355 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
9357 printf (" %8d", val
);
9360 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
9361 if (dw_sect
>= DW_SECT_MAX
)
9362 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
9364 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
9376 else if (do_display
)
9377 printf (_(" Unsupported version (%d)\n"), version
);
9385 /* Load the CU and TU indexes if present. This will build a list of
9386 section sets that we can use to associate a .debug_info.dwo section
9387 with its associated .debug_abbrev.dwo section in a .dwp file. */
9390 load_cu_tu_indexes (void *file
)
9392 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
9394 /* If we have already loaded (or tried to load) the CU and TU indexes
9395 then do not bother to repeat the task. */
9396 if (cu_tu_indexes_read
== -1)
9398 cu_tu_indexes_read
= TRUE
;
9400 if (load_debug_section_with_follow (dwp_cu_index
, file
))
9401 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
9402 cu_tu_indexes_read
= FALSE
;
9404 if (load_debug_section_with_follow (dwp_tu_index
, file
))
9405 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
9406 cu_tu_indexes_read
= FALSE
;
9409 return (bfd_boolean
) cu_tu_indexes_read
;
9412 /* Find the set of sections that includes section SHNDX. */
9415 find_cu_tu_set (void *file
, unsigned int shndx
)
9419 if (! load_cu_tu_indexes (file
))
9422 /* Find SHNDX in the shndx pool. */
9423 for (i
= 0; i
< shndx_pool_used
; i
++)
9424 if (shndx_pool
[i
] == shndx
)
9427 if (i
>= shndx_pool_used
)
9430 /* Now backup to find the first entry in the set. */
9431 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9434 return shndx_pool
+ i
;
9437 /* Display a .debug_cu_index or .debug_tu_index section. */
9440 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9442 return process_cu_tu_index (section
, 1);
9446 display_debug_not_supported (struct dwarf_section
*section
,
9447 void *file ATTRIBUTE_UNUSED
)
9449 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9455 /* Like malloc, but takes two parameters like calloc.
9456 Verifies that the first parameter is not too large.
9457 Note: does *not* initialise the allocated memory to zero. */
9460 cmalloc (size_t nmemb
, size_t size
)
9462 /* Check for overflow. */
9463 if (nmemb
>= ~(size_t) 0 / size
)
9466 return xmalloc (nmemb
* size
);
9469 /* Like xmalloc, but takes two parameters like calloc.
9470 Verifies that the first parameter is not too large.
9471 Note: does *not* initialise the allocated memory to zero. */
9474 xcmalloc (size_t nmemb
, size_t size
)
9476 /* Check for overflow. */
9477 if (nmemb
>= ~(size_t) 0 / size
)
9480 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9485 return xmalloc (nmemb
* size
);
9488 /* Like xrealloc, but takes three parameters.
9489 Verifies that the second parameter is not too large.
9490 Note: does *not* initialise any new memory to zero. */
9493 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9495 /* Check for overflow. */
9496 if (nmemb
>= ~(size_t) 0 / size
)
9498 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9503 return xrealloc (ptr
, nmemb
* size
);
9506 /* Like xcalloc, but verifies that the first parameter is not too large. */
9509 xcalloc2 (size_t nmemb
, size_t size
)
9511 /* Check for overflow. */
9512 if (nmemb
>= ~(size_t) 0 / size
)
9514 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9519 return xcalloc (nmemb
, size
);
9522 static unsigned long
9523 calc_gnu_debuglink_crc32 (unsigned long crc
,
9524 const unsigned char * buf
,
9527 static const unsigned long crc32_table
[256] =
9529 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
9530 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
9531 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
9532 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
9533 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
9534 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
9535 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
9536 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
9537 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
9538 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
9539 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
9540 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
9541 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
9542 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
9543 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
9544 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
9545 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
9546 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
9547 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
9548 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
9549 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
9550 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
9551 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
9552 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
9553 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
9554 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
9555 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
9556 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
9557 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
9558 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
9559 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
9560 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
9561 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
9562 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
9563 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
9564 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
9565 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
9566 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
9567 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
9568 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
9569 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
9570 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
9571 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
9572 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
9573 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
9574 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
9575 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
9576 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
9577 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
9578 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
9579 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
9582 const unsigned char *end
;
9584 crc
= ~crc
& 0xffffffff;
9585 for (end
= buf
+ len
; buf
< end
; ++ buf
)
9586 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
9587 return ~crc
& 0xffffffff;
9590 typedef bfd_boolean (* check_func_type
) (const char *, void *);
9591 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
9594 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
9596 static unsigned char buffer
[8 * 1024];
9598 bfd_size_type count
;
9599 unsigned long crc
= 0;
9602 sep_data
= open_debug_file (pathname
);
9603 if (sep_data
== NULL
)
9606 /* Yes - we are opening the file twice... */
9607 f
= fopen (pathname
, "rb");
9610 /* Paranoia: This should never happen. */
9611 close_debug_file (sep_data
);
9612 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
9616 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
9617 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
9621 if (crc
!= * (unsigned long *) crc_pointer
)
9623 close_debug_file (sep_data
);
9624 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
9633 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
9636 unsigned int crc_offset
;
9637 unsigned long * crc32
= (unsigned long *) data
;
9639 /* The name is first.
9640 The CRC value is stored after the filename, aligned up to 4 bytes. */
9641 name
= (const char *) section
->start
;
9643 crc_offset
= strnlen (name
, section
->size
) + 1;
9644 crc_offset
= (crc_offset
+ 3) & ~3;
9645 if (crc_offset
+ 4 > section
->size
)
9648 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
9653 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
9655 void * sep_data
= open_debug_file (filename
);
9657 if (sep_data
== NULL
)
9660 /* FIXME: We should now extract the build-id in the separate file
9666 typedef struct build_id_data
9669 const unsigned char * data
;
9673 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
9676 bfd_size_type namelen
;
9677 bfd_size_type id_len
;
9678 Build_id_data
* build_id_data
;
9680 /* The name is first.
9681 The build-id follows immediately, with no padding, up to the section's end. */
9683 name
= (const char *) section
->start
;
9684 namelen
= strnlen (name
, section
->size
) + 1;
9685 if (namelen
>= section
->size
)
9688 id_len
= section
->size
- namelen
;
9692 build_id_data
= calloc (1, sizeof * build_id_data
);
9693 if (build_id_data
== NULL
)
9696 build_id_data
->len
= id_len
;
9697 build_id_data
->data
= section
->start
+ namelen
;
9699 * (Build_id_data
**) data
= build_id_data
;
9705 load_separate_debug_info (const char * main_filename
,
9706 struct dwarf_section
* xlink
,
9707 parse_func_type parse_func
,
9708 check_func_type check_func
,
9711 const char * separate_filename
;
9714 size_t canon_dirlen
;
9717 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
9719 warn (_("Corrupt debuglink section: %s\n"),
9720 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
9724 /* Attempt to locate the separate file.
9725 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
9727 canon_dir
= lrealpath (main_filename
);
9729 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
9730 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
9732 canon_dir
[canon_dirlen
] = '\0';
9735 #define DEBUGDIR "/lib/debug"
9737 #ifndef EXTRA_DEBUG_ROOT1
9738 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
9740 #ifndef EXTRA_DEBUG_ROOT2
9741 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
9744 debugfile
= (char *) malloc (strlen (DEBUGDIR
) + 1
9746 + strlen (".debug/")
9747 #ifdef EXTRA_DEBUG_ROOT1
9748 + strlen (EXTRA_DEBUG_ROOT1
)
9750 #ifdef EXTRA_DEBUG_ROOT2
9751 + strlen (EXTRA_DEBUG_ROOT2
)
9753 + strlen (separate_filename
)
9755 if (debugfile
== NULL
)
9757 warn (_("Out of memory"));
9761 /* First try in the current directory. */
9762 sprintf (debugfile
, "%s", separate_filename
);
9763 if (check_func (debugfile
, func_data
))
9766 /* Then try in a subdirectory called .debug. */
9767 sprintf (debugfile
, ".debug/%s", separate_filename
);
9768 if (check_func (debugfile
, func_data
))
9771 /* Then try in the same directory as the original file. */
9772 sprintf (debugfile
, "%s%s", canon_dir
, separate_filename
);
9773 if (check_func (debugfile
, func_data
))
9776 /* And the .debug subdirectory of that directory. */
9777 sprintf (debugfile
, "%s.debug/%s", canon_dir
, separate_filename
);
9778 if (check_func (debugfile
, func_data
))
9781 #ifdef EXTRA_DEBUG_ROOT1
9782 /* Try the first extra debug file root. */
9783 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
9784 if (check_func (debugfile
, func_data
))
9788 #ifdef EXTRA_DEBUG_ROOT2
9789 /* Try the second extra debug file root. */
9790 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
9791 if (check_func (debugfile
, func_data
))
9795 /* Then try in the global debugfile directory. */
9796 strcpy (debugfile
, DEBUGDIR
);
9797 dirlen
= strlen (DEBUGDIR
) - 1;
9798 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
9799 strcat (debugfile
, "/");
9800 strcat (debugfile
, (const char *) separate_filename
);
9802 if (check_func (debugfile
, func_data
))
9805 /* Failed to find the file. */
9806 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
9807 warn (_("tried: %s\n"), debugfile
);
9809 #ifdef EXTRA_DEBUG_ROOT2
9810 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
9811 warn (_("tried: %s\n"), debugfile
);
9814 #ifdef EXTRA_DEBUG_ROOT1
9815 sprintf (debugfile
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
9816 warn (_("tried: %s\n"), debugfile
);
9819 sprintf (debugfile
, "%s.debug/%s", canon_dir
, separate_filename
);
9820 warn (_("tried: %s\n"), debugfile
);
9822 sprintf (debugfile
, "%s%s", canon_dir
, separate_filename
);
9823 warn (_("tried: %s\n"), debugfile
);
9825 sprintf (debugfile
, ".debug/%s", separate_filename
);
9826 warn (_("tried: %s\n"), debugfile
);
9828 sprintf (debugfile
, "%s", separate_filename
);
9829 warn (_("tried: %s\n"), debugfile
);
9838 /* Now open the file.... */
9839 if ((separate_debug_file
= open_debug_file (debugfile
)) == NULL
)
9841 warn (_("failed to open separate debug file: %s\n"), debugfile
);
9846 /* FIXME: We do not check to see if there are any other separate debug info
9847 files that would also match. */
9849 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debugfile
);
9850 separate_debug_filename
= debugfile
;
9852 /* Do not free debugfile - it might be referenced inside
9853 the structure returned by open_debug_file(). */
9854 return separate_debug_file
;
9857 /* Attempt to load a separate dwarf object file. */
9860 load_dwo_file (const char * main_filename
)
9864 /* FIXME: Skip adding / if dwo_dir ends in /. */
9865 filename
= concat (dwo_dir
, "/", dwo_name
, NULL
);
9866 if (filename
== NULL
)
9868 warn (_("Out of memory allocating dwo filename\n"));
9872 if ((separate_debug_file
= open_debug_file (filename
)) == NULL
)
9874 warn (_("Unable to load dwo file: %s\n"), filename
);
9879 /* FIXME: We should check the dwo_id. */
9881 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, filename
);
9882 separate_debug_filename
= filename
;
9883 return separate_debug_file
;
9886 /* Load a separate debug info file, if it exists.
9887 Returns the data pointer that is the result of calling open_debug_file
9888 on the separate debug info file, or NULL if there were problems or there
9892 load_separate_debug_file (void * file
, const char * filename
)
9894 /* Skip this operation if we are not interested in debug links. */
9895 if (! do_follow_links
&& ! do_debug_links
)
9898 /* See if there is a dwo link. */
9899 if (load_debug_section (str
, file
)
9900 && load_debug_section (abbrev
, file
)
9901 && load_debug_section (info
, file
))
9903 dwo_name
= dwo_dir
= NULL
;
9907 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
9909 if (dwo_name
!= NULL
)
9913 printf (_("The %s section contains a link to a dwo file:\n"),
9914 debug_displays
[info
].section
.uncompressed_name
);
9915 printf (_(" Name: %s\n"), dwo_name
);
9916 printf (_(" Directory: %s\n"), dwo_dir
? dwo_dir
: _("<not-found>"));
9918 display_data (printf (_(" ID: ")), dwo_id
, dwo_id_len
);
9920 printf (_(" ID: <unknown>\n"));
9924 /* FIXME: We do not check to see if there are any more dwo links in the file... */
9925 if (do_follow_links
)
9926 return load_dwo_file (filename
);
9931 if (! do_follow_links
)
9932 /* The other debug links will be displayed by display_debug_links()
9933 so we do not need to do any further processing here. */
9936 /* FIXME: We do not check for the presence of both link sections in the same file. */
9937 /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */
9938 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
9939 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
9941 if (load_debug_section (gnu_debugaltlink
, file
))
9943 Build_id_data
* build_id_data
;
9945 return load_separate_debug_info (filename
,
9946 & debug_displays
[gnu_debugaltlink
].section
,
9947 parse_gnu_debugaltlink
,
9948 check_gnu_debugaltlink
,
9952 if (load_debug_section (gnu_debuglink
, file
))
9954 unsigned long crc32
;
9956 return load_separate_debug_info (filename
,
9957 & debug_displays
[gnu_debuglink
].section
,
9958 parse_gnu_debuglink
,
9959 check_gnu_debuglink
,
9963 do_follow_links
= 0;
9968 free_debug_memory (void)
9974 for (i
= 0; i
< max
; i
++)
9975 free_debug_section ((enum dwarf_section_display_enum
) i
);
9977 if (debug_information
!= NULL
)
9979 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
9981 for (i
= 0; i
< num_debug_info_entries
; i
++)
9983 if (!debug_information
[i
].max_loc_offsets
)
9985 free (debug_information
[i
].loc_offsets
);
9986 free (debug_information
[i
].have_frame_base
);
9988 if (!debug_information
[i
].max_range_lists
)
9989 free (debug_information
[i
].range_lists
);
9992 free (debug_information
);
9993 debug_information
= NULL
;
9994 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
9997 if (separate_debug_file
!= NULL
)
9999 close_debug_file (separate_debug_file
);
10000 separate_debug_file
= NULL
;
10002 free ((void *) separate_debug_filename
);
10003 separate_debug_filename
= NULL
;
10008 dwarf_select_sections_by_names (const char *names
)
10012 const char * option
;
10016 debug_dump_long_opts
;
10018 static const debug_dump_long_opts opts_table
[] =
10020 /* Please keep this table alpha- sorted. */
10021 { "Ranges", & do_debug_ranges
, 1 },
10022 { "abbrev", & do_debug_abbrevs
, 1 },
10023 { "addr", & do_debug_addr
, 1 },
10024 { "aranges", & do_debug_aranges
, 1 },
10025 { "cu_index", & do_debug_cu_index
, 1 },
10026 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
10027 { "follow-links", & do_follow_links
, 1 },
10028 { "frames", & do_debug_frames
, 1 },
10029 { "frames-interp", & do_debug_frames_interp
, 1 },
10030 /* The special .gdb_index section. */
10031 { "gdb_index", & do_gdb_index
, 1 },
10032 { "info", & do_debug_info
, 1 },
10033 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
10034 { "links", & do_debug_links
, 1 },
10035 { "loc", & do_debug_loc
, 1 },
10036 { "macro", & do_debug_macinfo
, 1 },
10037 { "pubnames", & do_debug_pubnames
, 1 },
10038 { "pubtypes", & do_debug_pubtypes
, 1 },
10039 /* This entry is for compatibility
10040 with earlier versions of readelf. */
10041 { "ranges", & do_debug_aranges
, 1 },
10042 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
10043 { "str", & do_debug_str
, 1 },
10044 /* These trace_* sections are used by Itanium VMS. */
10045 { "trace_abbrev", & do_trace_abbrevs
, 1 },
10046 { "trace_aranges", & do_trace_aranges
, 1 },
10047 { "trace_info", & do_trace_info
, 1 },
10056 const debug_dump_long_opts
* entry
;
10058 for (entry
= opts_table
; entry
->option
; entry
++)
10060 size_t len
= strlen (entry
->option
);
10062 if (strncmp (p
, entry
->option
, len
) == 0
10063 && (p
[len
] == ',' || p
[len
] == '\0'))
10065 * entry
->variable
|= entry
->val
;
10067 /* The --debug-dump=frames-interp option also
10068 enables the --debug-dump=frames option. */
10069 if (do_debug_frames_interp
)
10070 do_debug_frames
= 1;
10077 if (entry
->option
== NULL
)
10079 warn (_("Unrecognized debug option '%s'\n"), p
);
10080 p
= strchr (p
, ',');
10091 dwarf_select_sections_by_letters (const char *letters
)
10093 unsigned int lindex
= 0;
10095 while (letters
[lindex
])
10096 switch (letters
[lindex
++])
10098 case 'A': do_debug_addr
= 1; break;
10099 case 'a': do_debug_abbrevs
= 1; break;
10100 case 'c': do_debug_cu_index
= 1; break;
10101 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
10102 case 'f': do_debug_frames
= 1; break;
10103 case 'g': do_gdb_index
= 1; break;
10104 case 'i': do_debug_info
= 1; break;
10105 case 'K': do_follow_links
= 1; break;
10106 case 'k': do_debug_links
= 1; break;
10107 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
10108 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
10109 case 'm': do_debug_macinfo
= 1; break;
10110 case 'o': do_debug_loc
= 1; break;
10111 case 'p': do_debug_pubnames
= 1; break;
10112 case 'R': do_debug_ranges
= 1; break;
10113 case 'r': do_debug_aranges
= 1; break;
10114 case 's': do_debug_str
= 1; break;
10115 case 'T': do_trace_aranges
= 1; break;
10116 case 't': do_debug_pubtypes
= 1; break;
10117 case 'U': do_trace_info
= 1; break;
10118 case 'u': do_trace_abbrevs
= 1; break;
10121 warn (_("Unrecognized debug option '%s'\n"), letters
);
10127 dwarf_select_sections_all (void)
10130 do_debug_abbrevs
= 1;
10131 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
10132 do_debug_pubnames
= 1;
10133 do_debug_pubtypes
= 1;
10134 do_debug_aranges
= 1;
10135 do_debug_ranges
= 1;
10136 do_debug_frames
= 1;
10137 do_debug_macinfo
= 1;
10142 do_trace_abbrevs
= 1;
10143 do_trace_aranges
= 1;
10145 do_debug_cu_index
= 1;
10146 do_follow_links
= 1;
10147 do_debug_links
= 1;
10150 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
10151 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
10153 /* N.B. The order here must match the order in section_display_enum. */
10155 struct dwarf_section_display debug_displays
[] =
10157 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10158 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
10159 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10160 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
10161 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10162 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
10163 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
10164 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
10165 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10166 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10167 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10168 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10169 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10170 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10171 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
10172 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
10173 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10174 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
10175 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10176 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10177 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
10178 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
10179 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
10180 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
10181 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
10182 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
10183 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
10184 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
10185 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
10186 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
10187 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
10188 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
10189 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
10190 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
10191 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
10192 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10193 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, NULL
, FALSE
},
10194 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
10195 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10196 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
10197 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10198 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
10199 /* Separate debug info files can containt their own .debug_str section,
10200 and this might be in *addition* to a .debug_str section already present
10201 in the main file. Hence we need to have two entries for .debug_str. */
10202 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
10205 /* A static assertion. */
10206 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];