1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2017 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"
35 #define MAX(a, b) ((a) > (b) ? (a) : (b))
36 #define MIN(a, b) ((a) < (b) ? (a) : (b))
38 static const char *regname (unsigned int regno
, int row
);
40 static int have_frame_base
;
41 static int need_base_address
;
43 static unsigned int num_debug_info_entries
= 0;
44 static unsigned int alloc_num_debug_info_entries
= 0;
45 static debug_info
*debug_information
= NULL
;
46 /* Special value for num_debug_info_entries to indicate
47 that the .debug_info section could not be loaded/parsed. */
48 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
50 unsigned int eh_addr_size
;
55 int do_debug_pubnames
;
56 int do_debug_pubtypes
;
60 int do_debug_frames_interp
;
69 int do_debug_cu_index
;
72 int dwarf_cutoff_level
= -1;
73 unsigned long dwarf_start_die
;
77 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
78 testing whether e.g. a locview list is present. */
79 static const dwarf_vma vm1
= -1;
81 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
82 sections. For version 1 package files, each set is stored in SHNDX_POOL
83 as a zero-terminated list of section indexes comprising one set of debug
84 sections from a .dwo file. */
86 static unsigned int *shndx_pool
= NULL
;
87 static unsigned int shndx_pool_size
= 0;
88 static unsigned int shndx_pool_used
= 0;
90 /* For version 2 package files, each set contains an array of section offsets
91 and an array of section sizes, giving the offset and size of the
92 contribution from a CU or TU within one of the debug sections.
93 When displaying debug info from a package file, we need to use these
94 tables to locate the corresponding contributions to each section. */
99 dwarf_vma section_offsets
[DW_SECT_MAX
];
100 size_t section_sizes
[DW_SECT_MAX
];
103 static int cu_count
= 0;
104 static int tu_count
= 0;
105 static struct cu_tu_set
*cu_sets
= NULL
;
106 static struct cu_tu_set
*tu_sets
= NULL
;
108 static bfd_boolean
load_cu_tu_indexes (void *);
110 /* Values for do_debug_lines. */
111 #define FLAG_DEBUG_LINES_RAW 1
112 #define FLAG_DEBUG_LINES_DECODED 2
115 size_of_encoded_value (int encoding
)
117 switch (encoding
& 0x7)
120 case 0: return eh_addr_size
;
128 get_encoded_value (unsigned char **pdata
,
130 struct dwarf_section
*section
,
133 unsigned char * data
= * pdata
;
134 unsigned int size
= size_of_encoded_value (encoding
);
137 if (data
+ size
>= end
)
139 warn (_("Encoded value extends past end of section\n"));
144 /* PR 17512: file: 002-829853-0.004. */
147 warn (_("Encoded size of %d is too large to read\n"), size
);
152 /* PR 17512: file: 1085-5603-0.004. */
155 warn (_("Encoded size of 0 is too small to read\n"));
160 if (encoding
& DW_EH_PE_signed
)
161 val
= byte_get_signed (data
, size
);
163 val
= byte_get (data
, size
);
165 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
166 val
+= section
->address
+ (data
- section
->start
);
168 * pdata
= data
+ size
;
172 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
174 # define DWARF_VMA_FMT "ll"
175 # define DWARF_VMA_FMT_LONG "%16.16llx"
177 # define DWARF_VMA_FMT "I64"
178 # define DWARF_VMA_FMT_LONG "%016I64x"
181 # define DWARF_VMA_FMT "l"
182 # define DWARF_VMA_FMT_LONG "%16.16lx"
185 /* Convert a dwarf vma value into a string. Returns a pointer to a static
186 buffer containing the converted VALUE. The value is converted according
187 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
188 it specifies the maximum number of bytes to be displayed in the converted
189 value and FMTCH is ignored - hex is always used. */
192 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
194 /* As dwarf_vmatoa is used more then once in a printf call
195 for output, we are cycling through an fixed array of pointers
196 for return address. */
197 static int buf_pos
= 0;
198 static struct dwarf_vmatoa_buf
204 ret
= buf
[buf_pos
++].place
;
205 buf_pos
%= ARRAY_SIZE (buf
);
209 /* Printf does not have a way of specifying a maximum field width for an
210 integer value, so we print the full value into a buffer and then select
211 the precision we need. */
212 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
215 return ret
+ (16 - 2 * num_bytes
);
222 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
224 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
225 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
230 static inline const char *
231 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
233 return dwarf_vmatoa_1 (fmtch
, value
, 0);
236 /* Print a dwarf_vma value (typically an address, offset or length) in
237 hexadecimal format, followed by a space. The length of the VALUE (and
238 hence the precision displayed) is determined by the NUM_BYTES parameter. */
241 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
243 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
246 /* Print a view number in hexadecimal value, with the same width
247 print_dwarf_vma would have printed it with the same num_bytes.
248 Print blanks for zero view, unless force is nonzero. */
251 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
259 assert (value
== (unsigned long) value
);
261 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
263 printf ("%*s", len
+ 1, "");
266 /* Format a 64-bit value, given as two 32-bit values, in hex.
267 For reentrancy, this uses a buffer provided by the caller. */
270 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
271 unsigned int buf_len
)
276 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
279 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
280 snprintf (buf
+ len
, buf_len
- len
,
281 "%08" DWARF_VMA_FMT
"x", lvalue
);
287 /* Read in a LEB128 encoded value starting at address DATA.
288 If SIGN is true, return a signed LEB128 value.
289 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
290 No bytes will be read at address END or beyond. */
293 read_leb128 (unsigned char *data
,
294 unsigned int *length_return
,
296 const unsigned char * const end
)
298 dwarf_vma result
= 0;
299 unsigned int num_read
= 0;
300 unsigned int shift
= 0;
301 unsigned char byte
= 0;
308 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
311 if ((byte
& 0x80) == 0)
314 /* PR 17512: file: 0ca183b8.
315 FIXME: Should we signal this error somehow ? */
316 if (shift
>= sizeof (result
) * 8)
320 if (length_return
!= NULL
)
321 *length_return
= num_read
;
323 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
324 result
|= -((dwarf_vma
) 1 << shift
);
329 /* Create a signed version to avoid painful typecasts. */
330 static inline dwarf_signed_vma
331 read_sleb128 (unsigned char * data
,
332 unsigned int * length_return
,
333 const unsigned char * const end
)
335 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
338 static inline dwarf_vma
339 read_uleb128 (unsigned char * data
,
340 unsigned int * length_return
,
341 const unsigned char * const end
)
343 return read_leb128 (data
, length_return
, FALSE
, end
);
346 #define SKIP_ULEB() read_uleb128 (start, & length_return, end); start += length_return
347 #define SKIP_SLEB() read_sleb128 (start, & length_return, end); start += length_return
349 #define READ_ULEB(var) \
354 (var) = _val = read_uleb128 (start, &length_return, end); \
356 error (_("Internal error: %s:%d: LEB value (%s) " \
357 "too large for containing variable\n"), \
358 __FILE__, __LINE__, dwarf_vmatoa ("u", _val)); \
359 start += length_return; \
363 #define READ_SLEB(var) \
366 dwarf_signed_vma _val; \
368 (var) = _val = read_sleb128 (start, &length_return, end); \
370 error (_("Internal error: %s:%d: LEB value (%s) " \
371 "too large for containing variable\n"), \
372 __FILE__, __LINE__, dwarf_vmatoa ("d", _val)); \
373 start += length_return; \
377 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
380 unsigned int amount = (AMOUNT); \
381 if (sizeof (VAL) < amount) \
383 error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\
384 amount, (int) sizeof (VAL)); \
385 amount = sizeof (VAL); \
387 if (((PTR) + amount) >= (END)) \
390 amount = (END) - (PTR); \
394 if (amount == 0 || amount > 8) \
397 VAL = byte_get ((PTR), amount); \
401 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
404 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
409 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
412 unsigned int amount = (AMOUNT); \
413 if (((PTR) + amount) >= (END)) \
416 amount = (END) - (PTR); \
421 VAL = byte_get_signed ((PTR), amount); \
427 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
430 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
435 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
438 if (((PTR) + 8) <= (END)) \
440 byte_get_64 ((PTR), (HIGH), (LOW)); \
444 * (LOW) = * (HIGH) = 0; \
449 typedef struct State_Machine_Registers
458 unsigned char op_index
;
459 unsigned char end_sequence
;
460 /* This variable hold the number of the last entry seen
461 in the File Table. */
462 unsigned int last_file_entry
;
465 static SMR state_machine_regs
;
468 reset_state_machine (int is_stmt
)
470 state_machine_regs
.address
= 0;
471 state_machine_regs
.view
= 0;
472 state_machine_regs
.op_index
= 0;
473 state_machine_regs
.file
= 1;
474 state_machine_regs
.line
= 1;
475 state_machine_regs
.column
= 0;
476 state_machine_regs
.is_stmt
= is_stmt
;
477 state_machine_regs
.basic_block
= 0;
478 state_machine_regs
.end_sequence
= 0;
479 state_machine_regs
.last_file_entry
= 0;
482 /* Handled an extend line op.
483 Returns the number of bytes read. */
486 process_extended_line_op (unsigned char * data
,
490 unsigned char op_code
;
491 unsigned int bytes_read
;
494 unsigned char *orig_data
= data
;
497 len
= read_uleb128 (data
, & bytes_read
, end
);
500 if (len
== 0 || data
== end
|| len
> (uintptr_t) (end
- data
))
502 warn (_("Badly formed extended line op encountered!\n"));
509 printf (_(" Extended opcode %d: "), op_code
);
513 case DW_LNE_end_sequence
:
514 printf (_("End of Sequence\n\n"));
515 reset_state_machine (is_stmt
);
518 case DW_LNE_set_address
:
519 /* PR 17512: file: 002-100480-0.004. */
520 if (len
- bytes_read
- 1 > 8)
522 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
523 len
- bytes_read
- 1);
527 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
528 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
529 state_machine_regs
.address
= adr
;
530 state_machine_regs
.view
= 0;
531 state_machine_regs
.op_index
= 0;
534 case DW_LNE_define_file
:
535 printf (_("define new File Table entry\n"));
536 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
537 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
543 l
= strnlen ((char *) data
, end
- data
);
545 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
547 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
549 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
551 printf ("%.*s\n\n", (int) l
, name
);
554 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
555 warn (_("DW_LNE_define_file: Bad opcode length\n"));
558 case DW_LNE_set_discriminator
:
559 printf (_("set Discriminator to %s\n"),
560 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
564 case DW_LNE_HP_negate_is_UV_update
:
565 printf ("DW_LNE_HP_negate_is_UV_update\n");
567 case DW_LNE_HP_push_context
:
568 printf ("DW_LNE_HP_push_context\n");
570 case DW_LNE_HP_pop_context
:
571 printf ("DW_LNE_HP_pop_context\n");
573 case DW_LNE_HP_set_file_line_column
:
574 printf ("DW_LNE_HP_set_file_line_column\n");
576 case DW_LNE_HP_set_routine_name
:
577 printf ("DW_LNE_HP_set_routine_name\n");
579 case DW_LNE_HP_set_sequence
:
580 printf ("DW_LNE_HP_set_sequence\n");
582 case DW_LNE_HP_negate_post_semantics
:
583 printf ("DW_LNE_HP_negate_post_semantics\n");
585 case DW_LNE_HP_negate_function_exit
:
586 printf ("DW_LNE_HP_negate_function_exit\n");
588 case DW_LNE_HP_negate_front_end_logical
:
589 printf ("DW_LNE_HP_negate_front_end_logical\n");
591 case DW_LNE_HP_define_proc
:
592 printf ("DW_LNE_HP_define_proc\n");
594 case DW_LNE_HP_source_file_correlation
:
596 unsigned char *edata
= data
+ len
- bytes_read
- 1;
598 printf ("DW_LNE_HP_source_file_correlation\n");
604 opc
= read_uleb128 (data
, & bytes_read
, edata
);
609 case DW_LNE_HP_SFC_formfeed
:
610 printf (" DW_LNE_HP_SFC_formfeed\n");
612 case DW_LNE_HP_SFC_set_listing_line
:
613 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
615 read_uleb128 (data
, & bytes_read
, edata
)));
618 case DW_LNE_HP_SFC_associate
:
619 printf (" DW_LNE_HP_SFC_associate ");
622 read_uleb128 (data
, & bytes_read
, edata
)));
626 read_uleb128 (data
, & bytes_read
, edata
)));
630 read_uleb128 (data
, & bytes_read
, edata
)));
634 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
644 unsigned int rlen
= len
- bytes_read
- 1;
646 if (op_code
>= DW_LNE_lo_user
647 /* The test against DW_LNW_hi_user is redundant due to
648 the limited range of the unsigned char data type used
650 /*&& op_code <= DW_LNE_hi_user*/)
651 printf (_("user defined: "));
653 printf (_("UNKNOWN: "));
654 printf (_("length %d ["), rlen
);
656 printf (" %02x", *data
++);
665 static const unsigned char *
666 fetch_indirect_string (dwarf_vma offset
)
668 struct dwarf_section
*section
= &debug_displays
[str
].section
;
669 const unsigned char * ret
;
671 if (section
->start
== NULL
)
672 return (const unsigned char *) _("<no .debug_str section>");
674 if (offset
>= section
->size
)
676 warn (_("DW_FORM_strp offset too big: %s\n"),
677 dwarf_vmatoa ("x", offset
));
678 return (const unsigned char *) _("<offset is too big>");
681 ret
= section
->start
+ offset
;
682 /* Unfortunately we cannot rely upon the .debug_str section ending with a
683 NUL byte. Since our caller is expecting to receive a well formed C
684 string we test for the lack of a terminating byte here. */
685 if (strnlen ((const char *) ret
, section
->size
- offset
)
686 == section
->size
- offset
)
687 ret
= (const unsigned char *)
688 _("<no NUL byte at end of .debug_str section>");
693 static const unsigned char *
694 fetch_indirect_line_string (dwarf_vma offset
)
696 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
697 const unsigned char * ret
;
699 if (section
->start
== NULL
)
700 return (const unsigned char *) _("<no .debug_line_str section>");
702 if (offset
>= section
->size
)
704 warn (_("DW_FORM_line_strp offset too big: %s\n"),
705 dwarf_vmatoa ("x", offset
));
706 return (const unsigned char *) _("<offset is too big>");
709 ret
= section
->start
+ offset
;
710 /* Unfortunately we cannot rely upon the .debug_line_str section ending
711 with a NUL byte. Since our caller is expecting to receive a well formed
712 C string we test for the lack of a terminating byte here. */
713 if (strnlen ((const char *) ret
, section
->size
- offset
)
714 == section
->size
- offset
)
715 ret
= (const unsigned char *)
716 _("<no NUL byte at end of .debug_line_str section>");
722 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
723 dwarf_vma offset_size
, int dwo
)
725 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
726 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
727 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
728 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
729 dwarf_vma index_offset
= idx
* offset_size
;
730 dwarf_vma str_offset
;
733 if (index_section
->start
== NULL
)
734 return (dwo
? _("<no .debug_str_offsets.dwo section>")
735 : _("<no .debug_str_offsets section>"));
737 if (this_set
!= NULL
)
738 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
739 if (index_offset
>= index_section
->size
)
741 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
742 dwarf_vmatoa ("x", index_offset
));
743 return _("<index offset is too big>");
746 if (str_section
->start
== NULL
)
747 return (dwo
? _("<no .debug_str.dwo section>")
748 : _("<no .debug_str section>"));
750 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
751 str_offset
-= str_section
->address
;
752 if (str_offset
>= str_section
->size
)
754 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
755 dwarf_vmatoa ("x", str_offset
));
756 return _("<indirect index offset is too big>");
759 ret
= (const char *) str_section
->start
+ str_offset
;
760 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
761 Since our caller is expecting to receive a well formed C string we test
762 for the lack of a terminating byte here. */
763 if (strnlen (ret
, str_section
->size
- str_offset
)
764 == str_section
->size
- str_offset
)
765 ret
= (const char *) _("<no NUL byte at end of section>");
771 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
773 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
775 if (section
->start
== NULL
)
776 return (_("<no .debug_addr section>"));
778 if (offset
+ bytes
> section
->size
)
780 warn (_("Offset into section %s too big: %s\n"),
781 section
->name
, dwarf_vmatoa ("x", offset
));
782 return "<offset too big>";
785 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
789 /* FIXME: There are better and more efficient ways to handle
790 these structures. For now though, I just want something that
791 is simple to implement. */
792 typedef struct abbrev_attr
794 unsigned long attribute
;
796 bfd_signed_vma implicit_const
;
797 struct abbrev_attr
*next
;
801 typedef struct abbrev_entry
806 struct abbrev_attr
*first_attr
;
807 struct abbrev_attr
*last_attr
;
808 struct abbrev_entry
*next
;
812 static abbrev_entry
*first_abbrev
= NULL
;
813 static abbrev_entry
*last_abbrev
= NULL
;
820 for (abbrv
= first_abbrev
; abbrv
;)
822 abbrev_entry
*next_abbrev
= abbrv
->next
;
825 for (attr
= abbrv
->first_attr
; attr
;)
827 abbrev_attr
*next_attr
= attr
->next
;
837 last_abbrev
= first_abbrev
= NULL
;
841 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
845 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
850 entry
->entry
= number
;
852 entry
->children
= children
;
853 entry
->first_attr
= NULL
;
854 entry
->last_attr
= NULL
;
857 if (first_abbrev
== NULL
)
858 first_abbrev
= entry
;
860 last_abbrev
->next
= entry
;
866 add_abbrev_attr (unsigned long attribute
, unsigned long form
,
867 bfd_signed_vma implicit_const
)
871 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
876 attr
->attribute
= attribute
;
878 attr
->implicit_const
= implicit_const
;
881 if (last_abbrev
->first_attr
== NULL
)
882 last_abbrev
->first_attr
= attr
;
884 last_abbrev
->last_attr
->next
= attr
;
886 last_abbrev
->last_attr
= attr
;
889 /* Processes the (partial) contents of a .debug_abbrev section.
890 Returns NULL if the end of the section was encountered.
891 Returns the address after the last byte read if the end of
892 an abbreviation set was found. */
894 static unsigned char *
895 process_abbrev_section (unsigned char *start
, unsigned char *end
)
897 if (first_abbrev
!= NULL
)
902 unsigned int bytes_read
;
905 unsigned long attribute
;
908 entry
= read_uleb128 (start
, & bytes_read
, end
);
911 /* A single zero is supposed to end the section according
912 to the standard. If there's more, then signal that to
919 tag
= read_uleb128 (start
, & bytes_read
, end
);
926 add_abbrev (entry
, tag
, children
);
931 /* Initialize it due to a false compiler warning. */
932 bfd_signed_vma implicit_const
= -1;
934 attribute
= read_uleb128 (start
, & bytes_read
, end
);
939 form
= read_uleb128 (start
, & bytes_read
, end
);
944 if (form
== DW_FORM_implicit_const
)
946 implicit_const
= read_sleb128 (start
, & bytes_read
, end
);
952 add_abbrev_attr (attribute
, form
, implicit_const
);
954 while (attribute
!= 0);
957 /* Report the missing single zero which ends the section. */
958 error (_(".debug_abbrev section not zero terminated\n"));
964 get_TAG_name (unsigned long tag
)
966 const char *name
= get_DW_TAG_name ((unsigned int)tag
);
970 static char buffer
[100];
972 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
980 get_FORM_name (unsigned long form
)
985 return "DW_FORM value: 0";
987 name
= get_DW_FORM_name (form
);
990 static char buffer
[100];
992 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1000 get_IDX_name (unsigned long idx
)
1002 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1006 static char buffer
[100];
1008 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1015 static unsigned char *
1016 display_block (unsigned char *data
,
1018 const unsigned char * const end
, char delimiter
)
1022 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1024 return (unsigned char *) end
;
1026 maxlen
= (dwarf_vma
) (end
- data
);
1027 length
= length
> maxlen
? maxlen
: length
;
1030 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1036 decode_location_expression (unsigned char * data
,
1037 unsigned int pointer_size
,
1038 unsigned int offset_size
,
1041 dwarf_vma cu_offset
,
1042 struct dwarf_section
* section
)
1045 unsigned int bytes_read
;
1047 dwarf_signed_vma svalue
;
1048 unsigned char *end
= data
+ length
;
1049 int need_frame_base
= 0;
1058 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1059 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1062 printf ("DW_OP_deref");
1065 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1066 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1069 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1070 printf ("DW_OP_const1s: %ld", (long) svalue
);
1073 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1074 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1077 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1078 printf ("DW_OP_const2s: %ld", (long) svalue
);
1081 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1082 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1085 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1086 printf ("DW_OP_const4s: %ld", (long) svalue
);
1089 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1090 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1091 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1092 printf ("%lu", (unsigned long) uvalue
);
1095 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1096 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1097 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1098 printf ("%ld", (long) svalue
);
1101 printf ("DW_OP_constu: %s",
1102 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1106 printf ("DW_OP_consts: %s",
1107 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1111 printf ("DW_OP_dup");
1114 printf ("DW_OP_drop");
1117 printf ("DW_OP_over");
1120 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1121 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1124 printf ("DW_OP_swap");
1127 printf ("DW_OP_rot");
1130 printf ("DW_OP_xderef");
1133 printf ("DW_OP_abs");
1136 printf ("DW_OP_and");
1139 printf ("DW_OP_div");
1142 printf ("DW_OP_minus");
1145 printf ("DW_OP_mod");
1148 printf ("DW_OP_mul");
1151 printf ("DW_OP_neg");
1154 printf ("DW_OP_not");
1157 printf ("DW_OP_or");
1160 printf ("DW_OP_plus");
1162 case DW_OP_plus_uconst
:
1163 printf ("DW_OP_plus_uconst: %s",
1164 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1168 printf ("DW_OP_shl");
1171 printf ("DW_OP_shr");
1174 printf ("DW_OP_shra");
1177 printf ("DW_OP_xor");
1180 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1181 printf ("DW_OP_bra: %ld", (long) svalue
);
1184 printf ("DW_OP_eq");
1187 printf ("DW_OP_ge");
1190 printf ("DW_OP_gt");
1193 printf ("DW_OP_le");
1196 printf ("DW_OP_lt");
1199 printf ("DW_OP_ne");
1202 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1203 printf ("DW_OP_skip: %ld", (long) svalue
);
1238 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1273 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1274 regname (op
- DW_OP_reg0
, 1));
1309 printf ("DW_OP_breg%d (%s): %s",
1311 regname (op
- DW_OP_breg0
, 1),
1312 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1317 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1319 printf ("DW_OP_regx: %s (%s)",
1320 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1323 need_frame_base
= 1;
1324 printf ("DW_OP_fbreg: %s",
1325 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1329 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1331 printf ("DW_OP_bregx: %s (%s) %s",
1332 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1333 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1337 printf ("DW_OP_piece: %s",
1338 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1341 case DW_OP_deref_size
:
1342 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1343 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1345 case DW_OP_xderef_size
:
1346 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1347 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1350 printf ("DW_OP_nop");
1353 /* DWARF 3 extensions. */
1354 case DW_OP_push_object_address
:
1355 printf ("DW_OP_push_object_address");
1358 /* XXX: Strictly speaking for 64-bit DWARF3 files
1359 this ought to be an 8-byte wide computation. */
1360 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1361 printf ("DW_OP_call2: <0x%s>",
1362 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1365 /* XXX: Strictly speaking for 64-bit DWARF3 files
1366 this ought to be an 8-byte wide computation. */
1367 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1368 printf ("DW_OP_call4: <0x%s>",
1369 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1371 case DW_OP_call_ref
:
1372 /* XXX: Strictly speaking for 64-bit DWARF3 files
1373 this ought to be an 8-byte wide computation. */
1374 if (dwarf_version
== -1)
1376 printf (_("(DW_OP_call_ref in frame info)"));
1377 /* No way to tell where the next op is, so just bail. */
1378 return need_frame_base
;
1380 if (dwarf_version
== 2)
1382 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1386 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1388 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1390 case DW_OP_form_tls_address
:
1391 printf ("DW_OP_form_tls_address");
1393 case DW_OP_call_frame_cfa
:
1394 printf ("DW_OP_call_frame_cfa");
1396 case DW_OP_bit_piece
:
1397 printf ("DW_OP_bit_piece: ");
1398 printf (_("size: %s "),
1399 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1401 printf (_("offset: %s "),
1402 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1406 /* DWARF 4 extensions. */
1407 case DW_OP_stack_value
:
1408 printf ("DW_OP_stack_value");
1411 case DW_OP_implicit_value
:
1412 printf ("DW_OP_implicit_value");
1413 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1415 data
= display_block (data
, uvalue
, end
, ' ');
1418 /* GNU extensions. */
1419 case DW_OP_GNU_push_tls_address
:
1420 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1422 case DW_OP_GNU_uninit
:
1423 printf ("DW_OP_GNU_uninit");
1424 /* FIXME: Is there data associated with this OP ? */
1426 case DW_OP_GNU_encoded_addr
:
1433 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1435 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1436 print_dwarf_vma (addr
, pointer_size
);
1439 case DW_OP_implicit_pointer
:
1440 case DW_OP_GNU_implicit_pointer
:
1441 /* XXX: Strictly speaking for 64-bit DWARF3 files
1442 this ought to be an 8-byte wide computation. */
1443 if (dwarf_version
== -1)
1445 printf (_("(%s in frame info)"),
1446 (op
== DW_OP_implicit_pointer
1447 ? "DW_OP_implicit_pointer"
1448 : "DW_OP_GNU_implicit_pointer"));
1449 /* No way to tell where the next op is, so just bail. */
1450 return need_frame_base
;
1452 if (dwarf_version
== 2)
1454 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1458 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1460 printf ("%s: <0x%s> %s",
1461 (op
== DW_OP_implicit_pointer
1462 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1463 dwarf_vmatoa ("x", uvalue
),
1464 dwarf_vmatoa ("d", read_sleb128 (data
,
1465 &bytes_read
, end
)));
1468 case DW_OP_entry_value
:
1469 case DW_OP_GNU_entry_value
:
1470 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1472 /* PR 17531: file: 0cc9cd00. */
1473 if (uvalue
> (dwarf_vma
) (end
- data
))
1474 uvalue
= end
- data
;
1475 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1476 : "DW_OP_GNU_entry_value"));
1477 if (decode_location_expression (data
, pointer_size
, offset_size
,
1478 dwarf_version
, uvalue
,
1479 cu_offset
, section
))
1480 need_frame_base
= 1;
1486 case DW_OP_const_type
:
1487 case DW_OP_GNU_const_type
:
1488 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1490 printf ("%s: <0x%s> ",
1491 (op
== DW_OP_const_type
? "DW_OP_const_type"
1492 : "DW_OP_GNU_const_type"),
1493 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1494 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1495 data
= display_block (data
, uvalue
, end
, ' ');
1497 case DW_OP_regval_type
:
1498 case DW_OP_GNU_regval_type
:
1499 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1501 printf ("%s: %s (%s)",
1502 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1503 : "DW_OP_GNU_regval_type"),
1504 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1505 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1507 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1509 case DW_OP_deref_type
:
1510 case DW_OP_GNU_deref_type
:
1511 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1513 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1514 : "DW_OP_GNU_deref_type"),
1516 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1518 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1521 case DW_OP_GNU_convert
:
1522 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1524 printf ("%s <0x%s>",
1525 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1526 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1528 case DW_OP_reinterpret
:
1529 case DW_OP_GNU_reinterpret
:
1530 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1532 printf ("%s <0x%s>",
1533 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1534 : "DW_OP_GNU_reinterpret"),
1535 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1537 case DW_OP_GNU_parameter_ref
:
1538 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1539 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1540 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1542 case DW_OP_GNU_addr_index
:
1543 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1545 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1547 case DW_OP_GNU_const_index
:
1548 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1550 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1553 /* HP extensions. */
1554 case DW_OP_HP_is_value
:
1555 printf ("DW_OP_HP_is_value");
1556 /* FIXME: Is there data associated with this OP ? */
1558 case DW_OP_HP_fltconst4
:
1559 printf ("DW_OP_HP_fltconst4");
1560 /* FIXME: Is there data associated with this OP ? */
1562 case DW_OP_HP_fltconst8
:
1563 printf ("DW_OP_HP_fltconst8");
1564 /* FIXME: Is there data associated with this OP ? */
1566 case DW_OP_HP_mod_range
:
1567 printf ("DW_OP_HP_mod_range");
1568 /* FIXME: Is there data associated with this OP ? */
1570 case DW_OP_HP_unmod_range
:
1571 printf ("DW_OP_HP_unmod_range");
1572 /* FIXME: Is there data associated with this OP ? */
1575 printf ("DW_OP_HP_tls");
1576 /* FIXME: Is there data associated with this OP ? */
1579 /* PGI (STMicroelectronics) extensions. */
1580 case DW_OP_PGI_omp_thread_num
:
1581 /* Pushes the thread number for the current thread as it would be
1582 returned by the standard OpenMP library function:
1583 omp_get_thread_num(). The "current thread" is the thread for
1584 which the expression is being evaluated. */
1585 printf ("DW_OP_PGI_omp_thread_num");
1589 if (op
>= DW_OP_lo_user
1590 && op
<= DW_OP_hi_user
)
1591 printf (_("(User defined location op 0x%x)"), op
);
1593 printf (_("(Unknown location op 0x%x)"), op
);
1594 /* No way to tell where the next op is, so just bail. */
1595 return need_frame_base
;
1598 /* Separate the ops. */
1603 return need_frame_base
;
1606 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1607 This is used for DWARF package files. */
1609 static struct cu_tu_set
*
1610 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1612 struct cu_tu_set
*p
;
1614 unsigned int dw_sect
;
1620 dw_sect
= DW_SECT_TYPES
;
1626 dw_sect
= DW_SECT_INFO
;
1630 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1638 /* Add INC to HIGH_BITS:LOW_BITS. */
1640 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1642 dwarf_vma tmp
= * low_bits
;
1646 /* FIXME: There is probably a better way of handling this:
1648 We need to cope with dwarf_vma being a 32-bit or 64-bit
1649 type. Plus regardless of its size LOW_BITS is meant to
1650 only hold 32-bits, so if there is overflow or wrap around
1651 we must propagate into HIGH_BITS. */
1652 if (tmp
< * low_bits
)
1656 else if (sizeof (tmp
) > 8
1666 static unsigned char *
1667 read_and_display_attr_value (unsigned long attribute
,
1669 dwarf_signed_vma implicit_const
,
1670 unsigned char * data
,
1671 unsigned char * end
,
1672 dwarf_vma cu_offset
,
1673 dwarf_vma pointer_size
,
1674 dwarf_vma offset_size
,
1676 debug_info
* debug_info_p
,
1678 struct dwarf_section
* section
,
1679 struct cu_tu_set
* this_set
, char delimiter
)
1681 dwarf_vma uvalue
= 0;
1682 unsigned char *block_start
= NULL
;
1683 unsigned char * orig_data
= data
;
1684 unsigned int bytes_read
;
1686 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
1688 warn (_("Corrupt attribute\n"));
1697 case DW_FORM_ref_addr
:
1698 if (dwarf_version
== 2)
1699 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1700 else if (dwarf_version
== 3 || dwarf_version
== 4)
1701 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1703 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1708 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1712 case DW_FORM_line_strp
:
1713 case DW_FORM_sec_offset
:
1714 case DW_FORM_GNU_ref_alt
:
1715 case DW_FORM_GNU_strp_alt
:
1716 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1719 case DW_FORM_flag_present
:
1726 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1731 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1736 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1740 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1744 case DW_FORM_GNU_str_index
:
1745 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1749 case DW_FORM_ref_udata
:
1751 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1755 case DW_FORM_indirect
:
1756 form
= read_uleb128 (data
, & bytes_read
, end
);
1759 printf ("%c%s", delimiter
, get_FORM_name (form
));
1760 if (form
== DW_FORM_implicit_const
)
1762 implicit_const
= read_sleb128 (data
, & bytes_read
, end
);
1765 return read_and_display_attr_value (attribute
, form
, implicit_const
, data
,
1766 end
, cu_offset
, pointer_size
,
1767 offset_size
, dwarf_version
,
1768 debug_info_p
, do_loc
,
1769 section
, this_set
, delimiter
);
1770 case DW_FORM_GNU_addr_index
:
1771 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1778 case DW_FORM_ref_addr
:
1780 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
1783 case DW_FORM_GNU_ref_alt
:
1785 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x",uvalue
));
1791 case DW_FORM_ref_udata
:
1793 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1798 case DW_FORM_sec_offset
:
1800 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
1803 case DW_FORM_flag_present
:
1810 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
1813 case DW_FORM_implicit_const
:
1815 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
1822 dwarf_vma high_bits
;
1826 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1828 if (form
== DW_FORM_ref8
)
1829 add64 (& high_bits
, & utmp
, cu_offset
);
1830 printf ("%c0x%s", delimiter
,
1831 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1834 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1835 && num_debug_info_entries
== 0)
1837 if (sizeof (uvalue
) == 8)
1838 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1840 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1846 case DW_FORM_data16
:
1849 dwarf_vma left_high_bits
, left_low_bits
;
1850 dwarf_vma right_high_bits
, right_low_bits
;
1852 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
1853 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
1854 if (byte_get
== byte_get_little_endian
)
1857 left_high_bits
^= right_high_bits
;
1858 right_high_bits
^= left_high_bits
;
1859 left_high_bits
^= right_high_bits
;
1860 left_low_bits
^= right_low_bits
;
1861 right_low_bits
^= left_low_bits
;
1862 left_low_bits
^= right_low_bits
;
1864 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
1865 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
1866 left_high_bits
, left_low_bits
, right_high_bits
,
1872 case DW_FORM_string
:
1874 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
1875 data
+= strnlen ((char *) data
, end
- data
) + 1;
1879 case DW_FORM_exprloc
:
1880 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1881 block_start
= data
+ bytes_read
;
1882 if (block_start
>= end
)
1884 warn (_("Block ends prematurely\n"));
1888 /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1889 gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute
1890 block_start + uvalue here. */
1891 data
= block_start
+ uvalue
;
1892 /* PR 17512: file: 008-103549-0.001:0.1. */
1893 if (block_start
+ uvalue
> end
|| data
< block_start
)
1895 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1896 uvalue
= end
- block_start
;
1899 data
= block_start
+ uvalue
;
1901 data
= display_block (block_start
, uvalue
, end
, delimiter
);
1904 case DW_FORM_block1
:
1905 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1906 block_start
= data
+ 1;
1907 if (block_start
>= end
)
1909 warn (_("Block ends prematurely\n"));
1913 data
= block_start
+ uvalue
;
1914 if (block_start
+ uvalue
> end
|| data
< block_start
)
1916 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1917 uvalue
= end
- block_start
;
1920 data
= block_start
+ uvalue
;
1922 data
= display_block (block_start
, uvalue
, end
, delimiter
);
1925 case DW_FORM_block2
:
1926 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1927 block_start
= data
+ 2;
1928 if (block_start
>= end
)
1930 warn (_("Block ends prematurely\n"));
1934 data
= block_start
+ uvalue
;
1935 if (block_start
+ uvalue
> end
|| data
< block_start
)
1937 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1938 uvalue
= end
- block_start
;
1941 data
= block_start
+ uvalue
;
1943 data
= display_block (block_start
, uvalue
, end
, delimiter
);
1946 case DW_FORM_block4
:
1947 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1948 block_start
= data
+ 4;
1949 /* PR 17512: file: 3371-3907-0.004. */
1950 if (block_start
>= end
)
1952 warn (_("Block ends prematurely\n"));
1956 data
= block_start
+ uvalue
;
1957 if (block_start
+ uvalue
> end
1958 /* PR 17531: file: 5b5f0592. */
1959 || data
< block_start
)
1961 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1962 uvalue
= end
- block_start
;
1965 data
= block_start
+ uvalue
;
1967 data
= display_block (block_start
, uvalue
, end
, delimiter
);
1972 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
1973 dwarf_vmatoa ("x", uvalue
),
1974 fetch_indirect_string (uvalue
));
1977 case DW_FORM_line_strp
:
1979 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
1980 dwarf_vmatoa ("x", uvalue
),
1981 fetch_indirect_line_string (uvalue
));
1984 case DW_FORM_GNU_str_index
:
1987 const char *suffix
= strrchr (section
->name
, '.');
1988 int dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? 1 : 0;
1990 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
1991 dwarf_vmatoa ("x", uvalue
),
1992 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
1996 case DW_FORM_GNU_strp_alt
:
1998 printf (_("%c(alt indirect string, offset: 0x%s)"), delimiter
,
1999 dwarf_vmatoa ("x", uvalue
));
2002 case DW_FORM_indirect
:
2003 /* Handled above. */
2006 case DW_FORM_ref_sig8
:
2009 dwarf_vma high_bits
;
2012 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2013 printf ("%csignature: 0x%s", delimiter
,
2014 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2019 case DW_FORM_GNU_addr_index
:
2021 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2022 dwarf_vmatoa ("x", uvalue
),
2023 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2027 warn (_("Unrecognized form: %lu\n"), form
);
2031 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2032 && num_debug_info_entries
== 0
2033 && debug_info_p
!= NULL
)
2037 case DW_AT_frame_base
:
2038 have_frame_base
= 1;
2040 case DW_AT_location
:
2041 case DW_AT_GNU_locviews
:
2042 case DW_AT_string_length
:
2043 case DW_AT_return_addr
:
2044 case DW_AT_data_member_location
:
2045 case DW_AT_vtable_elem_location
:
2047 case DW_AT_static_link
:
2048 case DW_AT_use_location
:
2049 case DW_AT_call_value
:
2050 case DW_AT_GNU_call_site_value
:
2051 case DW_AT_call_data_value
:
2052 case DW_AT_GNU_call_site_data_value
:
2053 case DW_AT_call_target
:
2054 case DW_AT_GNU_call_site_target
:
2055 case DW_AT_call_target_clobbered
:
2056 case DW_AT_GNU_call_site_target_clobbered
:
2057 if ((dwarf_version
< 4
2058 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2059 || form
== DW_FORM_sec_offset
)
2061 /* Process location list. */
2062 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2063 unsigned int num
= debug_info_p
->num_loc_offsets
;
2065 if (lmax
== 0 || num
>= lmax
)
2068 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2069 xcrealloc (debug_info_p
->loc_offsets
,
2070 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2071 debug_info_p
->loc_views
= (dwarf_vma
*)
2072 xcrealloc (debug_info_p
->loc_views
,
2073 lmax
, sizeof (*debug_info_p
->loc_views
));
2074 debug_info_p
->have_frame_base
= (int *)
2075 xcrealloc (debug_info_p
->have_frame_base
,
2076 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2077 debug_info_p
->max_loc_offsets
= lmax
;
2079 if (this_set
!= NULL
)
2080 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2081 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2082 if (attribute
!= DW_AT_GNU_locviews
)
2084 debug_info_p
->loc_offsets
[num
] = uvalue
;
2085 debug_info_p
->num_loc_offsets
++;
2086 assert (debug_info_p
->num_loc_offsets
2087 - debug_info_p
->num_loc_views
<= 1);
2091 assert (debug_info_p
->num_loc_views
<= num
);
2092 num
= debug_info_p
->num_loc_views
;
2093 debug_info_p
->loc_views
[num
] = uvalue
;
2094 debug_info_p
->num_loc_views
++;
2095 assert (debug_info_p
->num_loc_views
2096 - debug_info_p
->num_loc_offsets
<= 1);
2102 if (need_base_address
)
2103 debug_info_p
->base_address
= uvalue
;
2106 case DW_AT_GNU_addr_base
:
2107 debug_info_p
->addr_base
= uvalue
;
2110 case DW_AT_GNU_ranges_base
:
2111 debug_info_p
->ranges_base
= uvalue
;
2115 if ((dwarf_version
< 4
2116 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2117 || form
== DW_FORM_sec_offset
)
2119 /* Process range list. */
2120 unsigned int lmax
= debug_info_p
->max_range_lists
;
2121 unsigned int num
= debug_info_p
->num_range_lists
;
2123 if (lmax
== 0 || num
>= lmax
)
2126 debug_info_p
->range_lists
= (dwarf_vma
*)
2127 xcrealloc (debug_info_p
->range_lists
,
2128 lmax
, sizeof (*debug_info_p
->range_lists
));
2129 debug_info_p
->max_range_lists
= lmax
;
2131 debug_info_p
->range_lists
[num
] = uvalue
;
2132 debug_info_p
->num_range_lists
++;
2141 if (do_loc
|| attribute
== 0)
2144 /* For some attributes we can display further information. */
2151 case DW_INL_not_inlined
:
2152 printf (_("(not inlined)"));
2154 case DW_INL_inlined
:
2155 printf (_("(inlined)"));
2157 case DW_INL_declared_not_inlined
:
2158 printf (_("(declared as inline but ignored)"));
2160 case DW_INL_declared_inlined
:
2161 printf (_("(declared as inline and inlined)"));
2164 printf (_(" (Unknown inline attribute value: %s)"),
2165 dwarf_vmatoa ("x", uvalue
));
2170 case DW_AT_language
:
2174 /* Ordered by the numeric value of these constants. */
2175 case DW_LANG_C89
: printf ("(ANSI C)"); break;
2176 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
2177 case DW_LANG_Ada83
: printf ("(Ada)"); break;
2178 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
2179 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
2180 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
2181 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
2182 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
2183 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
2184 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
2185 /* DWARF 2.1 values. */
2186 case DW_LANG_Java
: printf ("(Java)"); break;
2187 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
2188 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
2189 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
2190 /* DWARF 3 values. */
2191 case DW_LANG_PLI
: printf ("(PLI)"); break;
2192 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
2193 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
2194 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
2195 case DW_LANG_D
: printf ("(D)"); break;
2196 /* DWARF 4 values. */
2197 case DW_LANG_Python
: printf ("(Python)"); break;
2198 /* DWARF 5 values. */
2199 case DW_LANG_Go
: printf ("(Go)"); break;
2200 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
2201 case DW_LANG_C11
: printf ("(C11)"); break;
2202 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
2203 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
2204 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
2205 /* MIPS extension. */
2206 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
2207 /* UPC extension. */
2208 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
2210 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
2211 printf (_("(implementation defined: %s)"),
2212 dwarf_vmatoa ("x", uvalue
));
2214 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
2219 case DW_AT_encoding
:
2223 case DW_ATE_void
: printf ("(void)"); break;
2224 case DW_ATE_address
: printf ("(machine address)"); break;
2225 case DW_ATE_boolean
: printf ("(boolean)"); break;
2226 case DW_ATE_complex_float
: printf ("(complex float)"); break;
2227 case DW_ATE_float
: printf ("(float)"); break;
2228 case DW_ATE_signed
: printf ("(signed)"); break;
2229 case DW_ATE_signed_char
: printf ("(signed char)"); break;
2230 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
2231 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
2232 /* DWARF 2.1 values: */
2233 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
2234 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2235 /* DWARF 3 values: */
2236 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2237 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2238 case DW_ATE_edited
: printf ("(edited)"); break;
2239 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2240 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2241 /* HP extensions: */
2242 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2243 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2244 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2245 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2246 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2247 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2248 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2249 /* DWARF 4 values: */
2250 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2253 if (uvalue
>= DW_ATE_lo_user
2254 && uvalue
<= DW_ATE_hi_user
)
2255 printf (_("(user defined type)"));
2257 printf (_("(unknown type)"));
2262 case DW_AT_accessibility
:
2266 case DW_ACCESS_public
: printf ("(public)"); break;
2267 case DW_ACCESS_protected
: printf ("(protected)"); break;
2268 case DW_ACCESS_private
: printf ("(private)"); break;
2270 printf (_("(unknown accessibility)"));
2275 case DW_AT_visibility
:
2279 case DW_VIS_local
: printf ("(local)"); break;
2280 case DW_VIS_exported
: printf ("(exported)"); break;
2281 case DW_VIS_qualified
: printf ("(qualified)"); break;
2282 default: printf (_("(unknown visibility)")); break;
2286 case DW_AT_virtuality
:
2290 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2291 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2292 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2293 default: printf (_("(unknown virtuality)")); break;
2297 case DW_AT_identifier_case
:
2301 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2302 case DW_ID_up_case
: printf ("(up_case)"); break;
2303 case DW_ID_down_case
: printf ("(down_case)"); break;
2304 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2305 default: printf (_("(unknown case)")); break;
2309 case DW_AT_calling_convention
:
2313 case DW_CC_normal
: printf ("(normal)"); break;
2314 case DW_CC_program
: printf ("(program)"); break;
2315 case DW_CC_nocall
: printf ("(nocall)"); break;
2317 if (uvalue
>= DW_CC_lo_user
2318 && uvalue
<= DW_CC_hi_user
)
2319 printf (_("(user defined)"));
2321 printf (_("(unknown convention)"));
2325 case DW_AT_ordering
:
2329 case -1: printf (_("(undefined)")); break;
2330 case 0: printf ("(row major)"); break;
2331 case 1: printf ("(column major)"); break;
2335 case DW_AT_frame_base
:
2336 have_frame_base
= 1;
2338 case DW_AT_location
:
2339 case DW_AT_string_length
:
2340 case DW_AT_return_addr
:
2341 case DW_AT_data_member_location
:
2342 case DW_AT_vtable_elem_location
:
2344 case DW_AT_static_link
:
2345 case DW_AT_use_location
:
2346 case DW_AT_call_value
:
2347 case DW_AT_GNU_call_site_value
:
2348 case DW_AT_call_data_value
:
2349 case DW_AT_GNU_call_site_data_value
:
2350 case DW_AT_call_target
:
2351 case DW_AT_GNU_call_site_target
:
2352 case DW_AT_call_target_clobbered
:
2353 case DW_AT_GNU_call_site_target_clobbered
:
2354 if ((dwarf_version
< 4
2355 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2356 || form
== DW_FORM_sec_offset
)
2357 printf (_(" (location list)"));
2359 case DW_AT_allocated
:
2360 case DW_AT_associated
:
2361 case DW_AT_data_location
:
2363 case DW_AT_upper_bound
:
2364 case DW_AT_lower_bound
:
2367 int need_frame_base
;
2370 need_frame_base
= decode_location_expression (block_start
,
2375 cu_offset
, section
);
2377 if (need_frame_base
&& !have_frame_base
)
2378 printf (_(" [without DW_AT_frame_base]"));
2384 if (form
== DW_FORM_ref_sig8
2385 || form
== DW_FORM_GNU_ref_alt
)
2388 if (form
== DW_FORM_ref1
2389 || form
== DW_FORM_ref2
2390 || form
== DW_FORM_ref4
2391 || form
== DW_FORM_ref_udata
)
2392 uvalue
+= cu_offset
;
2394 if (uvalue
>= section
->size
)
2395 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2396 dwarf_vmatoa ("x", uvalue
),
2397 (unsigned long) (orig_data
- section
->start
));
2400 unsigned long abbrev_number
;
2401 abbrev_entry
* entry
;
2403 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2405 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2406 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2407 use different abbrev table, and we don't track .debug_info chunks
2409 if (form
!= DW_FORM_ref_addr
)
2411 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2412 if (entry
->entry
== abbrev_number
)
2415 printf (" (%s)", get_TAG_name (entry
->tag
));
2430 get_AT_name (unsigned long attribute
)
2435 return "DW_AT value: 0";
2437 /* One value is shared by the MIPS and HP extensions: */
2438 if (attribute
== DW_AT_MIPS_fde
)
2439 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2441 name
= get_DW_AT_name (attribute
);
2445 static char buffer
[100];
2447 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2455 static unsigned char *
2456 read_and_display_attr (unsigned long attribute
,
2458 dwarf_signed_vma implicit_const
,
2459 unsigned char * data
,
2460 unsigned char * end
,
2461 dwarf_vma cu_offset
,
2462 dwarf_vma pointer_size
,
2463 dwarf_vma offset_size
,
2465 debug_info
* debug_info_p
,
2467 struct dwarf_section
* section
,
2468 struct cu_tu_set
* this_set
)
2471 printf (" %-18s:", get_AT_name (attribute
));
2472 data
= read_and_display_attr_value (attribute
, form
, implicit_const
, data
, end
,
2473 cu_offset
, pointer_size
, offset_size
,
2474 dwarf_version
, debug_info_p
,
2475 do_loc
, section
, this_set
, ' ');
2481 /* Process the contents of a .debug_info section. If do_loc is non-zero
2482 then we are scanning for location lists and we do not want to display
2483 anything to the user. If do_types is non-zero, we are processing
2484 a .debug_types section instead of a .debug_info section. */
2487 process_debug_info (struct dwarf_section
*section
,
2489 enum dwarf_section_display_enum abbrev_sec
,
2493 unsigned char *start
= section
->start
;
2494 unsigned char *end
= start
+ section
->size
;
2495 unsigned char *section_begin
;
2497 unsigned int num_units
= 0;
2499 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2500 && num_debug_info_entries
== 0
2505 /* First scan the section to get the number of comp units. */
2506 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2509 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2510 will be the length. For a 64-bit DWARF section, it'll be
2511 the escape code 0xffffffff followed by an 8 byte length. */
2512 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2514 if (length
== 0xffffffff)
2516 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2517 section_begin
+= length
+ 12;
2519 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2521 warn (_("Reserved length value (0x%s) found in section %s\n"),
2522 dwarf_vmatoa ("x", length
), section
->name
);
2526 section_begin
+= length
+ 4;
2528 /* Negative values are illegal, they may even cause infinite
2529 looping. This can happen if we can't accurately apply
2530 relocations to an object file, or if the file is corrupt. */
2531 if ((signed long) length
<= 0 || section_begin
< start
)
2533 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2534 dwarf_vmatoa ("x", length
), section
->name
);
2541 error (_("No comp units in %s section ?\n"), section
->name
);
2545 /* Then allocate an array to hold the information. */
2546 debug_information
= (debug_info
*) cmalloc (num_units
,
2547 sizeof (* debug_information
));
2548 if (debug_information
== NULL
)
2550 error (_("Not enough memory for a debug info array of %u entries\n"),
2552 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
2555 /* PR 17531: file: 92ca3797.
2556 We cannot rely upon the debug_information array being initialised
2557 before it is used. A corrupt file could easily contain references
2558 to a unit for which information has not been made available. So
2559 we ensure that the array is zeroed here. */
2560 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
2562 alloc_num_debug_info_entries
= num_units
;
2567 if (dwarf_start_die
== 0)
2568 printf (_("Contents of the %s section:\n\n"), section
->name
);
2570 load_debug_section (str
, file
);
2571 load_debug_section (line_str
, file
);
2572 load_debug_section (str_dwo
, file
);
2573 load_debug_section (str_index
, file
);
2574 load_debug_section (str_index_dwo
, file
);
2575 load_debug_section (debug_addr
, file
);
2578 load_debug_section (abbrev_sec
, file
);
2579 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2581 warn (_("Unable to locate %s section!\n"),
2582 debug_displays
[abbrev_sec
].section
.name
);
2586 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2588 DWARF2_Internal_CompUnit compunit
;
2589 unsigned char *hdrptr
;
2590 unsigned char *tags
;
2591 int level
, last_level
, saved_level
;
2592 dwarf_vma cu_offset
;
2593 unsigned int offset_size
;
2594 unsigned int initial_length_size
;
2595 dwarf_vma signature_high
= 0;
2596 dwarf_vma signature_low
= 0;
2597 dwarf_vma type_offset
= 0;
2598 struct cu_tu_set
*this_set
;
2599 dwarf_vma abbrev_base
;
2604 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2606 if (compunit
.cu_length
== 0xffffffff)
2608 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2610 initial_length_size
= 12;
2615 initial_length_size
= 4;
2618 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2620 cu_offset
= start
- section_begin
;
2622 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2624 if (compunit
.cu_version
< 5)
2626 compunit
.cu_unit_type
= DW_UT_compile
;
2627 /* Initialize it due to a false compiler warning. */
2628 compunit
.cu_pointer_size
= -1;
2632 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
2633 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
2635 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2638 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2640 if (this_set
== NULL
)
2643 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2647 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2648 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2651 if (compunit
.cu_version
< 5)
2652 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2654 /* PR 17512: file: 001-108546-0.001:0.1. */
2655 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2657 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2658 compunit
.cu_pointer_size
, offset_size
);
2659 compunit
.cu_pointer_size
= offset_size
;
2664 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2666 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2669 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2670 && num_debug_info_entries
== 0
2673 debug_information
[unit
].cu_offset
= cu_offset
;
2674 debug_information
[unit
].pointer_size
2675 = compunit
.cu_pointer_size
;
2676 debug_information
[unit
].offset_size
= offset_size
;
2677 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2678 debug_information
[unit
].base_address
= 0;
2679 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2680 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2681 debug_information
[unit
].loc_offsets
= NULL
;
2682 debug_information
[unit
].have_frame_base
= NULL
;
2683 debug_information
[unit
].max_loc_offsets
= 0;
2684 debug_information
[unit
].num_loc_offsets
= 0;
2685 debug_information
[unit
].range_lists
= NULL
;
2686 debug_information
[unit
].max_range_lists
= 0;
2687 debug_information
[unit
].num_range_lists
= 0;
2690 if (!do_loc
&& dwarf_start_die
== 0)
2692 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2693 dwarf_vmatoa ("x", cu_offset
));
2694 printf (_(" Length: 0x%s (%s)\n"),
2695 dwarf_vmatoa ("x", compunit
.cu_length
),
2696 offset_size
== 8 ? "64-bit" : "32-bit");
2697 printf (_(" Version: %d\n"), compunit
.cu_version
);
2698 printf (_(" Abbrev Offset: 0x%s\n"),
2699 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2700 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2705 printf (_(" Signature: 0x%s\n"),
2706 dwarf_vmatoa64 (signature_high
, signature_low
,
2707 buf
, sizeof (buf
)));
2708 printf (_(" Type Offset: 0x%s\n"),
2709 dwarf_vmatoa ("x", type_offset
));
2711 if (this_set
!= NULL
)
2713 dwarf_vma
*offsets
= this_set
->section_offsets
;
2714 size_t *sizes
= this_set
->section_sizes
;
2716 printf (_(" Section contributions:\n"));
2717 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2718 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2719 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2720 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2721 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2722 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2723 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2724 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2725 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2726 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2727 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2728 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2732 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2735 warn (_("Debug info is corrupted, length of CU at %s"
2736 " extends beyond end of section (length = %s)\n"),
2737 dwarf_vmatoa ("x", cu_offset
),
2738 dwarf_vmatoa ("x", compunit
.cu_length
));
2742 else if (compunit
.cu_length
+ initial_length_size
< initial_length_size
)
2744 warn (_("Debug info is corrupted, length of CU at %s is negative (%s)\n"),
2745 dwarf_vmatoa ("x", cu_offset
),
2746 dwarf_vmatoa ("x", compunit
.cu_length
));
2752 start
+= compunit
.cu_length
+ initial_length_size
;
2756 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2757 dwarf_vmatoa ("x", cu_offset
));
2761 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
2763 warn (_("CU at offset %s contains corrupt or "
2764 "unsupported version number: %d.\n"),
2765 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2769 if (compunit
.cu_unit_type
!= DW_UT_compile
2770 && compunit
.cu_unit_type
!= DW_UT_type
)
2772 warn (_("CU at offset %s contains corrupt or "
2773 "unsupported unit type: %d.\n"),
2774 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
2780 /* Process the abbrevs used by this compilation unit. */
2781 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2782 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2783 (unsigned long) compunit
.cu_abbrev_offset
,
2784 (unsigned long) abbrev_size
);
2785 /* PR 17531: file:4bcd9ce9. */
2786 else if ((abbrev_base
+ abbrev_size
)
2787 > debug_displays
[abbrev_sec
].section
.size
)
2788 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2789 (unsigned long) abbrev_base
+ abbrev_size
,
2790 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
2792 process_abbrev_section
2793 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2794 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2795 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2796 + abbrev_base
+ abbrev_size
));
2801 while (tags
< start
)
2803 unsigned int bytes_read
;
2804 unsigned long abbrev_number
;
2805 unsigned long die_offset
;
2806 abbrev_entry
*entry
;
2808 int do_printing
= 1;
2810 die_offset
= tags
- section_begin
;
2812 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2815 /* A null DIE marks the end of a list of siblings or it may also be
2816 a section padding. */
2817 if (abbrev_number
== 0)
2819 /* Check if it can be a section padding for the last CU. */
2820 if (level
== 0 && start
== end
)
2824 for (chk
= tags
; chk
< start
; chk
++)
2831 if (!do_loc
&& die_offset
>= dwarf_start_die
2832 && (dwarf_cutoff_level
== -1
2833 || level
< dwarf_cutoff_level
))
2834 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2840 static unsigned num_bogus_warns
= 0;
2842 if (num_bogus_warns
< 3)
2844 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2845 die_offset
, section
->name
);
2847 if (num_bogus_warns
== 3)
2848 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2851 if (dwarf_start_die
!= 0 && level
< saved_level
)
2858 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2862 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2863 saved_level
= level
;
2864 do_printing
= (dwarf_cutoff_level
== -1
2865 || level
< dwarf_cutoff_level
);
2867 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2868 level
, die_offset
, abbrev_number
);
2869 else if (dwarf_cutoff_level
== -1
2870 || last_level
< dwarf_cutoff_level
)
2871 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2876 /* Scan through the abbreviation list until we reach the
2878 for (entry
= first_abbrev
;
2879 entry
&& entry
->entry
!= abbrev_number
;
2880 entry
= entry
->next
)
2885 if (!do_loc
&& do_printing
)
2890 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2891 die_offset
, abbrev_number
);
2895 if (!do_loc
&& do_printing
)
2896 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2901 need_base_address
= 0;
2903 case DW_TAG_compile_unit
:
2904 need_base_address
= 1;
2906 case DW_TAG_entry_point
:
2907 case DW_TAG_subprogram
:
2908 need_base_address
= 0;
2909 /* Assuming that there is no DW_AT_frame_base. */
2910 have_frame_base
= 0;
2914 debug_info
*debug_info_p
=
2915 (debug_information
&& unit
< alloc_num_debug_info_entries
)
2916 ? debug_information
+ unit
: NULL
;
2918 assert (!debug_info_p
2919 || (debug_info_p
->num_loc_offsets
2920 == debug_info_p
->num_loc_views
));
2922 for (attr
= entry
->first_attr
;
2923 attr
&& attr
->attribute
;
2926 if (! do_loc
&& do_printing
)
2927 /* Show the offset from where the tag was extracted. */
2928 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2930 tags
= read_and_display_attr (attr
->attribute
,
2932 attr
->implicit_const
,
2936 compunit
.cu_pointer_size
,
2938 compunit
.cu_version
,
2940 do_loc
|| ! do_printing
,
2945 /* If a locview attribute appears before a location one,
2946 make sure we don't associate it with an earlier
2949 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
2952 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
2953 debug_info_p
->num_loc_views
++;
2954 assert (debug_info_p
->num_loc_views
2955 == debug_info_p
->num_loc_offsets
);
2962 warn(_("DIE has locviews without loclist\n"));
2963 debug_info_p
->num_loc_views
--;
2970 if (entry
->children
)
2975 /* Set num_debug_info_entries here so that it can be used to check if
2976 we need to process .debug_loc and .debug_ranges sections. */
2977 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2978 && num_debug_info_entries
== 0
2981 if (num_units
> alloc_num_debug_info_entries
)
2982 num_debug_info_entries
= alloc_num_debug_info_entries
;
2984 num_debug_info_entries
= num_units
;
2993 /* Locate and scan the .debug_info section in the file and record the pointer
2994 sizes and offsets for the compilation units in it. Usually an executable
2995 will have just one pointer size, but this is not guaranteed, and so we try
2996 not to make any assumptions. Returns zero upon failure, or the number of
2997 compilation units upon success. */
3000 load_debug_info (void * file
)
3002 /* If we have already tried and failed to load the .debug_info
3003 section then do not bother to repeat the task. */
3004 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3007 /* If we already have the information there is nothing else to do. */
3008 if (num_debug_info_entries
> 0)
3009 return num_debug_info_entries
;
3011 /* If this is a DWARF package file, load the CU and TU indexes. */
3012 (void) load_cu_tu_indexes (file
);
3014 if (load_debug_section (info
, file
)
3015 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
3016 return num_debug_info_entries
;
3018 if (load_debug_section (info_dwo
, file
)
3019 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3021 return num_debug_info_entries
;
3023 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3027 /* Read a DWARF .debug_line section header starting at DATA.
3028 Upon success returns an updated DATA pointer and the LINFO
3029 structure and the END_OF_SEQUENCE pointer will be filled in.
3030 Otherwise returns NULL. */
3032 static unsigned char *
3033 read_debug_line_header (struct dwarf_section
* section
,
3034 unsigned char * data
,
3035 unsigned char * end
,
3036 DWARF2_Internal_LineInfo
* linfo
,
3037 unsigned char ** end_of_sequence
)
3039 unsigned char *hdrptr
;
3040 unsigned int initial_length_size
;
3041 unsigned char address_size
, segment_selector_size
;
3043 /* Extract information from the Line Number Program Header.
3044 (section 6.2.4 in the Dwarf3 doc). */
3047 /* Get and check the length of the block. */
3048 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3050 if (linfo
->li_length
== 0xffffffff)
3052 /* This section is 64-bit DWARF 3. */
3053 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3054 linfo
->li_offset_size
= 8;
3055 initial_length_size
= 12;
3059 linfo
->li_offset_size
= 4;
3060 initial_length_size
= 4;
3063 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3065 /* If the length field has a relocation against it, then we should
3066 not complain if it is inaccurate (and probably negative). This
3067 happens in object files when the .debug_line section is actually
3068 comprised of several different .debug_line.* sections, (some of
3069 which may be removed by linker garbage collection), and a relocation
3070 is used to compute the correct length once that is done. */
3071 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3073 linfo
->li_length
= (end
- data
) - initial_length_size
;
3077 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3078 (long) linfo
->li_length
);
3083 /* Get and check the version number. */
3084 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3086 if (linfo
->li_version
!= 2
3087 && linfo
->li_version
!= 3
3088 && linfo
->li_version
!= 4
3089 && linfo
->li_version
!= 5)
3091 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3092 "is currently supported.\n"));
3096 if (linfo
->li_version
>= 5)
3098 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
3100 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
3101 if (segment_selector_size
!= 0)
3103 warn (_("The %s section contains "
3104 "unsupported segment selector size: %d.\n"),
3105 section
->name
, segment_selector_size
);
3110 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3111 linfo
->li_offset_size
, end
);
3112 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3114 if (linfo
->li_version
>= 4)
3116 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3118 if (linfo
->li_max_ops_per_insn
== 0)
3120 warn (_("Invalid maximum operations per insn.\n"));
3125 linfo
->li_max_ops_per_insn
= 1;
3127 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3128 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3129 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3130 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3132 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3133 /* PR 17512: file:002-117414-0.004. */
3134 if (* end_of_sequence
> end
)
3136 warn (_("Line length %s extends beyond end of section\n"),
3137 dwarf_vmatoa ("u", linfo
->li_length
));
3138 * end_of_sequence
= end
;
3145 static unsigned char *
3146 display_formatted_table (unsigned char *data
,
3147 unsigned char *start
, unsigned char *end
,
3148 const DWARF2_Internal_LineInfo
*linfo
,
3149 struct dwarf_section
*section
, const char *what
)
3151 unsigned char *format_start
, format_count
, *format
, formati
;
3152 dwarf_vma data_count
, datai
;
3153 unsigned int bytes_read
, namepass
, last_entry
= 0;
3155 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3156 format_start
= data
;
3157 for (formati
= 0; formati
< format_count
; formati
++)
3159 read_uleb128 (data
, & bytes_read
, end
);
3161 read_uleb128 (data
, & bytes_read
, end
);
3165 warn (_("Corrupt %s format table entry\n"), what
);
3170 data_count
= read_uleb128 (data
, & bytes_read
, end
);
3174 warn (_("Corrupt %s list\n"), what
);
3178 if (data_count
== 0)
3180 printf (_("\n The %s Table is empty.\n"), what
);
3184 printf (_("\n The %s Table (offset 0x%lx):\n"), what
,
3185 (long)(data
- start
));
3187 printf (_(" Entry"));
3188 /* Delay displaying name as the last entry for better screen layout. */
3189 for (namepass
= 0; namepass
< 2; namepass
++)
3191 format
= format_start
;
3192 for (formati
= 0; formati
< format_count
; formati
++)
3194 dwarf_vma content_type
;
3196 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3197 format
+= bytes_read
;
3198 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3199 switch (content_type
)
3202 printf (_("\tName"));
3204 case DW_LNCT_directory_index
:
3205 printf (_("\tDir"));
3207 case DW_LNCT_timestamp
:
3208 printf (_("\tTime"));
3211 printf (_("\tSize"));
3214 printf (_("\tMD5"));
3217 printf (_("\t(Unknown format content type %s)"),
3218 dwarf_vmatoa ("u", content_type
));
3220 read_uleb128 (format
, & bytes_read
, end
);
3221 format
+= bytes_read
;
3226 for (datai
= 0; datai
< data_count
; datai
++)
3228 unsigned char *datapass
= data
;
3230 printf (" %d", last_entry
++);
3231 /* Delay displaying name as the last entry for better screen layout. */
3232 for (namepass
= 0; namepass
< 2; namepass
++)
3234 format
= format_start
;
3236 for (formati
= 0; formati
< format_count
; formati
++)
3238 dwarf_vma content_type
, form
;
3240 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3241 format
+= bytes_read
;
3242 form
= read_uleb128 (format
, & bytes_read
, end
);
3243 format
+= bytes_read
;
3244 data
= read_and_display_attr_value (0, form
, 0, data
, end
, 0, 0,
3245 linfo
->li_offset_size
,
3246 linfo
->li_version
, NULL
,
3247 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3248 section
, NULL
, '\t');
3253 warn (_("Corrupt %s entries list\n"), what
);
3262 display_debug_lines_raw (struct dwarf_section
*section
,
3263 unsigned char *data
,
3264 unsigned char *end
, void *file
)
3266 unsigned char *start
= section
->start
;
3267 int verbose_view
= 0;
3269 printf (_("Raw dump of debug contents of section %s:\n\n"),
3274 static DWARF2_Internal_LineInfo saved_linfo
;
3275 DWARF2_Internal_LineInfo linfo
;
3276 unsigned char *standard_opcodes
;
3277 unsigned char *end_of_sequence
;
3280 if (const_strneq (section
->name
, ".debug_line.")
3281 /* Note: the following does not apply to .debug_line.dwo sections.
3282 These are full debug_line sections. */
3283 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3285 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3286 section containing just the Line Number Statements. They are
3287 created by the assembler and intended to be used alongside gcc's
3288 -ffunction-sections command line option. When the linker's
3289 garbage collection decides to discard a .text.<foo> section it
3290 can then also discard the line number information in .debug_line.<foo>.
3292 Since the section is a fragment it does not have the details
3293 needed to fill out a LineInfo structure, so instead we use the
3294 details from the last full debug_line section that we processed. */
3295 end_of_sequence
= end
;
3296 standard_opcodes
= NULL
;
3297 linfo
= saved_linfo
;
3298 /* PR 17531: file: 0522b371. */
3299 if (linfo
.li_line_range
== 0)
3301 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3304 reset_state_machine (linfo
.li_default_is_stmt
);
3308 unsigned char * hdrptr
;
3310 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3311 & end_of_sequence
)) == NULL
)
3314 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3315 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3316 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3317 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3318 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3319 if (linfo
.li_version
>= 4)
3320 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3321 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3322 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3323 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3324 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3326 /* PR 17512: file: 1665-6428-0.004. */
3327 if (linfo
.li_line_range
== 0)
3329 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3330 linfo
.li_line_range
= 1;
3333 reset_state_machine (linfo
.li_default_is_stmt
);
3335 /* Display the contents of the Opcodes table. */
3336 standard_opcodes
= hdrptr
;
3338 /* PR 17512: file: 002-417945-0.004. */
3339 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3341 warn (_("Line Base extends beyond end of section\n"));
3345 printf (_("\n Opcodes:\n"));
3347 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3348 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
3350 /* Display the contents of the Directory table. */
3351 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3353 if (linfo
.li_version
>= 5)
3355 load_debug_section (line_str
, file
);
3357 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3359 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3365 printf (_("\n The Directory Table is empty.\n"));
3368 unsigned int last_dir_entry
= 0;
3370 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3371 (long)(data
- start
));
3373 while (data
< end
&& *data
!= 0)
3375 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
3377 data
+= strnlen ((char *) data
, end
- data
) + 1;
3380 /* PR 17512: file: 002-132094-0.004. */
3381 if (data
>= end
- 1)
3385 /* Skip the NUL at the end of the table. */
3388 /* Display the contents of the File Name table. */
3390 printf (_("\n The File Name Table is empty.\n"));
3393 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3394 (long)(data
- start
));
3395 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3397 while (data
< end
&& *data
!= 0)
3399 unsigned char *name
;
3400 unsigned int bytes_read
;
3402 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
3404 data
+= strnlen ((char *) data
, end
- data
) + 1;
3407 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3410 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3413 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3415 printf ("%.*s\n", (int)(end
- name
), name
);
3419 warn (_("Corrupt file name table entry\n"));
3425 /* Skip the NUL at the end of the table. */
3430 saved_linfo
= linfo
;
3433 /* Now display the statements. */
3434 if (data
>= end_of_sequence
)
3435 printf (_(" No Line Number Statements.\n"));
3438 printf (_(" Line Number Statements:\n"));
3440 while (data
< end_of_sequence
)
3442 unsigned char op_code
;
3443 dwarf_signed_vma adv
;
3445 unsigned int bytes_read
;
3447 printf (" [0x%08lx]", (long)(data
- start
));
3451 if (op_code
>= linfo
.li_opcode_base
)
3453 op_code
-= linfo
.li_opcode_base
;
3454 uladv
= (op_code
/ linfo
.li_line_range
);
3455 if (linfo
.li_max_ops_per_insn
== 1)
3457 uladv
*= linfo
.li_min_insn_length
;
3458 state_machine_regs
.address
+= uladv
;
3460 state_machine_regs
.view
= 0;
3461 printf (_(" Special opcode %d: "
3462 "advance Address by %s to 0x%s%s"),
3463 op_code
, dwarf_vmatoa ("u", uladv
),
3464 dwarf_vmatoa ("x", state_machine_regs
.address
),
3465 verbose_view
&& uladv
3466 ? _(" (reset view)") : "");
3471 = ((state_machine_regs
.op_index
+ uladv
)
3472 / linfo
.li_max_ops_per_insn
)
3473 * linfo
.li_min_insn_length
;
3475 state_machine_regs
.address
+= addrdelta
;
3476 state_machine_regs
.op_index
3477 = (state_machine_regs
.op_index
+ uladv
)
3478 % linfo
.li_max_ops_per_insn
;
3480 state_machine_regs
.view
= 0;
3481 printf (_(" Special opcode %d: "
3482 "advance Address by %s to 0x%s[%d]%s"),
3483 op_code
, dwarf_vmatoa ("u", uladv
),
3484 dwarf_vmatoa ("x", state_machine_regs
.address
),
3485 state_machine_regs
.op_index
,
3486 verbose_view
&& addrdelta
3487 ? _(" (reset view)") : "");
3489 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3490 state_machine_regs
.line
+= adv
;
3491 printf (_(" and Line by %s to %d"),
3492 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
3493 if (verbose_view
|| state_machine_regs
.view
)
3494 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3497 state_machine_regs
.view
++;
3499 else switch (op_code
)
3501 case DW_LNS_extended_op
:
3502 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3506 printf (_(" Copy"));
3507 if (verbose_view
|| state_machine_regs
.view
)
3508 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3511 state_machine_regs
.view
++;
3514 case DW_LNS_advance_pc
:
3515 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3517 if (linfo
.li_max_ops_per_insn
== 1)
3519 uladv
*= linfo
.li_min_insn_length
;
3520 state_machine_regs
.address
+= uladv
;
3522 state_machine_regs
.view
= 0;
3523 printf (_(" Advance PC by %s to 0x%s%s\n"),
3524 dwarf_vmatoa ("u", uladv
),
3525 dwarf_vmatoa ("x", state_machine_regs
.address
),
3526 verbose_view
&& uladv
3527 ? _(" (reset view)") : "");
3532 = ((state_machine_regs
.op_index
+ uladv
)
3533 / linfo
.li_max_ops_per_insn
)
3534 * linfo
.li_min_insn_length
;
3535 state_machine_regs
.address
3537 state_machine_regs
.op_index
3538 = (state_machine_regs
.op_index
+ uladv
)
3539 % linfo
.li_max_ops_per_insn
;
3541 state_machine_regs
.view
= 0;
3542 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
3543 dwarf_vmatoa ("u", uladv
),
3544 dwarf_vmatoa ("x", state_machine_regs
.address
),
3545 state_machine_regs
.op_index
,
3546 verbose_view
&& addrdelta
3547 ? _(" (reset view)") : "");
3551 case DW_LNS_advance_line
:
3552 adv
= read_sleb128 (data
, & bytes_read
, end
);
3554 state_machine_regs
.line
+= adv
;
3555 printf (_(" Advance Line by %s to %d\n"),
3556 dwarf_vmatoa ("d", adv
),
3557 state_machine_regs
.line
);
3560 case DW_LNS_set_file
:
3561 adv
= read_uleb128 (data
, & bytes_read
, end
);
3563 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3564 dwarf_vmatoa ("d", adv
));
3565 state_machine_regs
.file
= adv
;
3568 case DW_LNS_set_column
:
3569 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3571 printf (_(" Set column to %s\n"),
3572 dwarf_vmatoa ("u", uladv
));
3573 state_machine_regs
.column
= uladv
;
3576 case DW_LNS_negate_stmt
:
3577 adv
= state_machine_regs
.is_stmt
;
3579 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3580 state_machine_regs
.is_stmt
= adv
;
3583 case DW_LNS_set_basic_block
:
3584 printf (_(" Set basic block\n"));
3585 state_machine_regs
.basic_block
= 1;
3588 case DW_LNS_const_add_pc
:
3589 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3590 if (linfo
.li_max_ops_per_insn
)
3592 uladv
*= linfo
.li_min_insn_length
;
3593 state_machine_regs
.address
+= uladv
;
3595 state_machine_regs
.view
= 0;
3596 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
3597 dwarf_vmatoa ("u", uladv
),
3598 dwarf_vmatoa ("x", state_machine_regs
.address
),
3599 verbose_view
&& uladv
3600 ? _(" (reset view)") : "");
3605 = ((state_machine_regs
.op_index
+ uladv
)
3606 / linfo
.li_max_ops_per_insn
)
3607 * linfo
.li_min_insn_length
;
3608 state_machine_regs
.address
3610 state_machine_regs
.op_index
3611 = (state_machine_regs
.op_index
+ uladv
)
3612 % linfo
.li_max_ops_per_insn
;
3614 state_machine_regs
.view
= 0;
3615 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
3616 dwarf_vmatoa ("u", uladv
),
3617 dwarf_vmatoa ("x", state_machine_regs
.address
),
3618 state_machine_regs
.op_index
,
3619 verbose_view
&& addrdelta
3620 ? _(" (reset view)") : "");
3624 case DW_LNS_fixed_advance_pc
:
3625 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3626 state_machine_regs
.address
+= uladv
;
3627 state_machine_regs
.op_index
= 0;
3628 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3629 dwarf_vmatoa ("u", uladv
),
3630 dwarf_vmatoa ("x", state_machine_regs
.address
));
3631 /* Do NOT reset view. */
3634 case DW_LNS_set_prologue_end
:
3635 printf (_(" Set prologue_end to true\n"));
3638 case DW_LNS_set_epilogue_begin
:
3639 printf (_(" Set epilogue_begin to true\n"));
3642 case DW_LNS_set_isa
:
3643 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3645 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3649 printf (_(" Unknown opcode %d with operands: "), op_code
);
3651 if (standard_opcodes
!= NULL
)
3652 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3654 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3656 i
== 1 ? "" : ", ");
3672 unsigned char *name
;
3673 unsigned int directory_index
;
3674 unsigned int modification_date
;
3675 unsigned int length
;
3678 /* Output a decoded representation of the .debug_line section. */
3681 display_debug_lines_decoded (struct dwarf_section
*section
,
3682 unsigned char *data
,
3683 unsigned char *end
, void *fileptr
)
3685 static DWARF2_Internal_LineInfo saved_linfo
;
3687 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3692 /* This loop amounts to one iteration per compilation unit. */
3693 DWARF2_Internal_LineInfo linfo
;
3694 unsigned char *standard_opcodes
;
3695 unsigned char *end_of_sequence
;
3697 File_Entry
*file_table
= NULL
;
3698 unsigned int n_files
= 0;
3699 unsigned char **directory_table
= NULL
;
3700 dwarf_vma n_directories
= 0;
3702 if (const_strneq (section
->name
, ".debug_line.")
3703 /* Note: the following does not apply to .debug_line.dwo sections.
3704 These are full debug_line sections. */
3705 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3707 /* See comment in display_debug_lines_raw(). */
3708 end_of_sequence
= end
;
3709 standard_opcodes
= NULL
;
3710 linfo
= saved_linfo
;
3711 /* PR 17531: file: 0522b371. */
3712 if (linfo
.li_line_range
== 0)
3714 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3717 reset_state_machine (linfo
.li_default_is_stmt
);
3721 unsigned char *hdrptr
;
3723 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3724 & end_of_sequence
)) == NULL
)
3727 /* PR 17531: file: 0522b371. */
3728 if (linfo
.li_line_range
== 0)
3730 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3731 linfo
.li_line_range
= 1;
3733 reset_state_machine (linfo
.li_default_is_stmt
);
3735 /* Save a pointer to the contents of the Opcodes table. */
3736 standard_opcodes
= hdrptr
;
3738 /* Traverse the Directory table just to count entries. */
3739 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3743 warn (_("opcode base of %d extends beyond end of section\n"),
3744 linfo
.li_opcode_base
);
3748 if (linfo
.li_version
>= 5)
3750 unsigned char *format_start
, format_count
, *format
;
3751 dwarf_vma formati
, entryi
;
3752 unsigned int bytes_read
;
3754 load_debug_section (line_str
, fileptr
);
3756 /* Skip directories format. */
3757 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3758 format_start
= data
;
3759 for (formati
= 0; formati
< format_count
; formati
++)
3761 read_uleb128 (data
, & bytes_read
, end
);
3763 read_uleb128 (data
, & bytes_read
, end
);
3767 n_directories
= read_uleb128 (data
, & bytes_read
, end
);
3771 warn (_("Corrupt directories list\n"));
3775 directory_table
= (unsigned char **)
3776 xmalloc (n_directories
* sizeof (unsigned char *));
3778 for (entryi
= 0; entryi
< n_directories
; entryi
++)
3780 unsigned char **pathp
= &directory_table
[entryi
];
3782 format
= format_start
;
3783 for (formati
= 0; formati
< format_count
; formati
++)
3785 dwarf_vma content_type
, form
;
3788 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3789 format
+= bytes_read
;
3790 form
= read_uleb128 (format
, & bytes_read
, end
);
3791 format
+= bytes_read
;
3794 warn (_("Corrupt directories list\n"));
3797 switch (content_type
)
3802 case DW_FORM_string
:
3805 case DW_FORM_line_strp
:
3806 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
3808 /* Remove const by the cast. */
3809 *pathp
= (unsigned char *)
3810 fetch_indirect_line_string (uvalue
);
3815 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
3817 linfo
.li_offset_size
,
3824 warn (_("Corrupt directories list\n"));
3829 /* Skip files format. */
3830 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3831 format_start
= data
;
3832 for (formati
= 0; formati
< format_count
; formati
++)
3834 read_uleb128 (data
, & bytes_read
, end
);
3836 read_uleb128 (data
, & bytes_read
, end
);
3840 n_files
= read_uleb128 (data
, & bytes_read
, end
);
3844 warn (_("Corrupt file name list\n"));
3848 file_table
= (File_Entry
*) xcalloc (1, n_files
3849 * sizeof (File_Entry
));
3851 for (entryi
= 0; entryi
< n_files
; entryi
++)
3853 File_Entry
*file
= &file_table
[entryi
];
3855 format
= format_start
;
3856 for (formati
= 0; formati
< format_count
; formati
++)
3858 dwarf_vma content_type
, form
;
3861 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3862 format
+= bytes_read
;
3863 form
= read_uleb128 (format
, & bytes_read
, end
);
3864 format
+= bytes_read
;
3867 warn (_("Corrupt file name list\n"));
3870 switch (content_type
)
3875 case DW_FORM_string
:
3878 case DW_FORM_line_strp
:
3879 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
3881 /* Remove const by the cast. */
3882 file
->name
= (unsigned char *)
3883 fetch_indirect_line_string (uvalue
);
3887 case DW_LNCT_directory_index
:
3891 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
3895 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
3899 file
->directory_index
= read_uleb128 (data
, NULL
,
3905 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
3907 linfo
.li_offset_size
,
3914 warn (_("Corrupt file name list\n"));
3923 unsigned char *ptr_directory_table
= data
;
3925 while (data
< end
&& *data
!= 0)
3927 data
+= strnlen ((char *) data
, end
- data
) + 1;
3934 warn (_("directory table ends unexpectedly\n"));
3939 /* Go through the directory table again to save the directories. */
3940 directory_table
= (unsigned char **)
3941 xmalloc (n_directories
* sizeof (unsigned char *));
3944 while (*ptr_directory_table
!= 0)
3946 directory_table
[i
] = ptr_directory_table
;
3947 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3948 ptr_directory_table
- end
) + 1;
3952 /* Skip the NUL at the end of the table. */
3955 /* Traverse the File Name table just to count the entries. */
3956 if (data
< end
&& *data
!= 0)
3958 unsigned char *ptr_file_name_table
= data
;
3960 while (data
< end
&& *data
!= 0)
3962 unsigned int bytes_read
;
3964 /* Skip Name, directory index, last modification time and length
3966 data
+= strnlen ((char *) data
, end
- data
) + 1;
3967 read_uleb128 (data
, & bytes_read
, end
);
3969 read_uleb128 (data
, & bytes_read
, end
);
3971 read_uleb128 (data
, & bytes_read
, end
);
3979 warn (_("file table ends unexpectedly\n"));
3984 /* Go through the file table again to save the strings. */
3985 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3988 while (*ptr_file_name_table
!= 0)
3990 unsigned int bytes_read
;
3992 file_table
[i
].name
= ptr_file_name_table
;
3993 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3994 end
- ptr_file_name_table
) + 1;
3996 /* We are not interested in directory, time or size. */
3997 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3999 ptr_file_name_table
+= bytes_read
;
4000 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
4002 ptr_file_name_table
+= bytes_read
;
4003 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
4004 ptr_file_name_table
+= bytes_read
;
4010 /* Skip the NUL at the end of the table. */
4014 /* Print the Compilation Unit's name and a header. */
4015 if (file_table
== NULL
)
4017 else if (directory_table
== NULL
)
4018 printf (_("CU: %s:\n"), file_table
[0].name
);
4021 unsigned int ix
= file_table
[0].directory_index
;
4022 const char *directory
;
4027 else if (n_directories
== 0)
4028 directory
= _("<unknown>");
4029 else if (ix
> n_directories
)
4031 warn (_("directory index %u > number of directories %s\n"),
4032 ix
, dwarf_vmatoa ("u", n_directories
));
4033 directory
= _("<corrupt>");
4036 directory
= (char *) directory_table
[ix
- 1];
4038 if (do_wide
|| strlen (directory
) < 76)
4039 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4041 printf ("%s:\n", file_table
[0].name
);
4044 printf (_("File name Line number Starting address View\n"));
4045 saved_linfo
= linfo
;
4048 /* This loop iterates through the Dwarf Line Number Program. */
4049 while (data
< end_of_sequence
)
4051 unsigned char op_code
;
4054 unsigned long int uladv
;
4055 unsigned int bytes_read
;
4056 int is_special_opcode
= 0;
4061 if (op_code
>= linfo
.li_opcode_base
)
4063 op_code
-= linfo
.li_opcode_base
;
4064 uladv
= (op_code
/ linfo
.li_line_range
);
4065 if (linfo
.li_max_ops_per_insn
== 1)
4067 uladv
*= linfo
.li_min_insn_length
;
4068 state_machine_regs
.address
+= uladv
;
4070 state_machine_regs
.view
= 0;
4075 = ((state_machine_regs
.op_index
+ uladv
)
4076 / linfo
.li_max_ops_per_insn
)
4077 * linfo
.li_min_insn_length
;
4078 state_machine_regs
.address
4080 state_machine_regs
.op_index
4081 = (state_machine_regs
.op_index
+ uladv
)
4082 % linfo
.li_max_ops_per_insn
;
4084 state_machine_regs
.view
= 0;
4087 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4088 state_machine_regs
.line
+= adv
;
4089 is_special_opcode
= 1;
4090 /* Increment view after printing this row. */
4092 else switch (op_code
)
4094 case DW_LNS_extended_op
:
4096 unsigned int ext_op_code_len
;
4097 unsigned char ext_op_code
;
4098 unsigned char *op_code_data
= data
;
4100 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
4102 op_code_data
+= bytes_read
;
4104 if (ext_op_code_len
== 0)
4106 warn (_("Badly formed extended line op encountered!\n"));
4109 ext_op_code_len
+= bytes_read
;
4110 ext_op_code
= *op_code_data
++;
4114 switch (ext_op_code
)
4116 case DW_LNE_end_sequence
:
4117 /* Reset stuff after printing this row. */
4119 case DW_LNE_set_address
:
4120 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4122 ext_op_code_len
- bytes_read
- 1,
4124 state_machine_regs
.op_index
= 0;
4125 state_machine_regs
.view
= 0;
4127 case DW_LNE_define_file
:
4129 file_table
= (File_Entry
*) xrealloc
4130 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4132 ++state_machine_regs
.last_file_entry
;
4133 /* Source file name. */
4134 file_table
[n_files
].name
= op_code_data
;
4135 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4136 /* Directory index. */
4137 file_table
[n_files
].directory_index
=
4138 read_uleb128 (op_code_data
, & bytes_read
,
4140 op_code_data
+= bytes_read
;
4141 /* Last modification time. */
4142 file_table
[n_files
].modification_date
=
4143 read_uleb128 (op_code_data
, & bytes_read
,
4145 op_code_data
+= bytes_read
;
4147 file_table
[n_files
].length
=
4148 read_uleb128 (op_code_data
, & bytes_read
,
4154 case DW_LNE_set_discriminator
:
4155 case DW_LNE_HP_set_sequence
:
4156 /* Simply ignored. */
4160 printf (_("UNKNOWN (%u): length %d\n"),
4161 ext_op_code
, ext_op_code_len
- bytes_read
);
4164 data
+= ext_op_code_len
;
4168 /* Increment view after printing this row. */
4171 case DW_LNS_advance_pc
:
4172 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4174 if (linfo
.li_max_ops_per_insn
== 1)
4176 uladv
*= linfo
.li_min_insn_length
;
4177 state_machine_regs
.address
+= uladv
;
4179 state_machine_regs
.view
= 0;
4184 = ((state_machine_regs
.op_index
+ uladv
)
4185 / linfo
.li_max_ops_per_insn
)
4186 * linfo
.li_min_insn_length
;
4187 state_machine_regs
.address
4189 state_machine_regs
.op_index
4190 = (state_machine_regs
.op_index
+ uladv
)
4191 % linfo
.li_max_ops_per_insn
;
4193 state_machine_regs
.view
= 0;
4197 case DW_LNS_advance_line
:
4198 adv
= read_sleb128 (data
, & bytes_read
, end
);
4200 state_machine_regs
.line
+= adv
;
4203 case DW_LNS_set_file
:
4204 adv
= read_uleb128 (data
, & bytes_read
, end
);
4206 state_machine_regs
.file
= adv
;
4209 unsigned file
= state_machine_regs
.file
- 1;
4212 if (file_table
== NULL
|| n_files
== 0)
4213 printf (_("\n [Use file table entry %d]\n"), file
);
4215 else if (file
>= n_files
)
4217 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4218 printf (_("\n <over large file table index %u>"), file
);
4220 else if ((dir
= file_table
[file
].directory_index
) == 0)
4221 /* If directory index is 0, that means current directory. */
4222 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4223 else if (directory_table
== NULL
|| n_directories
== 0)
4224 printf (_("\n [Use file %s in directory table entry %d]\n"),
4225 file_table
[file
].name
, dir
);
4227 else if (dir
> n_directories
)
4229 warn (_("directory index %u > number of directories %s\n"),
4230 dir
, dwarf_vmatoa ("u", n_directories
));
4231 printf (_("\n <over large directory table entry %u>\n"), dir
);
4234 printf ("\n%s/%s:\n",
4235 /* The directory index starts counting at 1. */
4236 directory_table
[dir
- 1], file_table
[file
].name
);
4240 case DW_LNS_set_column
:
4241 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4243 state_machine_regs
.column
= uladv
;
4246 case DW_LNS_negate_stmt
:
4247 adv
= state_machine_regs
.is_stmt
;
4249 state_machine_regs
.is_stmt
= adv
;
4252 case DW_LNS_set_basic_block
:
4253 state_machine_regs
.basic_block
= 1;
4256 case DW_LNS_const_add_pc
:
4257 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4258 if (linfo
.li_max_ops_per_insn
== 1)
4260 uladv
*= linfo
.li_min_insn_length
;
4261 state_machine_regs
.address
+= uladv
;
4263 state_machine_regs
.view
= 0;
4268 = ((state_machine_regs
.op_index
+ uladv
)
4269 / linfo
.li_max_ops_per_insn
)
4270 * linfo
.li_min_insn_length
;
4271 state_machine_regs
.address
4273 state_machine_regs
.op_index
4274 = (state_machine_regs
.op_index
+ uladv
)
4275 % linfo
.li_max_ops_per_insn
;
4277 state_machine_regs
.view
= 0;
4281 case DW_LNS_fixed_advance_pc
:
4282 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4283 state_machine_regs
.address
+= uladv
;
4284 state_machine_regs
.op_index
= 0;
4285 /* Do NOT reset view. */
4288 case DW_LNS_set_prologue_end
:
4291 case DW_LNS_set_epilogue_begin
:
4294 case DW_LNS_set_isa
:
4295 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4297 printf (_(" Set ISA to %lu\n"), uladv
);
4301 printf (_(" Unknown opcode %d with operands: "), op_code
);
4303 if (standard_opcodes
!= NULL
)
4304 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4306 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
4308 i
== 1 ? "" : ", ");
4315 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4316 to the DWARF address/line matrix. */
4317 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4318 || (xop
== DW_LNS_copy
))
4320 const unsigned int MAX_FILENAME_LENGTH
= 35;
4322 char *newFileName
= NULL
;
4323 size_t fileNameLength
;
4327 unsigned indx
= state_machine_regs
.file
- 1;
4329 if (indx
>= n_files
)
4331 warn (_("corrupt file index %u encountered\n"), indx
);
4332 fileName
= _("<corrupt>");
4335 fileName
= (char *) file_table
[indx
].name
;
4338 fileName
= _("<unknown>");
4340 fileNameLength
= strlen (fileName
);
4342 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4344 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4345 /* Truncate file name */
4346 strncpy (newFileName
,
4347 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4348 MAX_FILENAME_LENGTH
+ 1);
4352 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4353 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4356 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4358 if (linfo
.li_max_ops_per_insn
== 1)
4359 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4360 newFileName
, state_machine_regs
.line
,
4361 state_machine_regs
.address
);
4363 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4364 newFileName
, state_machine_regs
.line
,
4365 state_machine_regs
.address
,
4366 state_machine_regs
.op_index
);
4370 if (linfo
.li_max_ops_per_insn
== 1)
4371 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
4372 newFileName
, state_machine_regs
.line
,
4373 state_machine_regs
.address
);
4375 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4376 newFileName
, state_machine_regs
.line
,
4377 state_machine_regs
.address
,
4378 state_machine_regs
.op_index
);
4381 if (state_machine_regs
.view
)
4382 printf (" %6u\n", state_machine_regs
.view
);
4385 state_machine_regs
.view
++;
4387 if (xop
== -DW_LNE_end_sequence
)
4389 reset_state_machine (linfo
.li_default_is_stmt
);
4404 if (directory_table
)
4406 free (directory_table
);
4407 directory_table
= NULL
;
4418 display_debug_lines (struct dwarf_section
*section
, void *file
)
4420 unsigned char *data
= section
->start
;
4421 unsigned char *end
= data
+ section
->size
;
4423 int retValDecoded
= 1;
4425 if (do_debug_lines
== 0)
4426 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
4428 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
4429 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
4431 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
4432 retValDecoded
= display_debug_lines_decoded (section
, data
, end
, file
);
4434 if (!retValRaw
|| !retValDecoded
)
4441 find_debug_info_for_offset (unsigned long offset
)
4445 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4448 for (i
= 0; i
< num_debug_info_entries
; i
++)
4449 if (debug_information
[i
].cu_offset
== offset
)
4450 return debug_information
+ i
;
4456 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
4458 /* See gdb/gdb-index.h. */
4459 static const char * const kinds
[] =
4471 return _ (kinds
[kind
]);
4475 display_debug_pubnames_worker (struct dwarf_section
*section
,
4476 void *file ATTRIBUTE_UNUSED
,
4479 DWARF2_Internal_PubNames names
;
4480 unsigned char *start
= section
->start
;
4481 unsigned char *end
= start
+ section
->size
;
4483 /* It does not matter if this load fails,
4484 we test for that later on. */
4485 load_debug_info (file
);
4487 printf (_("Contents of the %s section:\n\n"), section
->name
);
4491 unsigned char *data
;
4494 unsigned int offset_size
, initial_length_size
;
4498 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
4499 if (names
.pn_length
== 0xffffffff)
4501 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
4503 initial_length_size
= 12;
4508 initial_length_size
= 4;
4511 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
4512 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
4514 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4515 && num_debug_info_entries
> 0
4516 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
4517 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4518 (unsigned long) names
.pn_offset
, section
->name
);
4520 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
4522 adr
= start
+ names
.pn_length
+ initial_length_size
;
4523 /* PR 17531: file: 7615b6b2. */
4524 if ((dwarf_signed_vma
) names
.pn_length
< 0
4525 /* PR 17531: file: a5dbeaa7. */
4528 warn (_("Negative length for public name: 0x%lx\n"), (long) names
.pn_length
);
4534 printf (_(" Length: %ld\n"),
4535 (long) names
.pn_length
);
4536 printf (_(" Version: %d\n"),
4538 printf (_(" Offset into .debug_info section: 0x%lx\n"),
4539 (unsigned long) names
.pn_offset
);
4540 printf (_(" Size of area in .debug_info section: %ld\n"),
4541 (long) names
.pn_size
);
4543 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
4545 static int warned
= 0;
4549 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
4557 printf (_("\n Offset Kind Name\n"));
4559 printf (_("\n Offset\tName\n"));
4563 bfd_size_type maxprint
;
4565 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
4569 data
+= offset_size
;
4572 maxprint
= (end
- data
) - 1;
4576 unsigned int kind_data
;
4577 gdb_index_symbol_kind kind
;
4578 const char *kind_name
;
4581 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
4584 /* GCC computes the kind as the upper byte in the CU index
4585 word, and then right shifts it by the CU index size.
4586 Left shift KIND to where the gdb-index.h accessor macros
4588 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
4589 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
4590 kind_name
= get_gdb_index_symbol_kind_name (kind
);
4591 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
4592 printf (" %-6lx %s,%-10s %.*s\n",
4593 (unsigned long) offset
, is_static
? _("s") : _("g"),
4594 kind_name
, (int) maxprint
, data
);
4597 printf (" %-6lx\t%.*s\n",
4598 (unsigned long) offset
, (int) maxprint
, data
);
4600 data
+= strnlen ((char *) data
, maxprint
) + 1;
4605 while (offset
!= 0);
4613 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
4615 return display_debug_pubnames_worker (section
, file
, 0);
4619 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
4621 return display_debug_pubnames_worker (section
, file
, 1);
4625 display_debug_macinfo (struct dwarf_section
*section
,
4626 void *file ATTRIBUTE_UNUSED
)
4628 unsigned char *start
= section
->start
;
4629 unsigned char *end
= start
+ section
->size
;
4630 unsigned char *curr
= start
;
4631 unsigned int bytes_read
;
4632 enum dwarf_macinfo_record_type op
;
4634 printf (_("Contents of the %s section:\n\n"), section
->name
);
4638 unsigned int lineno
;
4639 const unsigned char *string
;
4641 op
= (enum dwarf_macinfo_record_type
) *curr
;
4646 case DW_MACINFO_start_file
:
4648 unsigned int filenum
;
4650 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4652 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
4655 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
4660 case DW_MACINFO_end_file
:
4661 printf (_(" DW_MACINFO_end_file\n"));
4664 case DW_MACINFO_define
:
4665 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4668 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4669 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
4673 case DW_MACINFO_undef
:
4674 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4677 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4678 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
4682 case DW_MACINFO_vendor_ext
:
4684 unsigned int constant
;
4686 constant
= read_uleb128 (curr
, & bytes_read
, end
);
4689 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4690 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
4700 /* Given LINE_OFFSET into the .debug_line section, attempt to return
4701 filename and dirname corresponding to file name table entry with index
4702 FILEIDX. Return NULL on failure. */
4704 static unsigned char *
4705 get_line_filename_and_dirname (dwarf_vma line_offset
,
4707 unsigned char **dir_name
)
4709 struct dwarf_section
*section
= &debug_displays
[line
].section
;
4710 unsigned char *hdrptr
, *dirtable
, *file_name
;
4711 unsigned int offset_size
, initial_length_size
;
4712 unsigned int version
, opcode_base
, bytes_read
;
4713 dwarf_vma length
, diridx
;
4714 const unsigned char * end
;
4717 if (section
->start
== NULL
4718 || line_offset
>= section
->size
4722 hdrptr
= section
->start
+ line_offset
;
4723 end
= section
->start
+ section
->size
;
4725 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
4726 if (length
== 0xffffffff)
4728 /* This section is 64-bit DWARF 3. */
4729 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
4731 initial_length_size
= 12;
4736 initial_length_size
= 4;
4738 if (length
+ initial_length_size
> section
->size
)
4741 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
4742 if (version
!= 2 && version
!= 3 && version
!= 4)
4744 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
4746 hdrptr
++; /* Skip max_ops_per_insn. */
4747 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
4749 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
4750 if (opcode_base
== 0)
4753 hdrptr
+= opcode_base
- 1;
4758 /* Skip over dirname table. */
4759 while (*hdrptr
!= '\0')
4761 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4765 hdrptr
++; /* Skip the NUL at the end of the table. */
4767 /* Now skip over preceding filename table entries. */
4768 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
4770 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4771 read_uleb128 (hdrptr
, &bytes_read
, end
);
4772 hdrptr
+= bytes_read
;
4773 read_uleb128 (hdrptr
, &bytes_read
, end
);
4774 hdrptr
+= bytes_read
;
4775 read_uleb128 (hdrptr
, &bytes_read
, end
);
4776 hdrptr
+= bytes_read
;
4778 if (hdrptr
>= end
|| *hdrptr
== '\0')
4782 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4785 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
4788 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
4789 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
4790 if (dirtable
>= end
|| *dirtable
== '\0')
4792 *dir_name
= dirtable
;
4797 display_debug_macro (struct dwarf_section
*section
,
4800 unsigned char *start
= section
->start
;
4801 unsigned char *end
= start
+ section
->size
;
4802 unsigned char *curr
= start
;
4803 unsigned char *extended_op_buf
[256];
4804 unsigned int bytes_read
;
4806 load_debug_section (str
, file
);
4807 load_debug_section (line
, file
);
4809 printf (_("Contents of the %s section:\n\n"), section
->name
);
4813 unsigned int lineno
, version
, flags
;
4814 unsigned int offset_size
= 4;
4815 const unsigned char *string
;
4816 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
4817 unsigned char **extended_ops
= NULL
;
4819 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
4820 if (version
!= 4 && version
!= 5)
4822 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
4827 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
4830 printf (_(" Offset: 0x%lx\n"),
4831 (unsigned long) sec_offset
);
4832 printf (_(" Version: %d\n"), version
);
4833 printf (_(" Offset size: %d\n"), offset_size
);
4836 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
4837 printf (_(" Offset into .debug_line: 0x%lx\n"),
4838 (unsigned long) line_offset
);
4842 unsigned int i
, count
, op
;
4845 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
4847 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
4848 extended_ops
= extended_op_buf
;
4851 printf (_(" Extension opcode arguments:\n"));
4852 for (i
= 0; i
< count
; i
++)
4854 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4855 extended_ops
[op
] = curr
;
4856 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
4859 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
4862 printf (_(" DW_MACRO_%02x arguments: "), op
);
4863 for (n
= 0; n
< nargs
; n
++)
4867 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
4868 printf ("%s%s", get_FORM_name (form
),
4869 n
== nargs
- 1 ? "\n" : ", ");
4879 case DW_FORM_block1
:
4880 case DW_FORM_block2
:
4881 case DW_FORM_block4
:
4883 case DW_FORM_string
:
4885 case DW_FORM_sec_offset
:
4888 error (_("Invalid extension opcode form %s\n"),
4889 get_FORM_name (form
));
4905 error (_(".debug_macro section not zero terminated\n"));
4909 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4915 case DW_MACRO_start_file
:
4917 unsigned int filenum
;
4918 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4920 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4922 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4925 if ((flags
& 2) == 0)
4926 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
4929 = get_line_filename_and_dirname (line_offset
, filenum
,
4931 if (file_name
== NULL
)
4932 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
4935 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4937 dir_name
!= NULL
? (const char *) dir_name
: "",
4938 dir_name
!= NULL
? "/" : "", file_name
);
4942 case DW_MACRO_end_file
:
4943 printf (_(" DW_MACRO_end_file\n"));
4946 case DW_MACRO_define
:
4947 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4950 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4951 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
4955 case DW_MACRO_undef
:
4956 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4959 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4960 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
4964 case DW_MACRO_define_strp
:
4965 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4967 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4968 string
= fetch_indirect_string (offset
);
4969 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
4973 case DW_MACRO_undef_strp
:
4974 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4976 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4977 string
= fetch_indirect_string (offset
);
4978 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
4982 case DW_MACRO_import
:
4983 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4984 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
4985 (unsigned long) offset
);
4988 case DW_MACRO_define_sup
:
4989 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4991 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4992 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
4993 lineno
, (unsigned long) offset
);
4996 case DW_MACRO_undef_sup
:
4997 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4999 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5000 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
5001 lineno
, (unsigned long) offset
);
5004 case DW_MACRO_import_sup
:
5005 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5006 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5007 (unsigned long) offset
);
5011 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5013 error (_(" Unknown macro opcode %02x seen\n"), op
);
5018 /* Skip over unhandled opcodes. */
5020 unsigned char *desc
= extended_ops
[op
];
5021 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
5025 printf (_(" DW_MACRO_%02x\n"), op
);
5028 printf (_(" DW_MACRO_%02x -"), op
);
5029 for (n
= 0; n
< nargs
; n
++)
5033 /* DW_FORM_implicit_const is not expected here. */
5034 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5036 = read_and_display_attr_value (0, val
, 0,
5037 curr
, end
, 0, 0, offset_size
,
5038 version
, NULL
, 0, NULL
,
5056 display_debug_abbrev (struct dwarf_section
*section
,
5057 void *file ATTRIBUTE_UNUSED
)
5059 abbrev_entry
*entry
;
5060 unsigned char *start
= section
->start
;
5061 unsigned char *end
= start
+ section
->size
;
5063 printf (_("Contents of the %s section:\n\n"), section
->name
);
5067 unsigned char *last
;
5072 start
= process_abbrev_section (start
, end
);
5074 if (first_abbrev
== NULL
)
5077 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5079 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5083 printf (" %ld %s [%s]\n",
5085 get_TAG_name (entry
->tag
),
5086 entry
->children
? _("has children") : _("no children"));
5088 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5090 printf (" %-18s %s",
5091 get_AT_name (attr
->attribute
),
5092 get_FORM_name (attr
->form
));
5093 if (attr
->form
== DW_FORM_implicit_const
)
5094 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5106 /* Return true when ADDR is the maximum address, when addresses are
5107 POINTER_SIZE bytes long. */
5110 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5112 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5113 return ((addr
& mask
) == mask
);
5116 /* Display a view pair list starting at *VSTART_PTR and ending at
5117 VLISTEND within SECTION. */
5120 display_view_pair_list (struct dwarf_section
*section
,
5121 unsigned char **vstart_ptr
,
5122 unsigned int debug_info_entry
,
5123 unsigned char *vlistend
)
5125 unsigned char *vstart
= *vstart_ptr
;
5126 unsigned char *section_end
= section
->start
+ section
->size
;
5127 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5129 if (vlistend
< section_end
)
5130 section_end
= vlistend
;
5134 while (vstart
< section_end
)
5136 dwarf_vma off
= vstart
- section
->start
;
5137 dwarf_vma vbegin
, vend
;
5139 unsigned int bytes_read
;
5140 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5141 vstart
+= bytes_read
;
5142 if (vstart
== section_end
)
5144 vstart
-= bytes_read
;
5148 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5149 vstart
+= bytes_read
;
5151 printf (" %8.8lx ", (unsigned long) off
);
5153 print_dwarf_view (vbegin
, pointer_size
, 1);
5154 print_dwarf_view (vend
, pointer_size
, 1);
5155 printf (_("location view pair\n"));
5159 *vstart_ptr
= vstart
;
5162 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5165 display_loc_list (struct dwarf_section
*section
,
5166 unsigned char **start_ptr
,
5167 unsigned int debug_info_entry
,
5169 dwarf_vma base_address
,
5170 unsigned char **vstart_ptr
,
5173 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5174 unsigned char *section_end
= section
->start
+ section
->size
;
5175 unsigned long cu_offset
;
5176 unsigned int pointer_size
;
5177 unsigned int offset_size
;
5182 unsigned short length
;
5183 int need_frame_base
;
5185 if (debug_info_entry
>= num_debug_info_entries
)
5187 warn (_("No debug information available for loc lists of entry: %u\n"),
5192 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5193 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5194 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5195 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5197 if (pointer_size
< 2 || pointer_size
> 8)
5199 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5200 pointer_size
, debug_info_entry
);
5206 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5207 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5209 if (start
+ 2 * pointer_size
> section_end
)
5211 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5212 (unsigned long) offset
);
5216 printf (" %8.8lx ", (unsigned long) off
);
5218 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5219 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5221 if (begin
== 0 && end
== 0)
5223 /* PR 18374: In a object file we can have a location list that
5224 starts with a begin and end of 0 because there are relocations
5225 that need to be applied to the addresses. Actually applying
5226 the relocations now does not help as they will probably resolve
5227 to 0, since the object file has not been fully linked. Real
5228 end of list markers will not have any relocations against them. */
5229 if (! reloc_at (section
, off
)
5230 && ! reloc_at (section
, off
+ pointer_size
))
5232 printf (_("<End of list>\n"));
5237 /* Check base address specifiers. */
5238 if (is_max_address (begin
, pointer_size
)
5239 && !is_max_address (end
, pointer_size
))
5242 print_dwarf_vma (begin
, pointer_size
);
5243 print_dwarf_vma (end
, pointer_size
);
5244 printf (_("(base address)\n"));
5250 unsigned int bytes_read
;
5252 off
= offset
+ (vstart
- *start_ptr
);
5254 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5255 vstart
+= bytes_read
;
5256 print_dwarf_view (vbegin
, pointer_size
, 1);
5258 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5259 vstart
+= bytes_read
;
5260 print_dwarf_view (vend
, pointer_size
, 1);
5262 printf (_("views at %8.8lx for:\n %*s "),
5263 (unsigned long) off
, 8, "");
5266 if (start
+ 2 > section_end
)
5268 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5269 (unsigned long) offset
);
5273 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5275 if (start
+ length
> section_end
)
5277 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5278 (unsigned long) offset
);
5282 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5283 print_dwarf_vma (end
+ base_address
, pointer_size
);
5286 need_frame_base
= decode_location_expression (start
,
5291 cu_offset
, section
);
5294 if (need_frame_base
&& !has_frame_base
)
5295 printf (_(" [without DW_AT_frame_base]"));
5297 if (begin
== end
&& vbegin
== vend
)
5298 fputs (_(" (start == end)"), stdout
);
5299 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5300 fputs (_(" (start > end)"), stdout
);
5308 *vstart_ptr
= vstart
;
5311 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5314 display_loclists_list (struct dwarf_section
*section
,
5315 unsigned char **start_ptr
,
5316 unsigned int debug_info_entry
,
5318 dwarf_vma base_address
,
5319 unsigned char **vstart_ptr
,
5322 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5323 unsigned char *section_end
= section
->start
+ section
->size
;
5324 unsigned long cu_offset
;
5325 unsigned int pointer_size
;
5326 unsigned int offset_size
;
5328 unsigned int bytes_read
;
5330 /* Initialize it due to a false compiler warning. */
5331 dwarf_vma begin
= -1, vbegin
= -1;
5332 dwarf_vma end
= -1, vend
= -1;
5334 int need_frame_base
;
5336 if (debug_info_entry
>= num_debug_info_entries
)
5338 warn (_("No debug information available for "
5339 "loclists lists of entry: %u\n"),
5344 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5345 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5346 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5347 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5349 if (pointer_size
< 2 || pointer_size
> 8)
5351 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5352 pointer_size
, debug_info_entry
);
5358 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5359 enum dwarf_location_list_entry_type llet
;
5361 if (start
+ 1 > section_end
)
5363 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5364 (unsigned long) offset
);
5368 printf (" %8.8lx ", (unsigned long) off
);
5370 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5372 if (vstart
&& llet
== DW_LLE_offset_pair
)
5374 off
= offset
+ (vstart
- *start_ptr
);
5376 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5377 vstart
+= bytes_read
;
5378 print_dwarf_view (vbegin
, pointer_size
, 1);
5380 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5381 vstart
+= bytes_read
;
5382 print_dwarf_view (vend
, pointer_size
, 1);
5384 printf (_("views at %8.8lx for:\n %*s "),
5385 (unsigned long) off
, 8, "");
5390 case DW_LLE_end_of_list
:
5391 printf (_("<End of list>\n"));
5393 case DW_LLE_offset_pair
:
5394 begin
= read_uleb128 (start
, &bytes_read
, section_end
);
5395 start
+= bytes_read
;
5396 end
= read_uleb128 (start
, &bytes_read
, section_end
);
5397 start
+= bytes_read
;
5399 case DW_LLE_base_address
:
5400 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
5402 print_dwarf_vma (base_address
, pointer_size
);
5403 printf (_("(base address)\n"));
5405 #ifdef DW_LLE_view_pair
5406 case DW_LLE_view_pair
:
5408 printf (_("View pair entry in loclist with locviews attribute\n"));
5409 vbegin
= read_uleb128 (start
, &bytes_read
, section_end
);
5410 start
+= bytes_read
;
5411 print_dwarf_view (vbegin
, pointer_size
, 1);
5413 vend
= read_uleb128 (start
, &bytes_read
, section_end
);
5414 start
+= bytes_read
;
5415 print_dwarf_view (vend
, pointer_size
, 1);
5417 printf (_("views for:\n"));
5421 error (_("Invalid location list entry type %d\n"), llet
);
5424 if (llet
== DW_LLE_end_of_list
)
5426 if (llet
!= DW_LLE_offset_pair
)
5429 if (start
+ 2 > section_end
)
5431 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5432 (unsigned long) offset
);
5436 length
= read_uleb128 (start
, &bytes_read
, section_end
);
5437 start
+= bytes_read
;
5439 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5440 print_dwarf_vma (end
+ base_address
, pointer_size
);
5443 need_frame_base
= decode_location_expression (start
,
5448 cu_offset
, section
);
5451 if (need_frame_base
&& !has_frame_base
)
5452 printf (_(" [without DW_AT_frame_base]"));
5454 if (begin
== end
&& vbegin
== vend
)
5455 fputs (_(" (start == end)"), stdout
);
5456 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5457 fputs (_(" (start > end)"), stdout
);
5465 if (vbegin
!= vm1
|| vend
!= vm1
)
5466 printf (_("Trailing view pair not used in a range"));
5469 *vstart_ptr
= vstart
;
5472 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
5473 right-adjusted in a field of length LEN, and followed by a space. */
5476 print_addr_index (unsigned int idx
, unsigned int len
)
5478 static char buf
[15];
5479 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
5480 printf ("%*s ", len
, buf
);
5483 /* Display a location list from a .dwo section. It uses address indexes rather
5484 than embedded addresses. This code closely follows display_loc_list, but the
5485 two are sufficiently different that combining things is very ugly. */
5488 display_loc_list_dwo (struct dwarf_section
*section
,
5489 unsigned char **start_ptr
,
5490 unsigned int debug_info_entry
,
5492 unsigned char **vstart_ptr
,
5495 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5496 unsigned char *section_end
= section
->start
+ section
->size
;
5497 unsigned long cu_offset
;
5498 unsigned int pointer_size
;
5499 unsigned int offset_size
;
5502 unsigned short length
;
5503 int need_frame_base
;
5505 unsigned int bytes_read
;
5507 if (debug_info_entry
>= num_debug_info_entries
)
5509 warn (_("No debug information for loc lists of entry: %u\n"),
5514 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5515 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5516 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5517 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5519 if (pointer_size
< 2 || pointer_size
> 8)
5521 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5522 pointer_size
, debug_info_entry
);
5528 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
5530 if (start
>= section_end
)
5532 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5533 (unsigned long) offset
);
5537 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
5550 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
5552 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5553 vstart
+= bytes_read
;
5554 print_dwarf_view (view
, 8, 1);
5556 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5557 vstart
+= bytes_read
;
5558 print_dwarf_view (view
, 8, 1);
5560 printf (_("views at %8.8lx for:\n %*s "),
5561 (unsigned long) off
, 8, "");
5569 case 0: /* A terminating entry. */
5571 *vstart_ptr
= vstart
;
5572 printf (_("<End of list>\n"));
5574 case 1: /* A base-address entry. */
5575 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5576 start
+= bytes_read
;
5577 print_addr_index (idx
, 8);
5578 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
5579 printf (_("(base address selection entry)\n"));
5581 case 2: /* A start/end entry. */
5582 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5583 start
+= bytes_read
;
5584 print_addr_index (idx
, 8);
5585 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5586 start
+= bytes_read
;
5587 print_addr_index (idx
, 8);
5589 case 3: /* A start/length entry. */
5590 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5591 start
+= bytes_read
;
5592 print_addr_index (idx
, 8);
5593 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5594 printf ("%08x ", idx
);
5596 case 4: /* An offset pair entry. */
5597 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5598 printf ("%08x ", idx
);
5599 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5600 printf ("%08x ", idx
);
5603 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
5605 *vstart_ptr
= vstart
;
5609 if (start
+ 2 > section_end
)
5611 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5612 (unsigned long) offset
);
5616 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5617 if (start
+ length
> section_end
)
5619 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5620 (unsigned long) offset
);
5625 need_frame_base
= decode_location_expression (start
,
5630 cu_offset
, section
);
5633 if (need_frame_base
&& !has_frame_base
)
5634 printf (_(" [without DW_AT_frame_base]"));
5642 *vstart_ptr
= vstart
;
5645 /* Sort array of indexes in ascending order of loc_offsets[idx] and
5648 static dwarf_vma
*loc_offsets
, *loc_views
;
5651 loc_offsets_compar (const void *ap
, const void *bp
)
5653 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
5654 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
5656 int ret
= (a
> b
) - (b
> a
);
5660 a
= loc_views
[*(const unsigned int *) ap
];
5661 b
= loc_views
[*(const unsigned int *) bp
];
5663 ret
= (a
> b
) - (b
> a
);
5669 display_debug_loc (struct dwarf_section
*section
, void *file
)
5671 unsigned char *start
= section
->start
, *vstart
= NULL
;
5672 unsigned long bytes
;
5673 unsigned char *section_begin
= start
;
5674 unsigned int num_loc_list
= 0;
5675 unsigned long last_offset
= 0;
5676 unsigned long last_view
= 0;
5677 unsigned int first
= 0;
5680 int seen_first_offset
= 0;
5681 int locs_sorted
= 1;
5682 unsigned char *next
= start
, *vnext
= vstart
;
5683 unsigned int *array
= NULL
;
5684 const char *suffix
= strrchr (section
->name
, '.');
5686 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
5687 dwarf_vma expected_start
= 0;
5689 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
5692 bytes
= section
->size
;
5696 printf (_("\nThe %s section is empty.\n"), section
->name
);
5702 unsigned char *hdrptr
= section_begin
;
5703 dwarf_vma ll_length
;
5704 unsigned short ll_version
;
5705 unsigned char *end
= section_begin
+ section
->size
;
5706 unsigned char address_size
, segment_selector_size
;
5707 uint32_t offset_entry_count
;
5709 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
5710 if (ll_length
== 0xffffffff)
5711 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
5713 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
5714 if (ll_version
!= 5)
5716 warn (_("The %s section contains corrupt or "
5717 "unsupported version number: %d.\n"),
5718 section
->name
, ll_version
);
5722 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
5724 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
5725 if (segment_selector_size
!= 0)
5727 warn (_("The %s section contains "
5728 "unsupported segment selector size: %d.\n"),
5729 section
->name
, segment_selector_size
);
5733 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
5734 if (offset_entry_count
!= 0)
5736 warn (_("The %s section contains "
5737 "unsupported offset entry count: %d.\n"),
5738 section
->name
, offset_entry_count
);
5742 expected_start
= hdrptr
- section_begin
;
5745 if (load_debug_info (file
) == 0)
5747 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5752 /* Check the order of location list in .debug_info section. If
5753 offsets of location lists are in the ascending order, we can
5754 use `debug_information' directly. */
5755 for (i
= 0; i
< num_debug_info_entries
; i
++)
5759 num
= debug_information
[i
].num_loc_offsets
;
5760 if (num
> num_loc_list
)
5763 /* Check if we can use `debug_information' directly. */
5764 if (locs_sorted
&& num
!= 0)
5766 if (!seen_first_offset
)
5768 /* This is the first location list. */
5769 last_offset
= debug_information
[i
].loc_offsets
[0];
5770 last_view
= debug_information
[i
].loc_views
[0];
5772 seen_first_offset
= 1;
5778 for (; j
< num
; j
++)
5781 debug_information
[i
].loc_offsets
[j
]
5782 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
5783 && last_view
> debug_information
[i
].loc_views
[j
]))
5788 last_offset
= debug_information
[i
].loc_offsets
[j
];
5789 last_view
= debug_information
[i
].loc_views
[j
];
5794 if (!seen_first_offset
)
5795 error (_("No location lists in .debug_info section!\n"));
5797 if (debug_information
[first
].num_loc_offsets
> 0
5798 && debug_information
[first
].loc_offsets
[0] != expected_start
5799 && debug_information
[first
].loc_views
[0] != expected_start
)
5800 warn (_("Location lists in %s section start at 0x%s\n"),
5802 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
5805 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
5806 printf (_("Contents of the %s section:\n\n"), section
->name
);
5807 if (reloc_at (section
, 0))
5808 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
5809 printf (_(" Offset Begin End Expression\n"));
5811 seen_first_offset
= 0;
5812 for (i
= first
; i
< num_debug_info_entries
; i
++)
5814 dwarf_vma offset
, voffset
;
5815 dwarf_vma base_address
;
5821 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
5823 loc_offsets
= debug_information
[i
].loc_offsets
;
5824 loc_views
= debug_information
[i
].loc_views
;
5825 qsort (array
, debug_information
[i
].num_loc_offsets
,
5826 sizeof (*array
), loc_offsets_compar
);
5829 int adjacent_view_loclists
= 1;
5830 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
5832 j
= locs_sorted
? k
: array
[k
];
5834 && (debug_information
[i
].loc_offsets
[locs_sorted
5835 ? k
- 1 : array
[k
- 1]]
5836 == debug_information
[i
].loc_offsets
[j
])
5837 && (debug_information
[i
].loc_views
[locs_sorted
5838 ? k
- 1 : array
[k
- 1]]
5839 == debug_information
[i
].loc_views
[j
]))
5841 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
5842 offset
= debug_information
[i
].loc_offsets
[j
];
5843 next
= section_begin
+ offset
;
5844 voffset
= debug_information
[i
].loc_views
[j
];
5846 vnext
= section_begin
+ voffset
;
5849 base_address
= debug_information
[i
].base_address
;
5851 if (vnext
&& vnext
< next
)
5854 display_view_pair_list (section
, &vstart
, i
, next
);
5859 if (!seen_first_offset
|| !adjacent_view_loclists
)
5860 seen_first_offset
= 1;
5864 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
5865 (unsigned long) (start
- section_begin
),
5866 (unsigned long) offset
);
5867 else if (start
> next
)
5868 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
5869 (unsigned long) (start
- section_begin
),
5870 (unsigned long) offset
);
5875 if (offset
>= bytes
)
5877 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
5878 (unsigned long) offset
);
5882 if (vnext
&& voffset
>= bytes
)
5884 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
5885 (unsigned long) voffset
);
5892 display_loc_list_dwo (section
, &start
, i
, offset
,
5893 &vstart
, has_frame_base
);
5895 display_loc_list (section
, &start
, i
, offset
, base_address
,
5896 &vstart
, has_frame_base
);
5901 warn (_("DWO is not yet supported.\n"));
5903 display_loclists_list (section
, &start
, i
, offset
, base_address
,
5904 &vstart
, has_frame_base
);
5907 /* FIXME: this arrangement is quite simplistic. Nothing
5908 requires locview lists to be adjacent to corresponding
5909 loclists, and a single loclist could be augmented by
5910 different locview lists, and vice-versa, unlikely as it
5911 is that it would make sense to do so. Hopefully we'll
5912 have view pair support built into loclists before we ever
5913 need to address all these possibilities. */
5914 if (adjacent_view_loclists
&& vnext
5915 && vnext
!= start
&& vstart
!= next
)
5917 adjacent_view_loclists
= 0;
5918 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
5921 if (vnext
&& vnext
== start
)
5922 display_view_pair_list (section
, &start
, i
, vstart
);
5926 if (start
< section
->start
+ section
->size
)
5927 warn (_("There are %ld unused bytes at the end of section %s\n"),
5928 (long) (section
->start
+ section
->size
- start
), section
->name
);
5935 display_debug_str (struct dwarf_section
*section
,
5936 void *file ATTRIBUTE_UNUSED
)
5938 unsigned char *start
= section
->start
;
5939 unsigned long bytes
= section
->size
;
5940 dwarf_vma addr
= section
->address
;
5944 printf (_("\nThe %s section is empty.\n"), section
->name
);
5948 printf (_("Contents of the %s section:\n\n"), section
->name
);
5956 lbytes
= (bytes
> 16 ? 16 : bytes
);
5958 printf (" 0x%8.8lx ", (unsigned long) addr
);
5960 for (j
= 0; j
< 16; j
++)
5963 printf ("%2.2x", start
[j
]);
5971 for (j
= 0; j
< lbytes
; j
++)
5974 if (k
>= ' ' && k
< 0x80)
5993 display_debug_info (struct dwarf_section
*section
, void *file
)
5995 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
5999 display_debug_types (struct dwarf_section
*section
, void *file
)
6001 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
6005 display_trace_info (struct dwarf_section
*section
, void *file
)
6007 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
6011 display_debug_aranges (struct dwarf_section
*section
,
6012 void *file ATTRIBUTE_UNUSED
)
6014 unsigned char *start
= section
->start
;
6015 unsigned char *end
= start
+ section
->size
;
6017 printf (_("Contents of the %s section:\n\n"), section
->name
);
6019 /* It does not matter if this load fails,
6020 we test for that later on. */
6021 load_debug_info (file
);
6025 unsigned char *hdrptr
;
6026 DWARF2_Internal_ARange arange
;
6027 unsigned char *addr_ranges
;
6030 unsigned char address_size
;
6032 unsigned int offset_size
;
6033 unsigned int initial_length_size
;
6037 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6038 if (arange
.ar_length
== 0xffffffff)
6040 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6042 initial_length_size
= 12;
6047 initial_length_size
= 4;
6050 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6051 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6053 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6054 && num_debug_info_entries
> 0
6055 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6056 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6057 (unsigned long) arange
.ar_info_offset
, section
->name
);
6059 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6060 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6062 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6064 /* PR 19872: A version number of 0 probably means that there is
6065 padding at the end of the .debug_aranges section. Gold puts
6066 it there when performing an incremental link, for example.
6067 So do not generate a warning in this case. */
6068 if (arange
.ar_version
)
6069 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6073 printf (_(" Length: %ld\n"),
6074 (long) arange
.ar_length
);
6075 printf (_(" Version: %d\n"), arange
.ar_version
);
6076 printf (_(" Offset into .debug_info: 0x%lx\n"),
6077 (unsigned long) arange
.ar_info_offset
);
6078 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6079 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6081 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6083 /* PR 17512: file: 001-108546-0.001:0.1. */
6084 if (address_size
== 0 || address_size
> 8)
6086 error (_("Invalid address size in %s section!\n"),
6091 /* The DWARF spec does not require that the address size be a power
6092 of two, but we do. This will have to change if we ever encounter
6093 an uneven architecture. */
6094 if ((address_size
& (address_size
- 1)) != 0)
6096 warn (_("Pointer size + Segment size is not a power of two.\n"));
6100 if (address_size
> 4)
6101 printf (_("\n Address Length\n"));
6103 printf (_("\n Address Length\n"));
6105 addr_ranges
= hdrptr
;
6107 /* Must pad to an alignment boundary that is twice the address size. */
6108 excess
= (hdrptr
- start
) % (2 * address_size
);
6110 addr_ranges
+= (2 * address_size
) - excess
;
6112 hdrptr
= start
+ arange
.ar_length
+ initial_length_size
;
6113 if (hdrptr
< start
|| hdrptr
> end
)
6115 error (_("Excessive header length: %lx\n"), (long) arange
.ar_length
);
6120 while (addr_ranges
+ 2 * address_size
<= start
)
6122 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6123 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6126 print_dwarf_vma (address
, address_size
);
6127 print_dwarf_vma (length
, address_size
);
6137 /* Comparison function for qsort. */
6139 comp_addr_base (const void * v0
, const void * v1
)
6141 debug_info
* info0
= (debug_info
*) v0
;
6142 debug_info
* info1
= (debug_info
*) v1
;
6143 return info0
->addr_base
- info1
->addr_base
;
6146 /* Display the debug_addr section. */
6148 display_debug_addr (struct dwarf_section
*section
,
6151 debug_info
**debug_addr_info
;
6152 unsigned char *entry
;
6157 if (section
->size
== 0)
6159 printf (_("\nThe %s section is empty.\n"), section
->name
);
6163 if (load_debug_info (file
) == 0)
6165 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6170 printf (_("Contents of the %s section:\n\n"), section
->name
);
6172 /* PR 17531: file: cf38d01b.
6173 We use xcalloc because a corrupt file may not have initialised all of the
6174 fields in the debug_info structure, which means that the sort below might
6175 try to move uninitialised data. */
6176 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6177 sizeof (debug_info
*));
6180 for (i
= 0; i
< num_debug_info_entries
; i
++)
6181 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6183 /* PR 17531: file: cf38d01b. */
6184 if (debug_information
[i
].addr_base
>= section
->size
)
6185 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6186 (unsigned long) debug_information
[i
].addr_base
, i
);
6188 debug_addr_info
[count
++] = debug_information
+ i
;
6191 /* Add a sentinel to make iteration convenient. */
6192 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6193 debug_addr_info
[count
]->addr_base
= section
->size
;
6194 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6196 for (i
= 0; i
< count
; i
++)
6199 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6201 printf (_(" For compilation unit at offset 0x%s:\n"),
6202 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6204 printf (_("\tIndex\tAddress\n"));
6205 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6206 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6210 dwarf_vma base
= byte_get (entry
, address_size
);
6211 printf (_("\t%d:\t"), idx
);
6212 print_dwarf_vma (base
, address_size
);
6214 entry
+= address_size
;
6220 free (debug_addr_info
);
6224 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6226 display_debug_str_offsets (struct dwarf_section
*section
,
6227 void *file ATTRIBUTE_UNUSED
)
6229 if (section
->size
== 0)
6231 printf (_("\nThe %s section is empty.\n"), section
->name
);
6234 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6235 what the offset size is for this section. */
6239 /* Each debug_information[x].range_lists[y] gets this representation for
6240 sorting purposes. */
6244 /* The debug_information[x].range_lists[y] value. */
6245 dwarf_vma ranges_offset
;
6247 /* Original debug_information to find parameters of the data. */
6248 debug_info
*debug_info_p
;
6251 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6254 range_entry_compar (const void *ap
, const void *bp
)
6256 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6257 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6258 const dwarf_vma a
= a_re
->ranges_offset
;
6259 const dwarf_vma b
= b_re
->ranges_offset
;
6261 return (a
> b
) - (b
> a
);
6265 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6266 unsigned int pointer_size
, unsigned long offset
,
6267 unsigned long base_address
)
6269 while (start
< finish
)
6274 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6275 if (start
>= finish
)
6277 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6279 printf (" %8.8lx ", offset
);
6281 if (begin
== 0 && end
== 0)
6283 printf (_("<End of list>\n"));
6287 /* Check base address specifiers. */
6288 if (is_max_address (begin
, pointer_size
)
6289 && !is_max_address (end
, pointer_size
))
6292 print_dwarf_vma (begin
, pointer_size
);
6293 print_dwarf_vma (end
, pointer_size
);
6294 printf ("(base address)\n");
6298 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6299 print_dwarf_vma (end
+ base_address
, pointer_size
);
6302 fputs (_("(start == end)"), stdout
);
6303 else if (begin
> end
)
6304 fputs (_("(start > end)"), stdout
);
6311 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
6312 unsigned int pointer_size
, unsigned long offset
,
6313 unsigned long base_address
)
6315 unsigned char *next
= start
;
6319 unsigned long off
= offset
+ (start
- next
);
6320 enum dwarf_range_list_entry rlet
;
6321 /* Initialize it due to a false compiler warning. */
6322 dwarf_vma begin
= -1, length
, end
= -1;
6323 unsigned int bytes_read
;
6325 if (start
+ 1 > finish
)
6327 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6332 printf (" %8.8lx ", off
);
6334 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
6338 case DW_RLE_end_of_list
:
6339 printf (_("<End of list>\n"));
6341 case DW_RLE_base_address
:
6342 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
6343 print_dwarf_vma (base_address
, pointer_size
);
6344 printf (_("(base address)\n"));
6346 case DW_RLE_start_length
:
6347 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6348 length
= read_uleb128 (start
, &bytes_read
, finish
);
6349 start
+= bytes_read
;
6350 end
= begin
+ length
;
6352 case DW_RLE_offset_pair
:
6353 begin
= read_uleb128 (start
, &bytes_read
, finish
);
6354 start
+= bytes_read
;
6355 end
= read_uleb128 (start
, &bytes_read
, finish
);
6356 start
+= bytes_read
;
6358 case DW_RLE_start_end
:
6359 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6360 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6363 error (_("Invalid range list entry type %d\n"), rlet
);
6364 rlet
= DW_RLE_end_of_list
;
6367 if (rlet
== DW_RLE_end_of_list
)
6369 if (rlet
== DW_RLE_base_address
)
6372 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6373 print_dwarf_vma (end
+ base_address
, pointer_size
);
6376 fputs (_("(start == end)"), stdout
);
6377 else if (begin
> end
)
6378 fputs (_("(start > end)"), stdout
);
6385 display_debug_ranges (struct dwarf_section
*section
,
6386 void *file ATTRIBUTE_UNUSED
)
6388 unsigned char *start
= section
->start
;
6389 unsigned char *last_start
= start
;
6390 unsigned long bytes
= section
->size
;
6391 unsigned char *section_begin
= start
;
6392 unsigned char *finish
= start
+ bytes
;
6393 unsigned int num_range_list
, i
;
6394 struct range_entry
*range_entries
, *range_entry_fill
;
6395 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
6396 /* Initialize it due to a false compiler warning. */
6397 unsigned char address_size
= 0;
6401 printf (_("\nThe %s section is empty.\n"), section
->name
);
6407 dwarf_vma initial_length
;
6408 unsigned int initial_length_size
;
6409 unsigned char segment_selector_size
;
6410 unsigned int offset_size
, offset_entry_count
;
6411 unsigned short version
;
6413 /* Get and check the length of the block. */
6414 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
6416 if (initial_length
== 0xffffffff)
6418 /* This section is 64-bit DWARF 3. */
6419 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
6421 initial_length_size
= 12;
6426 initial_length_size
= 4;
6429 if (initial_length
+ initial_length_size
> section
->size
)
6431 /* If the length field has a relocation against it, then we should
6432 not complain if it is inaccurate (and probably negative).
6433 It is copied from .debug_line handling code. */
6434 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
6436 initial_length
= (finish
- start
) - initial_length_size
;
6440 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6441 (long) initial_length
);
6446 /* Get and check the version number. */
6447 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
6451 warn (_("Only DWARF version 5 debug_rnglists info "
6452 "is currently supported.\n"));
6456 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
6458 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
6459 if (segment_selector_size
!= 0)
6461 warn (_("The %s section contains "
6462 "unsupported segment selector size: %d.\n"),
6463 section
->name
, segment_selector_size
);
6467 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
6468 if (offset_entry_count
!= 0)
6470 warn (_("The %s section contains "
6471 "unsupported offset entry count: %u.\n"),
6472 section
->name
, offset_entry_count
);
6477 if (load_debug_info (file
) == 0)
6479 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6485 for (i
= 0; i
< num_debug_info_entries
; i
++)
6486 num_range_list
+= debug_information
[i
].num_range_lists
;
6488 if (num_range_list
== 0)
6490 /* This can happen when the file was compiled with -gsplit-debug
6491 which removes references to range lists from the primary .o file. */
6492 printf (_("No range lists in .debug_info section.\n"));
6496 range_entries
= (struct range_entry
*)
6497 xmalloc (sizeof (*range_entries
) * num_range_list
);
6498 range_entry_fill
= range_entries
;
6500 for (i
= 0; i
< num_debug_info_entries
; i
++)
6502 debug_info
*debug_info_p
= &debug_information
[i
];
6505 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
6507 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
6508 range_entry_fill
->debug_info_p
= debug_info_p
;
6513 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
6514 range_entry_compar
);
6516 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
6517 warn (_("Range lists in %s section start at 0x%lx\n"),
6518 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
6520 printf (_("Contents of the %s section:\n\n"), section
->name
);
6521 printf (_(" Offset Begin End\n"));
6523 for (i
= 0; i
< num_range_list
; i
++)
6525 struct range_entry
*range_entry
= &range_entries
[i
];
6526 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
6527 unsigned int pointer_size
;
6529 unsigned char *next
;
6530 dwarf_vma base_address
;
6532 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
6533 offset
= range_entry
->ranges_offset
;
6534 next
= section_begin
+ offset
;
6535 base_address
= debug_info_p
->base_address
;
6537 /* PR 17512: file: 001-101485-0.001:0.1. */
6538 if (pointer_size
< 2 || pointer_size
> 8)
6540 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
6541 pointer_size
, (unsigned long) offset
);
6545 if (dwarf_check
!= 0 && i
> 0)
6548 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
6549 (unsigned long) (start
- section_begin
),
6550 (unsigned long) (next
- section_begin
), section
->name
);
6551 else if (start
> next
)
6553 if (next
== last_start
)
6555 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
6556 (unsigned long) (start
- section_begin
),
6557 (unsigned long) (next
- section_begin
), section
->name
);
6563 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
6564 (start
, finish
, pointer_size
, offset
, base_address
);
6568 free (range_entries
);
6573 typedef struct Frame_Chunk
6575 struct Frame_Chunk
*next
;
6576 unsigned char *chunk_start
;
6578 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6579 short int *col_type
;
6582 unsigned int code_factor
;
6587 dwarf_vma cfa_offset
;
6589 unsigned char fde_encoding
;
6590 unsigned char cfa_exp
;
6591 unsigned char ptr_size
;
6592 unsigned char segment_size
;
6596 static const char *const *dwarf_regnames
;
6597 static unsigned int dwarf_regnames_count
;
6599 /* A marker for a col_type that means this column was never referenced
6600 in the frame info. */
6601 #define DW_CFA_unreferenced (-1)
6603 /* Return 0 if no more space is needed, 1 if more space is needed,
6604 -1 for invalid reg. */
6607 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
6609 unsigned int prev
= fc
->ncols
;
6611 if (reg
< (unsigned int) fc
->ncols
)
6614 if (dwarf_regnames_count
6615 && reg
> dwarf_regnames_count
)
6618 fc
->ncols
= reg
+ 1;
6619 /* PR 17512: file: 10450-2643-0.004.
6620 If reg == -1 then this can happen... */
6624 /* PR 17512: file: 2844a11d. */
6625 if (fc
->ncols
> 1024)
6627 error (_("Unfeasibly large register number: %u\n"), reg
);
6629 /* FIXME: 1024 is an arbitrary limit. Increase it if
6630 we ever encounter a valid binary that exceeds it. */
6634 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
6635 sizeof (short int));
6636 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
6637 /* PR 17512: file:002-10025-0.005. */
6638 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
6640 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
6646 while (prev
< fc
->ncols
)
6648 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
6649 fc
->col_offset
[prev
] = 0;
6655 static const char *const dwarf_regnames_i386
[] =
6657 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6658 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6659 "eip", "eflags", NULL
, /* 8 - 10 */
6660 "st0", "st1", "st2", "st3", /* 11 - 14 */
6661 "st4", "st5", "st6", "st7", /* 15 - 18 */
6662 NULL
, NULL
, /* 19 - 20 */
6663 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
6664 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
6665 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
6666 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
6667 "fcw", "fsw", "mxcsr", /* 37 - 39 */
6668 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
6669 "tr", "ldtr", /* 48 - 49 */
6670 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
6671 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
6672 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
6673 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
6674 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
6675 NULL
, NULL
, NULL
, /* 90 - 92 */
6676 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
6679 static const char *const dwarf_regnames_iamcu
[] =
6681 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6682 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6683 "eip", "eflags", NULL
, /* 8 - 10 */
6684 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
6685 NULL
, NULL
, /* 19 - 20 */
6686 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
6687 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
6688 NULL
, NULL
, NULL
, /* 37 - 39 */
6689 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
6690 "tr", "ldtr", /* 48 - 49 */
6691 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
6692 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
6693 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
6694 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
6695 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
6696 NULL
, NULL
, NULL
, /* 90 - 92 */
6697 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
6701 init_dwarf_regnames_i386 (void)
6703 dwarf_regnames
= dwarf_regnames_i386
;
6704 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
6708 init_dwarf_regnames_iamcu (void)
6710 dwarf_regnames
= dwarf_regnames_iamcu
;
6711 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
6714 static const char *const dwarf_regnames_x86_64
[] =
6716 "rax", "rdx", "rcx", "rbx",
6717 "rsi", "rdi", "rbp", "rsp",
6718 "r8", "r9", "r10", "r11",
6719 "r12", "r13", "r14", "r15",
6721 "xmm0", "xmm1", "xmm2", "xmm3",
6722 "xmm4", "xmm5", "xmm6", "xmm7",
6723 "xmm8", "xmm9", "xmm10", "xmm11",
6724 "xmm12", "xmm13", "xmm14", "xmm15",
6725 "st0", "st1", "st2", "st3",
6726 "st4", "st5", "st6", "st7",
6727 "mm0", "mm1", "mm2", "mm3",
6728 "mm4", "mm5", "mm6", "mm7",
6730 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
6731 "fs.base", "gs.base", NULL
, NULL
,
6733 "mxcsr", "fcw", "fsw",
6734 "xmm16", "xmm17", "xmm18", "xmm19",
6735 "xmm20", "xmm21", "xmm22", "xmm23",
6736 "xmm24", "xmm25", "xmm26", "xmm27",
6737 "xmm28", "xmm29", "xmm30", "xmm31",
6738 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
6739 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
6740 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
6741 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
6742 NULL
, NULL
, NULL
, /* 115 - 117 */
6743 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
6747 init_dwarf_regnames_x86_64 (void)
6749 dwarf_regnames
= dwarf_regnames_x86_64
;
6750 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
6753 static const char *const dwarf_regnames_aarch64
[] =
6755 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
6756 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
6757 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
6758 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
6759 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
6760 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
6761 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
6762 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
6763 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
6764 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
6765 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
6766 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
6770 init_dwarf_regnames_aarch64 (void)
6772 dwarf_regnames
= dwarf_regnames_aarch64
;
6773 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
6776 static const char *const dwarf_regnames_s390
[] =
6778 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
6779 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
6780 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
6781 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
6782 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
6783 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
6784 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
6785 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
6786 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
6789 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
6790 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
6794 init_dwarf_regnames_s390 (void)
6796 dwarf_regnames
= dwarf_regnames_s390
;
6797 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
6801 init_dwarf_regnames (unsigned int e_machine
)
6806 init_dwarf_regnames_i386 ();
6810 init_dwarf_regnames_iamcu ();
6816 init_dwarf_regnames_x86_64 ();
6820 init_dwarf_regnames_aarch64 ();
6824 init_dwarf_regnames_s390 ();
6833 regname (unsigned int regno
, int row
)
6835 static char reg
[64];
6838 && regno
< dwarf_regnames_count
6839 && dwarf_regnames
[regno
] != NULL
)
6842 return dwarf_regnames
[regno
];
6843 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
6844 dwarf_regnames
[regno
]);
6847 snprintf (reg
, sizeof (reg
), "r%d", regno
);
6852 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
6857 if (*max_regs
!= fc
->ncols
)
6858 *max_regs
= fc
->ncols
;
6860 if (*need_col_headers
)
6862 static const char *sloc
= " LOC";
6864 *need_col_headers
= 0;
6866 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
6868 for (r
= 0; r
< *max_regs
; r
++)
6869 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
6874 printf ("%-5s ", regname (r
, 1));
6880 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
6882 strcpy (tmp
, "exp");
6884 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
6885 printf ("%-8s ", tmp
);
6887 for (r
= 0; r
< fc
->ncols
; r
++)
6889 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
6891 switch (fc
->col_type
[r
])
6893 case DW_CFA_undefined
:
6896 case DW_CFA_same_value
:
6900 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
6902 case DW_CFA_val_offset
:
6903 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
6905 case DW_CFA_register
:
6906 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
6908 case DW_CFA_expression
:
6909 strcpy (tmp
, "exp");
6911 case DW_CFA_val_expression
:
6912 strcpy (tmp
, "vexp");
6915 strcpy (tmp
, "n/a");
6918 printf ("%-5s ", tmp
);
6924 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
6926 static unsigned char *
6927 read_cie (unsigned char *start
, unsigned char *end
,
6928 Frame_Chunk
**p_cie
, int *p_version
,
6929 unsigned long *p_aug_len
, unsigned char **p_aug
)
6933 unsigned int length_return
;
6934 unsigned char *augmentation_data
= NULL
;
6935 unsigned long augmentation_data_len
= 0;
6938 /* PR 17512: file: 001-228113-0.004. */
6942 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6943 memset (fc
, 0, sizeof (Frame_Chunk
));
6945 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
6946 fc
->col_offset
= (int *) xmalloc (sizeof (int));
6950 fc
->augmentation
= (char *) start
;
6951 /* PR 17512: file: 001-228113-0.004.
6952 Skip past augmentation name, but avoid running off the end of the data. */
6954 if (* start
++ == '\0')
6958 warn (_("No terminator for augmentation name\n"));
6962 if (strcmp (fc
->augmentation
, "eh") == 0)
6963 start
+= eh_addr_size
;
6967 GET (fc
->ptr_size
, 1);
6968 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
6970 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
6974 GET (fc
->segment_size
, 1);
6975 /* PR 17512: file: e99d2804. */
6976 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
6978 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
6982 eh_addr_size
= fc
->ptr_size
;
6986 fc
->ptr_size
= eh_addr_size
;
6987 fc
->segment_size
= 0;
6989 READ_ULEB (fc
->code_factor
);
6990 READ_SLEB (fc
->data_factor
);
7000 if (fc
->augmentation
[0] == 'z')
7002 READ_ULEB (augmentation_data_len
);
7003 augmentation_data
= start
;
7004 start
+= augmentation_data_len
;
7005 /* PR 17512: file: 11042-2589-0.004. */
7008 warn (_("Augmentation data too long: %#lx, expected at most %#lx\n"),
7009 augmentation_data_len
, (long)((end
- start
) + augmentation_data_len
));
7014 if (augmentation_data_len
)
7018 unsigned char *qend
;
7020 p
= (unsigned char *) fc
->augmentation
+ 1;
7021 q
= augmentation_data
;
7022 qend
= q
+ augmentation_data_len
;
7024 /* PR 17531: file: 015adfaa. */
7027 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len
);
7028 augmentation_data_len
= 0;
7031 while (p
< end
&& q
< augmentation_data
+ augmentation_data_len
)
7036 q
+= 1 + size_of_encoded_value (*q
);
7038 fc
->fde_encoding
= *q
++;
7045 /* Note - it is OK if this loop terminates with q < qend.
7046 Padding may have been inserted to align the end of the CIE. */
7051 *p_version
= version
;
7054 *p_aug_len
= augmentation_data_len
;
7055 *p_aug
= augmentation_data
;
7061 display_debug_frames (struct dwarf_section
*section
,
7062 void *file ATTRIBUTE_UNUSED
)
7064 unsigned char *start
= section
->start
;
7065 unsigned char *end
= start
+ section
->size
;
7066 unsigned char *section_start
= start
;
7067 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
7068 Frame_Chunk
*remembered_state
= 0;
7070 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7071 unsigned int length_return
;
7072 unsigned int max_regs
= 0;
7073 const char *bad_reg
= _("bad register: ");
7074 unsigned int saved_eh_addr_size
= eh_addr_size
;
7076 printf (_("Contents of the %s section:\n"), section
->name
);
7080 unsigned char *saved_start
;
7081 unsigned char *block_end
;
7086 int need_col_headers
= 1;
7087 unsigned char *augmentation_data
= NULL
;
7088 unsigned long augmentation_data_len
= 0;
7089 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7090 unsigned int offset_size
;
7091 unsigned int initial_length_size
;
7092 bfd_boolean all_nops
;
7094 saved_start
= start
;
7096 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7100 printf ("\n%08lx ZERO terminator\n\n",
7101 (unsigned long)(saved_start
- section_start
));
7102 /* Skip any zero terminators that directly follow.
7103 A corrupt section size could have loaded a whole
7104 slew of zero filled memory bytes. eg
7105 PR 17512: file: 070-19381-0.004. */
7106 while (start
< end
&& * start
== 0)
7111 if (length
== 0xffffffff)
7113 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7115 initial_length_size
= 12;
7120 initial_length_size
= 4;
7123 block_end
= saved_start
+ length
+ initial_length_size
;
7124 if (block_end
> end
|| block_end
< start
)
7126 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7127 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7128 (unsigned long) (saved_start
- section_start
));
7132 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7134 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7135 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7140 start
= read_cie (start
, end
, &cie
, &version
,
7141 &augmentation_data_len
, &augmentation_data
);
7142 /* PR 17512: file: 027-135133-0.005. */
7149 fc
->chunk_start
= saved_start
;
7150 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7153 if (frame_need_space (fc
, mreg
) < 0)
7155 if (fc
->fde_encoding
)
7156 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7158 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7159 print_dwarf_vma (length
, fc
->ptr_size
);
7160 print_dwarf_vma (cie_id
, offset_size
);
7162 if (do_debug_frames_interp
)
7164 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7165 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7170 printf (" Version: %d\n", version
);
7171 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7174 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7175 printf (" Segment Size: %u\n", fc
->segment_size
);
7177 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7178 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7179 printf (" Return address column: %d\n", fc
->ra
);
7181 if (augmentation_data_len
)
7185 printf (" Augmentation data: ");
7186 for (i
= 0; i
< augmentation_data_len
; ++i
)
7187 /* FIXME: If do_wide is FALSE, then we should
7188 add carriage returns at 80 columns... */
7189 printf (" %02x", augmentation_data
[i
]);
7197 unsigned char *look_for
;
7198 static Frame_Chunk fde_fc
;
7199 unsigned long segment_selector
;
7203 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7204 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7207 look_for
= section_start
+ cie_id
;
7209 if (look_for
<= saved_start
)
7211 for (cie
= chunks
; cie
; cie
= cie
->next
)
7212 if (cie
->chunk_start
== look_for
)
7217 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7218 if (cie
->chunk_start
== look_for
)
7222 unsigned int off_size
;
7223 unsigned char *cie_scan
;
7225 cie_scan
= look_for
;
7227 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7228 if (length
== 0xffffffff)
7230 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7237 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7240 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7241 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7246 read_cie (cie_scan
, end
, &cie
, &version
,
7247 &augmentation_data_len
, &augmentation_data
);
7248 /* PR 17512: file: 3450-2098-0.004. */
7251 warn (_("Failed to read CIE information\n"));
7254 cie
->next
= forward_refs
;
7256 cie
->chunk_start
= look_for
;
7257 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7260 if (frame_need_space (cie
, mreg
) < 0)
7262 warn (_("Invalid max register\n"));
7265 if (cie
->fde_encoding
)
7267 = size_of_encoded_value (cie
->fde_encoding
);
7274 memset (fc
, 0, sizeof (Frame_Chunk
));
7278 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7279 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7280 (unsigned long) (saved_start
- section_start
));
7282 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7283 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7284 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
7286 warn (_("Invalid max register\n"));
7290 fc
->augmentation
= "";
7291 fc
->fde_encoding
= 0;
7292 fc
->ptr_size
= eh_addr_size
;
7293 fc
->segment_size
= 0;
7297 fc
->ncols
= cie
->ncols
;
7298 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
7299 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
7300 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
7301 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
7302 fc
->augmentation
= cie
->augmentation
;
7303 fc
->ptr_size
= cie
->ptr_size
;
7304 eh_addr_size
= cie
->ptr_size
;
7305 fc
->segment_size
= cie
->segment_size
;
7306 fc
->code_factor
= cie
->code_factor
;
7307 fc
->data_factor
= cie
->data_factor
;
7308 fc
->cfa_reg
= cie
->cfa_reg
;
7309 fc
->cfa_offset
= cie
->cfa_offset
;
7311 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
7313 warn (_("Invalid max register\n"));
7316 fc
->fde_encoding
= cie
->fde_encoding
;
7319 if (fc
->fde_encoding
)
7320 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7322 segment_selector
= 0;
7323 if (fc
->segment_size
)
7325 if (fc
->segment_size
> sizeof (segment_selector
))
7327 /* PR 17512: file: 9e196b3e. */
7328 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
7329 fc
->segment_size
= 4;
7331 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
7334 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
7336 /* FIXME: It appears that sometimes the final pc_range value is
7337 encoded in less than encoded_ptr_size bytes. See the x86_64
7338 run of the "objcopy on compressed debug sections" test for an
7340 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
7342 if (cie
->augmentation
[0] == 'z')
7344 READ_ULEB (augmentation_data_len
);
7345 augmentation_data
= start
;
7346 start
+= augmentation_data_len
;
7347 /* PR 17512: file: 722-8446-0.004. */
7348 if (start
>= end
|| ((signed long) augmentation_data_len
) < 0)
7350 warn (_("Corrupt augmentation data length: %lx\n"),
7351 augmentation_data_len
);
7353 augmentation_data
= NULL
;
7354 augmentation_data_len
= 0;
7358 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
7359 (unsigned long)(saved_start
- section_start
),
7360 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
7361 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7362 (unsigned long)(cie
->chunk_start
- section_start
));
7364 if (fc
->segment_size
)
7365 printf ("%04lx:", segment_selector
);
7368 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
7369 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
7371 if (! do_debug_frames_interp
&& augmentation_data_len
)
7375 printf (" Augmentation data: ");
7376 for (i
= 0; i
< augmentation_data_len
; ++i
)
7377 printf (" %02x", augmentation_data
[i
]);
7383 /* At this point, fc is the current chunk, cie (if any) is set, and
7384 we're about to interpret instructions for the chunk. */
7385 /* ??? At present we need to do this always, since this sizes the
7386 fc->col_type and fc->col_offset arrays, which we write into always.
7387 We should probably split the interpreted and non-interpreted bits
7388 into two different routines, since there's so much that doesn't
7389 really overlap between them. */
7390 if (1 || do_debug_frames_interp
)
7392 /* Start by making a pass over the chunk, allocating storage
7393 and taking note of what registers are used. */
7394 unsigned char *tmp
= start
;
7396 while (start
< block_end
)
7398 unsigned int reg
, op
, opa
;
7400 unsigned char * new_start
;
7407 /* Warning: if you add any more cases to this switch, be
7408 sure to add them to the corresponding switch below. */
7411 case DW_CFA_advance_loc
:
7415 if (frame_need_space (fc
, opa
) >= 0)
7416 fc
->col_type
[opa
] = DW_CFA_undefined
;
7418 case DW_CFA_restore
:
7419 if (frame_need_space (fc
, opa
) >= 0)
7420 fc
->col_type
[opa
] = DW_CFA_undefined
;
7422 case DW_CFA_set_loc
:
7423 start
+= encoded_ptr_size
;
7425 case DW_CFA_advance_loc1
:
7428 case DW_CFA_advance_loc2
:
7431 case DW_CFA_advance_loc4
:
7434 case DW_CFA_offset_extended
:
7435 case DW_CFA_val_offset
:
7438 if (frame_need_space (fc
, reg
) >= 0)
7439 fc
->col_type
[reg
] = DW_CFA_undefined
;
7441 case DW_CFA_restore_extended
:
7443 if (frame_need_space (fc
, reg
) >= 0)
7444 fc
->col_type
[reg
] = DW_CFA_undefined
;
7446 case DW_CFA_undefined
:
7448 if (frame_need_space (fc
, reg
) >= 0)
7449 fc
->col_type
[reg
] = DW_CFA_undefined
;
7451 case DW_CFA_same_value
:
7453 if (frame_need_space (fc
, reg
) >= 0)
7454 fc
->col_type
[reg
] = DW_CFA_undefined
;
7456 case DW_CFA_register
:
7459 if (frame_need_space (fc
, reg
) >= 0)
7460 fc
->col_type
[reg
] = DW_CFA_undefined
;
7462 case DW_CFA_def_cfa
:
7466 case DW_CFA_def_cfa_register
:
7469 case DW_CFA_def_cfa_offset
:
7472 case DW_CFA_def_cfa_expression
:
7474 new_start
= start
+ temp
;
7475 if (new_start
< start
)
7477 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
7483 case DW_CFA_expression
:
7484 case DW_CFA_val_expression
:
7487 new_start
= start
+ temp
;
7488 if (new_start
< start
)
7490 /* PR 17512: file:306-192417-0.005. */
7491 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
7496 if (frame_need_space (fc
, reg
) >= 0)
7497 fc
->col_type
[reg
] = DW_CFA_undefined
;
7499 case DW_CFA_offset_extended_sf
:
7500 case DW_CFA_val_offset_sf
:
7503 if (frame_need_space (fc
, reg
) >= 0)
7504 fc
->col_type
[reg
] = DW_CFA_undefined
;
7506 case DW_CFA_def_cfa_sf
:
7510 case DW_CFA_def_cfa_offset_sf
:
7513 case DW_CFA_MIPS_advance_loc8
:
7516 case DW_CFA_GNU_args_size
:
7519 case DW_CFA_GNU_negative_offset_extended
:
7522 if (frame_need_space (fc
, reg
) >= 0)
7523 fc
->col_type
[reg
] = DW_CFA_undefined
;
7534 /* Now we know what registers are used, make a second pass over
7535 the chunk, this time actually printing out the info. */
7537 while (start
< block_end
)
7539 unsigned char * tmp
;
7541 unsigned long ul
, roffs
;
7542 /* Note: It is tempting to use an unsigned long for 'reg' but there
7543 are various functions, notably frame_space_needed() that assume that
7544 reg is an unsigned int. */
7549 const char *reg_prefix
= "";
7556 /* Make a note if something other than DW_CFA_nop happens. */
7557 if (op
!= DW_CFA_nop
)
7560 /* Warning: if you add any more cases to this switch, be
7561 sure to add them to the corresponding switch above. */
7564 case DW_CFA_advance_loc
:
7565 if (do_debug_frames_interp
)
7566 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7568 printf (" DW_CFA_advance_loc: %d to %s\n",
7569 opa
* fc
->code_factor
,
7570 dwarf_vmatoa_1 (NULL
,
7571 fc
->pc_begin
+ opa
* fc
->code_factor
,
7573 fc
->pc_begin
+= opa
* fc
->code_factor
;
7578 if (opa
>= (unsigned int) fc
->ncols
)
7579 reg_prefix
= bad_reg
;
7580 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7581 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
7582 reg_prefix
, regname (opa
, 0),
7583 roffs
* fc
->data_factor
);
7584 if (*reg_prefix
== '\0')
7586 fc
->col_type
[opa
] = DW_CFA_offset
;
7587 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
7591 case DW_CFA_restore
:
7592 if (opa
>= (unsigned int) fc
->ncols
)
7593 reg_prefix
= bad_reg
;
7594 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7595 printf (" DW_CFA_restore: %s%s\n",
7596 reg_prefix
, regname (opa
, 0));
7597 if (*reg_prefix
!= '\0')
7600 if (opa
>= (unsigned int) cie
->ncols
7601 || (do_debug_frames_interp
7602 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
7604 fc
->col_type
[opa
] = DW_CFA_undefined
;
7605 fc
->col_offset
[opa
] = 0;
7609 fc
->col_type
[opa
] = cie
->col_type
[opa
];
7610 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
7614 case DW_CFA_set_loc
:
7615 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
7616 if (do_debug_frames_interp
)
7617 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7619 printf (" DW_CFA_set_loc: %s\n",
7620 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
7624 case DW_CFA_advance_loc1
:
7625 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
7626 if (do_debug_frames_interp
)
7627 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7629 printf (" DW_CFA_advance_loc1: %ld to %s\n",
7630 (unsigned long) (ofs
* fc
->code_factor
),
7631 dwarf_vmatoa_1 (NULL
,
7632 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7634 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7637 case DW_CFA_advance_loc2
:
7638 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
7639 if (do_debug_frames_interp
)
7640 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7642 printf (" DW_CFA_advance_loc2: %ld to %s\n",
7643 (unsigned long) (ofs
* fc
->code_factor
),
7644 dwarf_vmatoa_1 (NULL
,
7645 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7647 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7650 case DW_CFA_advance_loc4
:
7651 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
7652 if (do_debug_frames_interp
)
7653 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7655 printf (" DW_CFA_advance_loc4: %ld to %s\n",
7656 (unsigned long) (ofs
* fc
->code_factor
),
7657 dwarf_vmatoa_1 (NULL
,
7658 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7660 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7663 case DW_CFA_offset_extended
:
7666 if (reg
>= (unsigned int) fc
->ncols
)
7667 reg_prefix
= bad_reg
;
7668 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7669 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
7670 reg_prefix
, regname (reg
, 0),
7671 roffs
* fc
->data_factor
);
7672 if (*reg_prefix
== '\0')
7674 fc
->col_type
[reg
] = DW_CFA_offset
;
7675 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
7679 case DW_CFA_val_offset
:
7682 if (reg
>= (unsigned int) fc
->ncols
)
7683 reg_prefix
= bad_reg
;
7684 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7685 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
7686 reg_prefix
, regname (reg
, 0),
7687 roffs
* fc
->data_factor
);
7688 if (*reg_prefix
== '\0')
7690 fc
->col_type
[reg
] = DW_CFA_val_offset
;
7691 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
7695 case DW_CFA_restore_extended
:
7697 if (reg
>= (unsigned int) fc
->ncols
)
7698 reg_prefix
= bad_reg
;
7699 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7700 printf (" DW_CFA_restore_extended: %s%s\n",
7701 reg_prefix
, regname (reg
, 0));
7702 if (*reg_prefix
!= '\0')
7705 if (reg
>= (unsigned int) cie
->ncols
)
7707 fc
->col_type
[reg
] = DW_CFA_undefined
;
7708 fc
->col_offset
[reg
] = 0;
7712 fc
->col_type
[reg
] = cie
->col_type
[reg
];
7713 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
7717 case DW_CFA_undefined
:
7719 if (reg
>= (unsigned int) fc
->ncols
)
7720 reg_prefix
= bad_reg
;
7721 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7722 printf (" DW_CFA_undefined: %s%s\n",
7723 reg_prefix
, regname (reg
, 0));
7724 if (*reg_prefix
== '\0')
7726 fc
->col_type
[reg
] = DW_CFA_undefined
;
7727 fc
->col_offset
[reg
] = 0;
7731 case DW_CFA_same_value
:
7733 if (reg
>= (unsigned int) fc
->ncols
)
7734 reg_prefix
= bad_reg
;
7735 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7736 printf (" DW_CFA_same_value: %s%s\n",
7737 reg_prefix
, regname (reg
, 0));
7738 if (*reg_prefix
== '\0')
7740 fc
->col_type
[reg
] = DW_CFA_same_value
;
7741 fc
->col_offset
[reg
] = 0;
7745 case DW_CFA_register
:
7748 if (reg
>= (unsigned int) fc
->ncols
)
7749 reg_prefix
= bad_reg
;
7750 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7752 printf (" DW_CFA_register: %s%s in ",
7753 reg_prefix
, regname (reg
, 0));
7754 puts (regname (roffs
, 0));
7756 if (*reg_prefix
== '\0')
7758 fc
->col_type
[reg
] = DW_CFA_register
;
7759 fc
->col_offset
[reg
] = roffs
;
7763 case DW_CFA_remember_state
:
7764 if (! do_debug_frames_interp
)
7765 printf (" DW_CFA_remember_state\n");
7766 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7767 rs
->cfa_offset
= fc
->cfa_offset
;
7768 rs
->cfa_reg
= fc
->cfa_reg
;
7770 rs
->cfa_exp
= fc
->cfa_exp
;
7771 rs
->ncols
= fc
->ncols
;
7772 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
7773 sizeof (* rs
->col_type
));
7774 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
7775 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
7776 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
7777 rs
->next
= remembered_state
;
7778 remembered_state
= rs
;
7781 case DW_CFA_restore_state
:
7782 if (! do_debug_frames_interp
)
7783 printf (" DW_CFA_restore_state\n");
7784 rs
= remembered_state
;
7787 remembered_state
= rs
->next
;
7788 fc
->cfa_offset
= rs
->cfa_offset
;
7789 fc
->cfa_reg
= rs
->cfa_reg
;
7791 fc
->cfa_exp
= rs
->cfa_exp
;
7792 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
7794 warn (_("Invalid column number in saved frame state\n"));
7798 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
7799 memcpy (fc
->col_offset
, rs
->col_offset
,
7800 rs
->ncols
* sizeof (* rs
->col_offset
));
7801 free (rs
->col_type
);
7802 free (rs
->col_offset
);
7805 else if (do_debug_frames_interp
)
7806 printf ("Mismatched DW_CFA_restore_state\n");
7809 case DW_CFA_def_cfa
:
7810 READ_SLEB (fc
->cfa_reg
);
7811 READ_ULEB (fc
->cfa_offset
);
7813 if (! do_debug_frames_interp
)
7814 printf (" DW_CFA_def_cfa: %s ofs %d\n",
7815 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
7818 case DW_CFA_def_cfa_register
:
7819 READ_SLEB (fc
->cfa_reg
);
7821 if (! do_debug_frames_interp
)
7822 printf (" DW_CFA_def_cfa_register: %s\n",
7823 regname (fc
->cfa_reg
, 0));
7826 case DW_CFA_def_cfa_offset
:
7827 READ_ULEB (fc
->cfa_offset
);
7828 if (! do_debug_frames_interp
)
7829 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
7833 if (! do_debug_frames_interp
)
7834 printf (" DW_CFA_nop\n");
7837 case DW_CFA_def_cfa_expression
:
7839 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
7841 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
7844 if (! do_debug_frames_interp
)
7846 printf (" DW_CFA_def_cfa_expression (");
7847 decode_location_expression (start
, eh_addr_size
, 0, -1,
7855 case DW_CFA_expression
:
7858 if (reg
>= (unsigned int) fc
->ncols
)
7859 reg_prefix
= bad_reg
;
7860 /* PR 17512: file: 069-133014-0.006. */
7861 /* PR 17512: file: 98c02eb4. */
7863 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
7865 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
7868 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7870 printf (" DW_CFA_expression: %s%s (",
7871 reg_prefix
, regname (reg
, 0));
7872 decode_location_expression (start
, eh_addr_size
, 0, -1,
7876 if (*reg_prefix
== '\0')
7877 fc
->col_type
[reg
] = DW_CFA_expression
;
7881 case DW_CFA_val_expression
:
7884 if (reg
>= (unsigned int) fc
->ncols
)
7885 reg_prefix
= bad_reg
;
7887 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
7889 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
7892 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7894 printf (" DW_CFA_val_expression: %s%s (",
7895 reg_prefix
, regname (reg
, 0));
7896 decode_location_expression (start
, eh_addr_size
, 0, -1,
7900 if (*reg_prefix
== '\0')
7901 fc
->col_type
[reg
] = DW_CFA_val_expression
;
7905 case DW_CFA_offset_extended_sf
:
7908 if (frame_need_space (fc
, reg
) < 0)
7909 reg_prefix
= bad_reg
;
7910 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7911 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
7912 reg_prefix
, regname (reg
, 0),
7913 (long)(l
* fc
->data_factor
));
7914 if (*reg_prefix
== '\0')
7916 fc
->col_type
[reg
] = DW_CFA_offset
;
7917 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
7921 case DW_CFA_val_offset_sf
:
7924 if (frame_need_space (fc
, reg
) < 0)
7925 reg_prefix
= bad_reg
;
7926 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7927 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
7928 reg_prefix
, regname (reg
, 0),
7929 (long)(l
* fc
->data_factor
));
7930 if (*reg_prefix
== '\0')
7932 fc
->col_type
[reg
] = DW_CFA_val_offset
;
7933 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
7937 case DW_CFA_def_cfa_sf
:
7938 READ_SLEB (fc
->cfa_reg
);
7939 READ_ULEB (fc
->cfa_offset
);
7940 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
7942 if (! do_debug_frames_interp
)
7943 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
7944 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
7947 case DW_CFA_def_cfa_offset_sf
:
7948 READ_ULEB (fc
->cfa_offset
);
7949 fc
->cfa_offset
*= fc
->data_factor
;
7950 if (! do_debug_frames_interp
)
7951 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
7954 case DW_CFA_MIPS_advance_loc8
:
7955 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
7956 if (do_debug_frames_interp
)
7957 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7959 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
7960 (unsigned long) (ofs
* fc
->code_factor
),
7961 dwarf_vmatoa_1 (NULL
,
7962 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7964 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7967 case DW_CFA_GNU_window_save
:
7968 if (! do_debug_frames_interp
)
7969 printf (" DW_CFA_GNU_window_save\n");
7972 case DW_CFA_GNU_args_size
:
7974 if (! do_debug_frames_interp
)
7975 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
7978 case DW_CFA_GNU_negative_offset_extended
:
7982 if (frame_need_space (fc
, reg
) < 0)
7983 reg_prefix
= bad_reg
;
7984 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7985 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
7986 reg_prefix
, regname (reg
, 0),
7987 (long)(l
* fc
->data_factor
));
7988 if (*reg_prefix
== '\0')
7990 fc
->col_type
[reg
] = DW_CFA_offset
;
7991 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
7996 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
7997 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
7999 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
8004 /* Interpret the CFA - as long as it is not completely full of NOPs. */
8005 if (do_debug_frames_interp
&& ! all_nops
)
8006 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8009 eh_addr_size
= saved_eh_addr_size
;
8020 display_debug_names (struct dwarf_section
*section
, void *file
)
8022 unsigned char *hdrptr
= section
->start
;
8023 dwarf_vma unit_length
;
8024 unsigned char *unit_start
;
8025 const unsigned char *const section_end
= section
->start
+ section
->size
;
8026 unsigned char *unit_end
;
8028 printf (_("Contents of the %s section:\n"), section
->name
);
8030 load_debug_section (str
, file
);
8032 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8034 unsigned int offset_size
;
8035 uint16_t dwarf_version
, padding
;
8036 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8037 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8038 uint32_t augmentation_string_size
;
8041 unit_start
= hdrptr
;
8043 /* Get and check the length of the block. */
8044 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8046 if (unit_length
== 0xffffffff)
8048 /* This section is 64-bit DWARF. */
8049 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8054 unit_end
= hdrptr
+ unit_length
;
8056 if ((hdrptr
- section
->start
) + unit_length
> section
->size
)
8058 warn (_("The length field (0x%lx) for unit 0x%lx in the debug_names "
8059 "header is wrong - the section is too small\n"),
8060 (long) unit_length
, (long) (unit_start
- section
->start
));
8064 /* Get and check the version number. */
8065 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8066 printf (_("Version %ld\n"), (long) dwarf_version
);
8068 /* Prior versions did not exist, and future versions may not be
8069 backwards compatible. */
8070 if (dwarf_version
!= 5)
8072 warn (_("Only DWARF version 5 .debug_names "
8073 "is currently supported.\n"));
8077 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8079 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8082 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8083 if (comp_unit_count
== 0)
8084 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8086 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8087 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8088 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8089 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8090 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8092 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8093 if (augmentation_string_size
% 4 != 0)
8095 warn (_("Augmentation string length %u must be rounded up "
8096 "to a multiple of 4 in .debug_names.\n"),
8097 augmentation_string_size
);
8098 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8100 printf (_("Augmentation string:"));
8101 for (i
= 0; i
< augmentation_string_size
; i
++)
8105 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8106 printf (" %02x", uc
);
8111 printf (_("CU table:\n"));
8112 for (i
= 0; i
< comp_unit_count
; i
++)
8116 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8117 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8121 printf (_("TU table:\n"));
8122 for (i
= 0; i
< local_type_unit_count
; i
++)
8126 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8127 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8131 printf (_("Foreign TU table:\n"));
8132 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8136 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8137 printf (_("[%3u] "), i
);
8138 print_dwarf_vma (signature
, 8);
8143 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8144 hdrptr
+= bucket_count
* sizeof (uint32_t);
8145 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8146 hdrptr
+= name_count
* sizeof (uint32_t);
8147 unsigned char *const name_table_string_offsets
= hdrptr
;
8148 hdrptr
+= name_count
* offset_size
;
8149 unsigned char *const name_table_entry_offsets
= hdrptr
;
8150 hdrptr
+= name_count
* offset_size
;
8151 unsigned char *const abbrev_table
= hdrptr
;
8152 hdrptr
+= abbrev_table_size
;
8153 const unsigned char *const abbrev_table_end
= hdrptr
;
8154 unsigned char *const entry_pool
= hdrptr
;
8155 if (hdrptr
> unit_end
)
8157 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8158 "for unit 0x%lx in the debug_names\n"),
8159 (long) (hdrptr
- section
->start
),
8160 (long) (unit_end
- section
->start
),
8161 (long) (unit_start
- section
->start
));
8165 size_t buckets_filled
= 0;
8167 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8169 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8174 printf (_("Used %zu of %lu buckets.\n"), buckets_filled
,
8175 (unsigned long) bucket_count
);
8177 uint32_t hash_prev
= 0;
8178 size_t hash_clash_count
= 0;
8179 size_t longest_clash
= 0;
8180 size_t this_length
= 0;
8182 for (hashi
= 0; hashi
< name_count
; hashi
++)
8184 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8188 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8192 longest_clash
= MAX (longest_clash
, this_length
);
8197 hash_prev
= hash_this
;
8199 printf (_("Out of %lu items there are %zu bucket clashes"
8200 " (longest of %zu entries).\n"),
8201 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
8202 assert (name_count
== buckets_filled
+ hash_clash_count
);
8204 struct abbrev_lookup_entry
8206 dwarf_vma abbrev_tag
;
8207 unsigned char *abbrev_lookup_ptr
;
8209 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
8210 size_t abbrev_lookup_used
= 0;
8211 size_t abbrev_lookup_allocated
= 0;
8213 unsigned char *abbrevptr
= abbrev_table
;
8216 unsigned int bytes_read
;
8217 const dwarf_vma abbrev_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8219 abbrevptr
+= bytes_read
;
8220 if (abbrev_tag
== 0)
8222 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
8224 abbrev_lookup_allocated
= MAX (0x100,
8225 abbrev_lookup_allocated
* 2);
8226 abbrev_lookup
= xrealloc (abbrev_lookup
,
8227 (abbrev_lookup_allocated
8228 * sizeof (*abbrev_lookup
)));
8230 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
8231 struct abbrev_lookup_entry
*entry
;
8232 for (entry
= abbrev_lookup
;
8233 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8235 if (entry
->abbrev_tag
== abbrev_tag
)
8237 warn (_("Duplicate abbreviation tag %lu "
8238 "in unit 0x%lx in the debug_names\n"),
8239 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
8242 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
8243 entry
->abbrev_tag
= abbrev_tag
;
8244 entry
->abbrev_lookup_ptr
= abbrevptr
;
8246 /* Skip DWARF tag. */
8247 read_uleb128 (abbrevptr
, &bytes_read
, abbrev_table_end
);
8248 abbrevptr
+= bytes_read
;
8251 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8254 abbrevptr
+= bytes_read
;
8255 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8257 abbrevptr
+= bytes_read
;
8258 if (xindex
== 0 && form
== 0)
8263 printf (_("\nSymbol table:\n"));
8265 for (namei
= 0; namei
< name_count
; ++namei
)
8267 uint64_t string_offset
, entry_offset
;
8269 SAFE_BYTE_GET (string_offset
,
8270 name_table_string_offsets
+ namei
* offset_size
,
8271 offset_size
, unit_end
);
8272 SAFE_BYTE_GET (entry_offset
,
8273 name_table_entry_offsets
+ namei
* offset_size
,
8274 offset_size
, unit_end
);
8276 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
8277 fetch_indirect_string (string_offset
));
8279 unsigned char *entryptr
= entry_pool
+ entry_offset
;
8281 // We need to scan first whether there is a single or multiple
8282 // entries. TAGNO is -2 for the first entry, it is -1 for the
8283 // initial tag read of the second entry, then it becomes 0 for the
8284 // first entry for real printing etc.
8286 /* Initialize it due to a false compiler warning. */
8287 dwarf_vma second_abbrev_tag
= -1;
8290 unsigned int bytes_read
;
8291 const dwarf_vma abbrev_tag
= read_uleb128 (entryptr
, &bytes_read
,
8293 entryptr
+= bytes_read
;
8296 second_abbrev_tag
= abbrev_tag
;
8298 entryptr
= entry_pool
+ entry_offset
;
8301 if (abbrev_tag
== 0)
8305 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
8306 (unsigned long) abbrev_tag
);
8308 const struct abbrev_lookup_entry
*entry
;
8309 for (entry
= abbrev_lookup
;
8310 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8312 if (entry
->abbrev_tag
== abbrev_tag
)
8314 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
8316 warn (_("Undefined abbreviation tag %lu "
8317 "in unit 0x%lx in the debug_names\n"),
8319 (long) (unit_start
- section
->start
));
8322 abbrevptr
= entry
->abbrev_lookup_ptr
;
8323 const dwarf_vma dwarf_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8325 abbrevptr
+= bytes_read
;
8327 printf (" %s", get_TAG_name (dwarf_tag
));
8330 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8333 abbrevptr
+= bytes_read
;
8334 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8336 abbrevptr
+= bytes_read
;
8337 if (xindex
== 0 && form
== 0)
8341 printf (" %s", get_IDX_name (xindex
));
8342 entryptr
= read_and_display_attr_value (0, form
, 0, entryptr
,
8345 dwarf_version
, NULL
,
8352 printf (_(" <no entries>"));
8356 free (abbrev_lookup
);
8363 display_gdb_index (struct dwarf_section
*section
,
8364 void *file ATTRIBUTE_UNUSED
)
8366 unsigned char *start
= section
->start
;
8368 uint32_t cu_list_offset
, tu_list_offset
;
8369 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
8370 unsigned int cu_list_elements
, tu_list_elements
;
8371 unsigned int address_table_size
, symbol_table_slots
;
8372 unsigned char *cu_list
, *tu_list
;
8373 unsigned char *address_table
, *symbol_table
, *constant_pool
;
8376 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
8378 printf (_("Contents of the %s section:\n"), section
->name
);
8380 if (section
->size
< 6 * sizeof (uint32_t))
8382 warn (_("Truncated header in the %s section.\n"), section
->name
);
8386 version
= byte_get_little_endian (start
, 4);
8387 printf (_("Version %ld\n"), (long) version
);
8389 /* Prior versions are obsolete, and future versions may not be
8390 backwards compatible. */
8391 if (version
< 3 || version
> 8)
8393 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
8397 warn (_("The address table data in version 3 may be wrong.\n"));
8399 warn (_("Version 4 does not support case insensitive lookups.\n"));
8401 warn (_("Version 5 does not include inlined functions.\n"));
8403 warn (_("Version 6 does not include symbol attributes.\n"));
8404 /* Version 7 indices generated by Gold have bad type unit references,
8405 PR binutils/15021. But we don't know if the index was generated by
8406 Gold or not, so to avoid worrying users with gdb-generated indices
8407 we say nothing for version 7 here. */
8409 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
8410 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
8411 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
8412 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
8413 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
8415 if (cu_list_offset
> section
->size
8416 || tu_list_offset
> section
->size
8417 || address_table_offset
> section
->size
8418 || symbol_table_offset
> section
->size
8419 || constant_pool_offset
> section
->size
)
8421 warn (_("Corrupt header in the %s section.\n"), section
->name
);
8425 /* PR 17531: file: 418d0a8a. */
8426 if (tu_list_offset
< cu_list_offset
)
8428 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
8429 tu_list_offset
, cu_list_offset
);
8433 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
8435 if (address_table_offset
< tu_list_offset
)
8437 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
8438 address_table_offset
, tu_list_offset
);
8442 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
8444 /* PR 17531: file: 18a47d3d. */
8445 if (symbol_table_offset
< address_table_offset
)
8447 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
8448 symbol_table_offset
, address_table_offset
);
8452 address_table_size
= symbol_table_offset
- address_table_offset
;
8454 if (constant_pool_offset
< symbol_table_offset
)
8456 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
8457 constant_pool_offset
, symbol_table_offset
);
8461 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
8463 cu_list
= start
+ cu_list_offset
;
8464 tu_list
= start
+ tu_list_offset
;
8465 address_table
= start
+ address_table_offset
;
8466 symbol_table
= start
+ symbol_table_offset
;
8467 constant_pool
= start
+ constant_pool_offset
;
8469 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
8471 warn (_("Address table extends beyond end of section.\n"));
8475 printf (_("\nCU table:\n"));
8476 for (i
= 0; i
< cu_list_elements
; i
+= 2)
8478 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
8479 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
8481 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
8482 (unsigned long) cu_offset
,
8483 (unsigned long) (cu_offset
+ cu_length
- 1));
8486 printf (_("\nTU table:\n"));
8487 for (i
= 0; i
< tu_list_elements
; i
+= 3)
8489 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
8490 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
8491 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
8493 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
8494 (unsigned long) tu_offset
,
8495 (unsigned long) type_offset
);
8496 print_dwarf_vma (signature
, 8);
8500 printf (_("\nAddress table:\n"));
8501 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
8504 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
8505 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
8506 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
8508 print_dwarf_vma (low
, 8);
8509 print_dwarf_vma (high
, 8);
8510 printf (_("%lu\n"), (unsigned long) cu_index
);
8513 printf (_("\nSymbol table:\n"));
8514 for (i
= 0; i
< symbol_table_slots
; ++i
)
8516 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
8517 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
8518 uint32_t num_cus
, cu
;
8520 if (name_offset
!= 0
8521 || cu_vector_offset
!= 0)
8524 unsigned char * adr
;
8526 adr
= constant_pool
+ name_offset
;
8527 /* PR 17531: file: 5b7b07ad. */
8528 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
8530 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
8531 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
8535 printf ("[%3u] %.*s:", i
,
8536 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
8537 constant_pool
+ name_offset
);
8539 adr
= constant_pool
+ cu_vector_offset
;
8540 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
8542 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
8543 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
8544 cu_vector_offset
, i
);
8548 num_cus
= byte_get_little_endian (adr
, 4);
8550 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
8551 if (num_cus
* 4 < num_cus
8552 || adr
>= section
->start
+ section
->size
8553 || adr
< constant_pool
)
8555 printf ("<invalid number of CUs: %d>\n", num_cus
);
8556 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
8564 for (j
= 0; j
< num_cus
; ++j
)
8567 gdb_index_symbol_kind kind
;
8569 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
8570 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
8571 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
8572 cu
= GDB_INDEX_CU_VALUE (cu
);
8573 /* Convert to TU number if it's for a type unit. */
8574 if (cu
>= cu_list_elements
/ 2)
8575 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
8576 (unsigned long) (cu
- cu_list_elements
/ 2));
8578 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
8580 printf (" [%s, %s]",
8581 is_static
? _("static") : _("global"),
8582 get_gdb_index_symbol_kind_name (kind
));
8594 /* Pre-allocate enough space for the CU/TU sets needed. */
8597 prealloc_cu_tu_list (unsigned int nshndx
)
8599 if (shndx_pool
== NULL
)
8601 shndx_pool_size
= nshndx
;
8602 shndx_pool_used
= 0;
8603 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
8604 sizeof (unsigned int));
8608 shndx_pool_size
= shndx_pool_used
+ nshndx
;
8609 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
8610 sizeof (unsigned int));
8615 add_shndx_to_cu_tu_entry (unsigned int shndx
)
8617 if (shndx_pool_used
>= shndx_pool_size
)
8619 error (_("Internal error: out of space in the shndx pool.\n"));
8622 shndx_pool
[shndx_pool_used
++] = shndx
;
8626 end_cu_tu_entry (void)
8628 if (shndx_pool_used
>= shndx_pool_size
)
8630 error (_("Internal error: out of space in the shndx pool.\n"));
8633 shndx_pool
[shndx_pool_used
++] = 0;
8636 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
8639 get_DW_SECT_short_name (unsigned int dw_sect
)
8641 static char buf
[16];
8649 case DW_SECT_ABBREV
:
8655 case DW_SECT_STR_OFFSETS
:
8657 case DW_SECT_MACINFO
:
8665 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
8669 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
8670 These sections are extensions for Fission.
8671 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
8674 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
8676 unsigned char *phdr
= section
->start
;
8677 unsigned char *limit
= phdr
+ section
->size
;
8678 unsigned char *phash
;
8679 unsigned char *pindex
;
8680 unsigned char *ppool
;
8681 unsigned int version
;
8682 unsigned int ncols
= 0;
8684 unsigned int nslots
;
8687 dwarf_vma signature_high
;
8688 dwarf_vma signature_low
;
8691 /* PR 17512: file: 002-168123-0.004. */
8694 warn (_("Section %s is empty\n"), section
->name
);
8697 /* PR 17512: file: 002-376-0.004. */
8698 if (section
->size
< 24)
8700 warn (_("Section %s is too small to contain a CU/TU header\n"),
8705 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
8707 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
8708 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
8709 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
8712 pindex
= phash
+ nslots
* 8;
8713 ppool
= pindex
+ nslots
* 4;
8715 /* PR 17531: file: 45d69832. */
8716 if (pindex
< phash
|| ppool
< phdr
|| (pindex
== phash
&& nslots
!= 0))
8718 warn (_("Section %s is too small for %d slots\n"),
8719 section
->name
, nslots
);
8725 printf (_("Contents of the %s section:\n\n"), section
->name
);
8726 printf (_(" Version: %d\n"), version
);
8728 printf (_(" Number of columns: %d\n"), ncols
);
8729 printf (_(" Number of used entries: %d\n"), nused
);
8730 printf (_(" Number of slots: %d\n\n"), nslots
);
8733 if (ppool
> limit
|| ppool
< phdr
)
8735 warn (_("Section %s too small for %d hash table entries\n"),
8736 section
->name
, nslots
);
8743 prealloc_cu_tu_list ((limit
- ppool
) / 4);
8744 for (i
= 0; i
< nslots
; i
++)
8746 unsigned char *shndx_list
;
8749 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
8750 if (signature_high
!= 0 || signature_low
!= 0)
8752 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
8753 shndx_list
= ppool
+ j
* 4;
8754 /* PR 17531: file: 705e010d. */
8755 if (shndx_list
< ppool
)
8757 warn (_("Section index pool located before start of section\n"));
8762 printf (_(" [%3d] Signature: 0x%s Sections: "),
8763 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
8764 buf
, sizeof (buf
)));
8767 if (shndx_list
>= limit
)
8769 warn (_("Section %s too small for shndx pool\n"),
8773 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
8777 printf (" %d", shndx
);
8779 add_shndx_to_cu_tu_entry (shndx
);
8791 else if (version
== 2)
8794 unsigned int dw_sect
;
8795 unsigned char *ph
= phash
;
8796 unsigned char *pi
= pindex
;
8797 unsigned char *poffsets
= ppool
+ ncols
* 4;
8798 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
8799 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
8800 bfd_boolean is_tu_index
;
8801 struct cu_tu_set
*this_set
= NULL
;
8803 unsigned char *prow
;
8805 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
8807 /* PR 17531: file: 0dd159bf.
8808 Check for wraparound with an overlarge ncols value. */
8809 if (poffsets
< ppool
|| (unsigned int) ((poffsets
- ppool
) / 4) != ncols
)
8811 warn (_("Overlarge number of columns: %x\n"), ncols
);
8817 warn (_("Section %s too small for offset and size tables\n"),
8824 printf (_(" Offset table\n"));
8825 printf (" slot %-16s ",
8826 is_tu_index
? _("signature") : _("dwo_id"));
8833 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
8839 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
8846 for (j
= 0; j
< ncols
; j
++)
8848 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
8849 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
8854 for (i
= 0; i
< nslots
; i
++)
8856 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
8858 SAFE_BYTE_GET (row
, pi
, 4, limit
);
8861 /* PR 17531: file: a05f6ab3. */
8864 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
8870 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
8872 prow
= poffsets
+ (row
- 1) * ncols
* 4;
8873 /* PR 17531: file: b8ce60a8. */
8874 if (prow
< poffsets
|| prow
> limit
)
8876 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
8882 printf (_(" [%3d] 0x%s"),
8883 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
8884 buf
, sizeof (buf
)));
8885 for (j
= 0; j
< ncols
; j
++)
8887 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
8889 printf (" %8d", val
);
8892 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
8894 /* PR 17531: file: 10796eb3. */
8895 if (dw_sect
>= DW_SECT_MAX
)
8896 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
8898 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
8914 printf (_(" Size table\n"));
8915 printf (" slot %-16s ",
8916 is_tu_index
? _("signature") : _("dwo_id"));
8919 for (j
= 0; j
< ncols
; j
++)
8921 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
8923 printf (" %8s", get_DW_SECT_short_name (val
));
8929 for (i
= 0; i
< nslots
; i
++)
8931 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
8933 SAFE_BYTE_GET (row
, pi
, 4, limit
);
8936 prow
= psizes
+ (row
- 1) * ncols
* 4;
8939 printf (_(" [%3d] 0x%s"),
8940 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
8941 buf
, sizeof (buf
)));
8943 for (j
= 0; j
< ncols
; j
++)
8945 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
8947 printf (" %8d", val
);
8950 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
8951 if (dw_sect
>= DW_SECT_MAX
)
8952 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
8954 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
8966 else if (do_display
)
8967 printf (_(" Unsupported version (%d)\n"), version
);
8975 /* Load the CU and TU indexes if present. This will build a list of
8976 section sets that we can use to associate a .debug_info.dwo section
8977 with its associated .debug_abbrev.dwo section in a .dwp file. */
8980 load_cu_tu_indexes (void *file
)
8982 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
8984 /* If we have already loaded (or tried to load) the CU and TU indexes
8985 then do not bother to repeat the task. */
8986 if (cu_tu_indexes_read
== -1)
8988 cu_tu_indexes_read
= TRUE
;
8990 if (load_debug_section (dwp_cu_index
, file
))
8991 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
8992 cu_tu_indexes_read
= FALSE
;
8994 if (load_debug_section (dwp_tu_index
, file
))
8995 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
8996 cu_tu_indexes_read
= FALSE
;
8999 return (bfd_boolean
) cu_tu_indexes_read
;
9002 /* Find the set of sections that includes section SHNDX. */
9005 find_cu_tu_set (void *file
, unsigned int shndx
)
9009 if (! load_cu_tu_indexes (file
))
9012 /* Find SHNDX in the shndx pool. */
9013 for (i
= 0; i
< shndx_pool_used
; i
++)
9014 if (shndx_pool
[i
] == shndx
)
9017 if (i
>= shndx_pool_used
)
9020 /* Now backup to find the first entry in the set. */
9021 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9024 return shndx_pool
+ i
;
9027 /* Display a .debug_cu_index or .debug_tu_index section. */
9030 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9032 return process_cu_tu_index (section
, 1);
9036 display_debug_not_supported (struct dwarf_section
*section
,
9037 void *file ATTRIBUTE_UNUSED
)
9039 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9045 /* Like malloc, but takes two parameters like calloc.
9046 Verifies that the first parameter is not too large.
9047 Note: does *not* initialise the allocated memory to zero. */
9049 cmalloc (size_t nmemb
, size_t size
)
9051 /* Check for overflow. */
9052 if (nmemb
>= ~(size_t) 0 / size
)
9055 return xmalloc (nmemb
* size
);
9058 /* Like xmalloc, but takes two parameters like calloc.
9059 Verifies that the first parameter is not too large.
9060 Note: does *not* initialise the allocated memory to zero. */
9062 xcmalloc (size_t nmemb
, size_t size
)
9064 /* Check for overflow. */
9065 if (nmemb
>= ~(size_t) 0 / size
)
9068 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9073 return xmalloc (nmemb
* size
);
9076 /* Like xrealloc, but takes three parameters.
9077 Verifies that the second parameter is not too large.
9078 Note: does *not* initialise any new memory to zero. */
9080 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9082 /* Check for overflow. */
9083 if (nmemb
>= ~(size_t) 0 / size
)
9086 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9091 return xrealloc (ptr
, nmemb
* size
);
9094 /* Like xcalloc, but verifies that the first parameter is not too large. */
9096 xcalloc2 (size_t nmemb
, size_t size
)
9098 /* Check for overflow. */
9099 if (nmemb
>= ~(size_t) 0 / size
)
9102 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9107 return xcalloc (nmemb
, size
);
9111 free_debug_memory (void)
9117 for (i
= 0; i
< max
; i
++)
9118 free_debug_section ((enum dwarf_section_display_enum
) i
);
9120 if (debug_information
!= NULL
)
9122 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
9124 for (i
= 0; i
< num_debug_info_entries
; i
++)
9126 if (!debug_information
[i
].max_loc_offsets
)
9128 free (debug_information
[i
].loc_offsets
);
9129 free (debug_information
[i
].have_frame_base
);
9131 if (!debug_information
[i
].max_range_lists
)
9132 free (debug_information
[i
].range_lists
);
9135 free (debug_information
);
9136 debug_information
= NULL
;
9137 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
9142 dwarf_select_sections_by_names (const char *names
)
9146 const char * option
;
9150 debug_dump_long_opts
;
9152 static const debug_dump_long_opts opts_table
[] =
9154 /* Please keep this table alpha- sorted. */
9155 { "Ranges", & do_debug_ranges
, 1 },
9156 { "abbrev", & do_debug_abbrevs
, 1 },
9157 { "addr", & do_debug_addr
, 1 },
9158 { "aranges", & do_debug_aranges
, 1 },
9159 { "cu_index", & do_debug_cu_index
, 1 },
9160 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
9161 { "frames", & do_debug_frames
, 1 },
9162 { "frames-interp", & do_debug_frames_interp
, 1 },
9163 /* The special .gdb_index section. */
9164 { "gdb_index", & do_gdb_index
, 1 },
9165 { "info", & do_debug_info
, 1 },
9166 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
9167 { "loc", & do_debug_loc
, 1 },
9168 { "macro", & do_debug_macinfo
, 1 },
9169 { "pubnames", & do_debug_pubnames
, 1 },
9170 { "pubtypes", & do_debug_pubtypes
, 1 },
9171 /* This entry is for compatibility
9172 with earlier versions of readelf. */
9173 { "ranges", & do_debug_aranges
, 1 },
9174 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
9175 { "str", & do_debug_str
, 1 },
9176 /* These trace_* sections are used by Itanium VMS. */
9177 { "trace_abbrev", & do_trace_abbrevs
, 1 },
9178 { "trace_aranges", & do_trace_aranges
, 1 },
9179 { "trace_info", & do_trace_info
, 1 },
9188 const debug_dump_long_opts
* entry
;
9190 for (entry
= opts_table
; entry
->option
; entry
++)
9192 size_t len
= strlen (entry
->option
);
9194 if (strncmp (p
, entry
->option
, len
) == 0
9195 && (p
[len
] == ',' || p
[len
] == '\0'))
9197 * entry
->variable
|= entry
->val
;
9199 /* The --debug-dump=frames-interp option also
9200 enables the --debug-dump=frames option. */
9201 if (do_debug_frames_interp
)
9202 do_debug_frames
= 1;
9209 if (entry
->option
== NULL
)
9211 warn (_("Unrecognized debug option '%s'\n"), p
);
9212 p
= strchr (p
, ',');
9223 dwarf_select_sections_by_letters (const char *letters
)
9225 unsigned int lindex
= 0;
9227 while (letters
[lindex
])
9228 switch (letters
[lindex
++])
9235 do_debug_abbrevs
= 1;
9239 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
9243 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
9247 do_debug_pubnames
= 1;
9251 do_debug_pubtypes
= 1;
9255 do_debug_aranges
= 1;
9259 do_debug_ranges
= 1;
9263 do_debug_frames_interp
= 1;
9266 do_debug_frames
= 1;
9270 do_debug_macinfo
= 1;
9282 warn (_("Unrecognized debug option '%s'\n"), letters
);
9288 dwarf_select_sections_all (void)
9291 do_debug_abbrevs
= 1;
9292 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
9293 do_debug_pubnames
= 1;
9294 do_debug_pubtypes
= 1;
9295 do_debug_aranges
= 1;
9296 do_debug_ranges
= 1;
9297 do_debug_frames
= 1;
9298 do_debug_macinfo
= 1;
9303 do_trace_abbrevs
= 1;
9304 do_trace_aranges
= 1;
9306 do_debug_cu_index
= 1;
9309 struct dwarf_section_display debug_displays
[] =
9311 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9312 display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
9313 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9314 display_debug_aranges
, &do_debug_aranges
, TRUE
},
9315 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9316 display_debug_frames
, &do_debug_frames
, TRUE
},
9317 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
, NULL
, 0, NULL
},
9318 display_debug_info
, &do_debug_info
, TRUE
},
9319 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9320 display_debug_lines
, &do_debug_lines
, TRUE
},
9321 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9322 display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
9323 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9324 display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
9325 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9326 display_debug_frames
, &do_debug_frames
, TRUE
},
9327 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9328 display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
9329 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9330 display_debug_macro
, &do_debug_macinfo
, TRUE
},
9331 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9332 display_debug_str
, &do_debug_str
, FALSE
},
9333 { { ".debug_line_str", ".zdebug_line_str", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9334 display_debug_str
, &do_debug_str
, FALSE
},
9335 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9336 display_debug_loc
, &do_debug_loc
, TRUE
},
9337 { { ".debug_loclists", ".zdebug_loclists", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9338 display_debug_loc
, &do_debug_loc
, TRUE
},
9339 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9340 display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
9341 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9342 display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
9343 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9344 display_debug_ranges
, &do_debug_ranges
, TRUE
},
9345 { { ".debug_rnglists", ".zdebug_rnglists", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9346 display_debug_ranges
, &do_debug_ranges
, TRUE
},
9347 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9348 display_debug_not_supported
, NULL
, FALSE
},
9349 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9350 display_debug_not_supported
, NULL
, FALSE
},
9351 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
, NULL
, 0, NULL
},
9352 display_debug_types
, &do_debug_info
, TRUE
},
9353 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9354 display_debug_not_supported
, NULL
, FALSE
},
9355 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9356 display_gdb_index
, &do_gdb_index
, FALSE
},
9357 { { ".debug_names", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9358 display_debug_names
, &do_gdb_index
, FALSE
},
9359 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
, NULL
, 0, NULL
},
9360 display_trace_info
, &do_trace_info
, TRUE
},
9361 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9362 display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
9363 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9364 display_debug_aranges
, &do_trace_aranges
, FALSE
},
9365 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
, 0, NULL
},
9366 display_debug_info
, &do_debug_info
, TRUE
},
9367 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9368 display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
9369 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
, 0, NULL
},
9370 display_debug_types
, &do_debug_info
, TRUE
},
9371 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9372 display_debug_lines
, &do_debug_lines
, TRUE
},
9373 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9374 display_debug_loc
, &do_debug_loc
, TRUE
},
9375 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9376 display_debug_macro
, &do_debug_macinfo
, TRUE
},
9377 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9378 display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
9379 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9380 display_debug_str
, &do_debug_str
, TRUE
},
9381 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9382 display_debug_str_offsets
, NULL
, FALSE
},
9383 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9384 display_debug_str_offsets
, NULL
, FALSE
},
9385 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9386 display_debug_addr
, &do_debug_addr
, TRUE
},
9387 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9388 display_cu_index
, &do_debug_cu_index
, FALSE
},
9389 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9390 display_cu_index
, &do_debug_cu_index
, FALSE
},
9393 /* A static assertion. */
9394 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];