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 long sec_off
;
2594 unsigned int offset_size
;
2595 unsigned int initial_length_size
;
2596 dwarf_vma signature_high
= 0;
2597 dwarf_vma signature_low
= 0;
2598 dwarf_vma type_offset
= 0;
2599 struct cu_tu_set
*this_set
;
2600 dwarf_vma abbrev_base
;
2605 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2607 if (compunit
.cu_length
== 0xffffffff)
2609 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2611 initial_length_size
= 12;
2616 initial_length_size
= 4;
2619 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2621 cu_offset
= start
- section_begin
;
2623 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2625 if (compunit
.cu_version
< 5)
2627 compunit
.cu_unit_type
= DW_UT_compile
;
2628 /* Initialize it due to a false compiler warning. */
2629 compunit
.cu_pointer_size
= -1;
2633 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
2634 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
2636 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2639 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2641 if (this_set
== NULL
)
2644 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2648 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2649 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2652 if (compunit
.cu_version
< 5)
2653 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2655 /* PR 17512: file: 001-108546-0.001:0.1. */
2656 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2658 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2659 compunit
.cu_pointer_size
, offset_size
);
2660 compunit
.cu_pointer_size
= offset_size
;
2665 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2667 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2670 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
2671 + initial_length_size
))
2673 start
= section_begin
+ cu_offset
+ compunit
.cu_length
2674 + initial_length_size
;
2678 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2679 && num_debug_info_entries
== 0
2682 debug_information
[unit
].cu_offset
= cu_offset
;
2683 debug_information
[unit
].pointer_size
2684 = compunit
.cu_pointer_size
;
2685 debug_information
[unit
].offset_size
= offset_size
;
2686 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2687 debug_information
[unit
].base_address
= 0;
2688 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2689 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2690 debug_information
[unit
].loc_offsets
= NULL
;
2691 debug_information
[unit
].have_frame_base
= NULL
;
2692 debug_information
[unit
].max_loc_offsets
= 0;
2693 debug_information
[unit
].num_loc_offsets
= 0;
2694 debug_information
[unit
].range_lists
= NULL
;
2695 debug_information
[unit
].max_range_lists
= 0;
2696 debug_information
[unit
].num_range_lists
= 0;
2699 if (!do_loc
&& dwarf_start_die
== 0)
2701 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2702 dwarf_vmatoa ("x", cu_offset
));
2703 printf (_(" Length: 0x%s (%s)\n"),
2704 dwarf_vmatoa ("x", compunit
.cu_length
),
2705 offset_size
== 8 ? "64-bit" : "32-bit");
2706 printf (_(" Version: %d\n"), compunit
.cu_version
);
2707 printf (_(" Abbrev Offset: 0x%s\n"),
2708 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2709 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2714 printf (_(" Signature: 0x%s\n"),
2715 dwarf_vmatoa64 (signature_high
, signature_low
,
2716 buf
, sizeof (buf
)));
2717 printf (_(" Type Offset: 0x%s\n"),
2718 dwarf_vmatoa ("x", type_offset
));
2720 if (this_set
!= NULL
)
2722 dwarf_vma
*offsets
= this_set
->section_offsets
;
2723 size_t *sizes
= this_set
->section_sizes
;
2725 printf (_(" Section contributions:\n"));
2726 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2727 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2728 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2729 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2730 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2731 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2732 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2733 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2734 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2735 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2736 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2737 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2741 sec_off
= cu_offset
+ initial_length_size
;
2742 if (sec_off
+ compunit
.cu_length
< sec_off
2743 || sec_off
+ compunit
.cu_length
> section
->size
)
2745 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
2747 (unsigned long) cu_offset
,
2748 dwarf_vmatoa ("x", compunit
.cu_length
));
2754 start
+= compunit
.cu_length
+ initial_length_size
;
2756 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
2758 warn (_("CU at offset %s contains corrupt or "
2759 "unsupported version number: %d.\n"),
2760 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2764 if (compunit
.cu_unit_type
!= DW_UT_compile
2765 && compunit
.cu_unit_type
!= DW_UT_type
)
2767 warn (_("CU at offset %s contains corrupt or "
2768 "unsupported unit type: %d.\n"),
2769 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
2775 /* Process the abbrevs used by this compilation unit. */
2776 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2777 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2778 (unsigned long) compunit
.cu_abbrev_offset
,
2779 (unsigned long) abbrev_size
);
2780 /* PR 17531: file:4bcd9ce9. */
2781 else if ((abbrev_base
+ abbrev_size
)
2782 > debug_displays
[abbrev_sec
].section
.size
)
2783 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2784 (unsigned long) abbrev_base
+ abbrev_size
,
2785 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
2787 process_abbrev_section
2788 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2789 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2790 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2791 + abbrev_base
+ abbrev_size
));
2796 while (tags
< start
)
2798 unsigned int bytes_read
;
2799 unsigned long abbrev_number
;
2800 unsigned long die_offset
;
2801 abbrev_entry
*entry
;
2803 int do_printing
= 1;
2805 die_offset
= tags
- section_begin
;
2807 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2810 /* A null DIE marks the end of a list of siblings or it may also be
2811 a section padding. */
2812 if (abbrev_number
== 0)
2814 /* Check if it can be a section padding for the last CU. */
2815 if (level
== 0 && start
== end
)
2819 for (chk
= tags
; chk
< start
; chk
++)
2826 if (!do_loc
&& die_offset
>= dwarf_start_die
2827 && (dwarf_cutoff_level
== -1
2828 || level
< dwarf_cutoff_level
))
2829 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2835 static unsigned num_bogus_warns
= 0;
2837 if (num_bogus_warns
< 3)
2839 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2840 die_offset
, section
->name
);
2842 if (num_bogus_warns
== 3)
2843 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2846 if (dwarf_start_die
!= 0 && level
< saved_level
)
2853 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2857 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2858 saved_level
= level
;
2859 do_printing
= (dwarf_cutoff_level
== -1
2860 || level
< dwarf_cutoff_level
);
2862 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2863 level
, die_offset
, abbrev_number
);
2864 else if (dwarf_cutoff_level
== -1
2865 || last_level
< dwarf_cutoff_level
)
2866 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2871 /* Scan through the abbreviation list until we reach the
2873 for (entry
= first_abbrev
;
2874 entry
&& entry
->entry
!= abbrev_number
;
2875 entry
= entry
->next
)
2880 if (!do_loc
&& do_printing
)
2885 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2886 die_offset
, abbrev_number
);
2890 if (!do_loc
&& do_printing
)
2891 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2896 need_base_address
= 0;
2898 case DW_TAG_compile_unit
:
2899 need_base_address
= 1;
2901 case DW_TAG_entry_point
:
2902 case DW_TAG_subprogram
:
2903 need_base_address
= 0;
2904 /* Assuming that there is no DW_AT_frame_base. */
2905 have_frame_base
= 0;
2909 debug_info
*debug_info_p
=
2910 (debug_information
&& unit
< alloc_num_debug_info_entries
)
2911 ? debug_information
+ unit
: NULL
;
2913 assert (!debug_info_p
2914 || (debug_info_p
->num_loc_offsets
2915 == debug_info_p
->num_loc_views
));
2917 for (attr
= entry
->first_attr
;
2918 attr
&& attr
->attribute
;
2921 if (! do_loc
&& do_printing
)
2922 /* Show the offset from where the tag was extracted. */
2923 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2925 tags
= read_and_display_attr (attr
->attribute
,
2927 attr
->implicit_const
,
2931 compunit
.cu_pointer_size
,
2933 compunit
.cu_version
,
2935 do_loc
|| ! do_printing
,
2940 /* If a locview attribute appears before a location one,
2941 make sure we don't associate it with an earlier
2944 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
2947 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
2948 debug_info_p
->num_loc_views
++;
2949 assert (debug_info_p
->num_loc_views
2950 == debug_info_p
->num_loc_offsets
);
2957 warn(_("DIE has locviews without loclist\n"));
2958 debug_info_p
->num_loc_views
--;
2965 if (entry
->children
)
2970 /* Set num_debug_info_entries here so that it can be used to check if
2971 we need to process .debug_loc and .debug_ranges sections. */
2972 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2973 && num_debug_info_entries
== 0
2976 if (num_units
> alloc_num_debug_info_entries
)
2977 num_debug_info_entries
= alloc_num_debug_info_entries
;
2979 num_debug_info_entries
= num_units
;
2988 /* Locate and scan the .debug_info section in the file and record the pointer
2989 sizes and offsets for the compilation units in it. Usually an executable
2990 will have just one pointer size, but this is not guaranteed, and so we try
2991 not to make any assumptions. Returns zero upon failure, or the number of
2992 compilation units upon success. */
2995 load_debug_info (void * file
)
2997 /* If we have already tried and failed to load the .debug_info
2998 section then do not bother to repeat the task. */
2999 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3002 /* If we already have the information there is nothing else to do. */
3003 if (num_debug_info_entries
> 0)
3004 return num_debug_info_entries
;
3006 /* If this is a DWARF package file, load the CU and TU indexes. */
3007 (void) load_cu_tu_indexes (file
);
3009 if (load_debug_section (info
, file
)
3010 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
3011 return num_debug_info_entries
;
3013 if (load_debug_section (info_dwo
, file
)
3014 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
3016 return num_debug_info_entries
;
3018 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
3022 /* Read a DWARF .debug_line section header starting at DATA.
3023 Upon success returns an updated DATA pointer and the LINFO
3024 structure and the END_OF_SEQUENCE pointer will be filled in.
3025 Otherwise returns NULL. */
3027 static unsigned char *
3028 read_debug_line_header (struct dwarf_section
* section
,
3029 unsigned char * data
,
3030 unsigned char * end
,
3031 DWARF2_Internal_LineInfo
* linfo
,
3032 unsigned char ** end_of_sequence
)
3034 unsigned char *hdrptr
;
3035 unsigned int initial_length_size
;
3036 unsigned char address_size
, segment_selector_size
;
3038 /* Extract information from the Line Number Program Header.
3039 (section 6.2.4 in the Dwarf3 doc). */
3042 /* Get and check the length of the block. */
3043 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
3045 if (linfo
->li_length
== 0xffffffff)
3047 /* This section is 64-bit DWARF 3. */
3048 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
3049 linfo
->li_offset_size
= 8;
3050 initial_length_size
= 12;
3054 linfo
->li_offset_size
= 4;
3055 initial_length_size
= 4;
3058 if (linfo
->li_length
+ initial_length_size
> section
->size
)
3060 /* If the length field has a relocation against it, then we should
3061 not complain if it is inaccurate (and probably negative). This
3062 happens in object files when the .debug_line section is actually
3063 comprised of several different .debug_line.* sections, (some of
3064 which may be removed by linker garbage collection), and a relocation
3065 is used to compute the correct length once that is done. */
3066 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
3068 linfo
->li_length
= (end
- data
) - initial_length_size
;
3072 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
3073 (long) linfo
->li_length
);
3078 /* Get and check the version number. */
3079 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
3081 if (linfo
->li_version
!= 2
3082 && linfo
->li_version
!= 3
3083 && linfo
->li_version
!= 4
3084 && linfo
->li_version
!= 5)
3086 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
3087 "is currently supported.\n"));
3091 if (linfo
->li_version
>= 5)
3093 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
3095 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
3096 if (segment_selector_size
!= 0)
3098 warn (_("The %s section contains "
3099 "unsupported segment selector size: %d.\n"),
3100 section
->name
, segment_selector_size
);
3105 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
3106 linfo
->li_offset_size
, end
);
3107 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
3109 if (linfo
->li_version
>= 4)
3111 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
3113 if (linfo
->li_max_ops_per_insn
== 0)
3115 warn (_("Invalid maximum operations per insn.\n"));
3120 linfo
->li_max_ops_per_insn
= 1;
3122 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
3123 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
3124 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
3125 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
3127 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
3128 /* PR 17512: file:002-117414-0.004. */
3129 if (* end_of_sequence
> end
)
3131 warn (_("Line length %s extends beyond end of section\n"),
3132 dwarf_vmatoa ("u", linfo
->li_length
));
3133 * end_of_sequence
= end
;
3140 static unsigned char *
3141 display_formatted_table (unsigned char *data
,
3142 unsigned char *start
, unsigned char *end
,
3143 const DWARF2_Internal_LineInfo
*linfo
,
3144 struct dwarf_section
*section
, const char *what
)
3146 unsigned char *format_start
, format_count
, *format
, formati
;
3147 dwarf_vma data_count
, datai
;
3148 unsigned int bytes_read
, namepass
, last_entry
= 0;
3150 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3151 format_start
= data
;
3152 for (formati
= 0; formati
< format_count
; formati
++)
3154 read_uleb128 (data
, & bytes_read
, end
);
3156 read_uleb128 (data
, & bytes_read
, end
);
3160 warn (_("Corrupt %s format table entry\n"), what
);
3165 data_count
= read_uleb128 (data
, & bytes_read
, end
);
3169 warn (_("Corrupt %s list\n"), what
);
3173 if (data_count
== 0)
3175 printf (_("\n The %s Table is empty.\n"), what
);
3179 printf (_("\n The %s Table (offset 0x%lx):\n"), what
,
3180 (long)(data
- start
));
3182 printf (_(" Entry"));
3183 /* Delay displaying name as the last entry for better screen layout. */
3184 for (namepass
= 0; namepass
< 2; namepass
++)
3186 format
= format_start
;
3187 for (formati
= 0; formati
< format_count
; formati
++)
3189 dwarf_vma content_type
;
3191 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3192 format
+= bytes_read
;
3193 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
3194 switch (content_type
)
3197 printf (_("\tName"));
3199 case DW_LNCT_directory_index
:
3200 printf (_("\tDir"));
3202 case DW_LNCT_timestamp
:
3203 printf (_("\tTime"));
3206 printf (_("\tSize"));
3209 printf (_("\tMD5"));
3212 printf (_("\t(Unknown format content type %s)"),
3213 dwarf_vmatoa ("u", content_type
));
3215 read_uleb128 (format
, & bytes_read
, end
);
3216 format
+= bytes_read
;
3221 for (datai
= 0; datai
< data_count
; datai
++)
3223 unsigned char *datapass
= data
;
3225 printf (" %d", last_entry
++);
3226 /* Delay displaying name as the last entry for better screen layout. */
3227 for (namepass
= 0; namepass
< 2; namepass
++)
3229 format
= format_start
;
3231 for (formati
= 0; formati
< format_count
; formati
++)
3233 dwarf_vma content_type
, form
;
3235 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3236 format
+= bytes_read
;
3237 form
= read_uleb128 (format
, & bytes_read
, end
);
3238 format
+= bytes_read
;
3239 data
= read_and_display_attr_value (0, form
, 0, data
, end
, 0, 0,
3240 linfo
->li_offset_size
,
3241 linfo
->li_version
, NULL
,
3242 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
3243 section
, NULL
, '\t');
3248 warn (_("Corrupt %s entries list\n"), what
);
3257 display_debug_lines_raw (struct dwarf_section
*section
,
3258 unsigned char *data
,
3259 unsigned char *end
, void *file
)
3261 unsigned char *start
= section
->start
;
3262 int verbose_view
= 0;
3264 printf (_("Raw dump of debug contents of section %s:\n\n"),
3269 static DWARF2_Internal_LineInfo saved_linfo
;
3270 DWARF2_Internal_LineInfo linfo
;
3271 unsigned char *standard_opcodes
;
3272 unsigned char *end_of_sequence
;
3275 if (const_strneq (section
->name
, ".debug_line.")
3276 /* Note: the following does not apply to .debug_line.dwo sections.
3277 These are full debug_line sections. */
3278 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3280 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3281 section containing just the Line Number Statements. They are
3282 created by the assembler and intended to be used alongside gcc's
3283 -ffunction-sections command line option. When the linker's
3284 garbage collection decides to discard a .text.<foo> section it
3285 can then also discard the line number information in .debug_line.<foo>.
3287 Since the section is a fragment it does not have the details
3288 needed to fill out a LineInfo structure, so instead we use the
3289 details from the last full debug_line section that we processed. */
3290 end_of_sequence
= end
;
3291 standard_opcodes
= NULL
;
3292 linfo
= saved_linfo
;
3293 /* PR 17531: file: 0522b371. */
3294 if (linfo
.li_line_range
== 0)
3296 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3299 reset_state_machine (linfo
.li_default_is_stmt
);
3303 unsigned char * hdrptr
;
3305 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3306 & end_of_sequence
)) == NULL
)
3309 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
3310 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
3311 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
3312 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
3313 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
3314 if (linfo
.li_version
>= 4)
3315 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
3316 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
3317 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
3318 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
3319 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
3321 /* PR 17512: file: 1665-6428-0.004. */
3322 if (linfo
.li_line_range
== 0)
3324 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3325 linfo
.li_line_range
= 1;
3328 reset_state_machine (linfo
.li_default_is_stmt
);
3330 /* Display the contents of the Opcodes table. */
3331 standard_opcodes
= hdrptr
;
3333 /* PR 17512: file: 002-417945-0.004. */
3334 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
3336 warn (_("Line Base extends beyond end of section\n"));
3340 printf (_("\n Opcodes:\n"));
3342 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
3343 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
3345 /* Display the contents of the Directory table. */
3346 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3348 if (linfo
.li_version
>= 5)
3350 load_debug_section (line_str
, file
);
3352 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3354 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
3360 printf (_("\n The Directory Table is empty.\n"));
3363 unsigned int last_dir_entry
= 0;
3365 printf (_("\n The Directory Table (offset 0x%lx):\n"),
3366 (long)(data
- start
));
3368 while (data
< end
&& *data
!= 0)
3370 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
3372 data
+= strnlen ((char *) data
, end
- data
) + 1;
3375 /* PR 17512: file: 002-132094-0.004. */
3376 if (data
>= end
- 1)
3380 /* Skip the NUL at the end of the table. */
3383 /* Display the contents of the File Name table. */
3385 printf (_("\n The File Name Table is empty.\n"));
3388 printf (_("\n The File Name Table (offset 0x%lx):\n"),
3389 (long)(data
- start
));
3390 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3392 while (data
< end
&& *data
!= 0)
3394 unsigned char *name
;
3395 unsigned int bytes_read
;
3397 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
3399 data
+= strnlen ((char *) data
, end
- data
) + 1;
3402 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3405 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3408 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
3410 printf ("%.*s\n", (int)(end
- name
), name
);
3414 warn (_("Corrupt file name table entry\n"));
3420 /* Skip the NUL at the end of the table. */
3425 saved_linfo
= linfo
;
3428 /* Now display the statements. */
3429 if (data
>= end_of_sequence
)
3430 printf (_(" No Line Number Statements.\n"));
3433 printf (_(" Line Number Statements:\n"));
3435 while (data
< end_of_sequence
)
3437 unsigned char op_code
;
3438 dwarf_signed_vma adv
;
3440 unsigned int bytes_read
;
3442 printf (" [0x%08lx]", (long)(data
- start
));
3446 if (op_code
>= linfo
.li_opcode_base
)
3448 op_code
-= linfo
.li_opcode_base
;
3449 uladv
= (op_code
/ linfo
.li_line_range
);
3450 if (linfo
.li_max_ops_per_insn
== 1)
3452 uladv
*= linfo
.li_min_insn_length
;
3453 state_machine_regs
.address
+= uladv
;
3455 state_machine_regs
.view
= 0;
3456 printf (_(" Special opcode %d: "
3457 "advance Address by %s to 0x%s%s"),
3458 op_code
, dwarf_vmatoa ("u", uladv
),
3459 dwarf_vmatoa ("x", state_machine_regs
.address
),
3460 verbose_view
&& uladv
3461 ? _(" (reset view)") : "");
3466 = ((state_machine_regs
.op_index
+ uladv
)
3467 / linfo
.li_max_ops_per_insn
)
3468 * linfo
.li_min_insn_length
;
3470 state_machine_regs
.address
+= addrdelta
;
3471 state_machine_regs
.op_index
3472 = (state_machine_regs
.op_index
+ uladv
)
3473 % linfo
.li_max_ops_per_insn
;
3475 state_machine_regs
.view
= 0;
3476 printf (_(" Special opcode %d: "
3477 "advance Address by %s to 0x%s[%d]%s"),
3478 op_code
, dwarf_vmatoa ("u", uladv
),
3479 dwarf_vmatoa ("x", state_machine_regs
.address
),
3480 state_machine_regs
.op_index
,
3481 verbose_view
&& addrdelta
3482 ? _(" (reset view)") : "");
3484 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3485 state_machine_regs
.line
+= adv
;
3486 printf (_(" and Line by %s to %d"),
3487 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
3488 if (verbose_view
|| state_machine_regs
.view
)
3489 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3492 state_machine_regs
.view
++;
3494 else switch (op_code
)
3496 case DW_LNS_extended_op
:
3497 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3501 printf (_(" Copy"));
3502 if (verbose_view
|| state_machine_regs
.view
)
3503 printf (_(" (view %u)\n"), state_machine_regs
.view
);
3506 state_machine_regs
.view
++;
3509 case DW_LNS_advance_pc
:
3510 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3512 if (linfo
.li_max_ops_per_insn
== 1)
3514 uladv
*= linfo
.li_min_insn_length
;
3515 state_machine_regs
.address
+= uladv
;
3517 state_machine_regs
.view
= 0;
3518 printf (_(" Advance PC by %s to 0x%s%s\n"),
3519 dwarf_vmatoa ("u", uladv
),
3520 dwarf_vmatoa ("x", state_machine_regs
.address
),
3521 verbose_view
&& uladv
3522 ? _(" (reset view)") : "");
3527 = ((state_machine_regs
.op_index
+ uladv
)
3528 / linfo
.li_max_ops_per_insn
)
3529 * linfo
.li_min_insn_length
;
3530 state_machine_regs
.address
3532 state_machine_regs
.op_index
3533 = (state_machine_regs
.op_index
+ uladv
)
3534 % linfo
.li_max_ops_per_insn
;
3536 state_machine_regs
.view
= 0;
3537 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
3538 dwarf_vmatoa ("u", uladv
),
3539 dwarf_vmatoa ("x", state_machine_regs
.address
),
3540 state_machine_regs
.op_index
,
3541 verbose_view
&& addrdelta
3542 ? _(" (reset view)") : "");
3546 case DW_LNS_advance_line
:
3547 adv
= read_sleb128 (data
, & bytes_read
, end
);
3549 state_machine_regs
.line
+= adv
;
3550 printf (_(" Advance Line by %s to %d\n"),
3551 dwarf_vmatoa ("d", adv
),
3552 state_machine_regs
.line
);
3555 case DW_LNS_set_file
:
3556 adv
= read_uleb128 (data
, & bytes_read
, end
);
3558 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3559 dwarf_vmatoa ("d", adv
));
3560 state_machine_regs
.file
= adv
;
3563 case DW_LNS_set_column
:
3564 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3566 printf (_(" Set column to %s\n"),
3567 dwarf_vmatoa ("u", uladv
));
3568 state_machine_regs
.column
= uladv
;
3571 case DW_LNS_negate_stmt
:
3572 adv
= state_machine_regs
.is_stmt
;
3574 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3575 state_machine_regs
.is_stmt
= adv
;
3578 case DW_LNS_set_basic_block
:
3579 printf (_(" Set basic block\n"));
3580 state_machine_regs
.basic_block
= 1;
3583 case DW_LNS_const_add_pc
:
3584 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3585 if (linfo
.li_max_ops_per_insn
)
3587 uladv
*= linfo
.li_min_insn_length
;
3588 state_machine_regs
.address
+= uladv
;
3590 state_machine_regs
.view
= 0;
3591 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
3592 dwarf_vmatoa ("u", uladv
),
3593 dwarf_vmatoa ("x", state_machine_regs
.address
),
3594 verbose_view
&& uladv
3595 ? _(" (reset view)") : "");
3600 = ((state_machine_regs
.op_index
+ uladv
)
3601 / linfo
.li_max_ops_per_insn
)
3602 * linfo
.li_min_insn_length
;
3603 state_machine_regs
.address
3605 state_machine_regs
.op_index
3606 = (state_machine_regs
.op_index
+ uladv
)
3607 % linfo
.li_max_ops_per_insn
;
3609 state_machine_regs
.view
= 0;
3610 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
3611 dwarf_vmatoa ("u", uladv
),
3612 dwarf_vmatoa ("x", state_machine_regs
.address
),
3613 state_machine_regs
.op_index
,
3614 verbose_view
&& addrdelta
3615 ? _(" (reset view)") : "");
3619 case DW_LNS_fixed_advance_pc
:
3620 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3621 state_machine_regs
.address
+= uladv
;
3622 state_machine_regs
.op_index
= 0;
3623 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3624 dwarf_vmatoa ("u", uladv
),
3625 dwarf_vmatoa ("x", state_machine_regs
.address
));
3626 /* Do NOT reset view. */
3629 case DW_LNS_set_prologue_end
:
3630 printf (_(" Set prologue_end to true\n"));
3633 case DW_LNS_set_epilogue_begin
:
3634 printf (_(" Set epilogue_begin to true\n"));
3637 case DW_LNS_set_isa
:
3638 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3640 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3644 printf (_(" Unknown opcode %d with operands: "), op_code
);
3646 if (standard_opcodes
!= NULL
)
3647 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3649 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3651 i
== 1 ? "" : ", ");
3667 unsigned char *name
;
3668 unsigned int directory_index
;
3669 unsigned int modification_date
;
3670 unsigned int length
;
3673 /* Output a decoded representation of the .debug_line section. */
3676 display_debug_lines_decoded (struct dwarf_section
*section
,
3677 unsigned char *data
,
3678 unsigned char *end
, void *fileptr
)
3680 static DWARF2_Internal_LineInfo saved_linfo
;
3682 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3687 /* This loop amounts to one iteration per compilation unit. */
3688 DWARF2_Internal_LineInfo linfo
;
3689 unsigned char *standard_opcodes
;
3690 unsigned char *end_of_sequence
;
3692 File_Entry
*file_table
= NULL
;
3693 unsigned int n_files
= 0;
3694 unsigned char **directory_table
= NULL
;
3695 dwarf_vma n_directories
= 0;
3697 if (const_strneq (section
->name
, ".debug_line.")
3698 /* Note: the following does not apply to .debug_line.dwo sections.
3699 These are full debug_line sections. */
3700 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3702 /* See comment in display_debug_lines_raw(). */
3703 end_of_sequence
= end
;
3704 standard_opcodes
= NULL
;
3705 linfo
= saved_linfo
;
3706 /* PR 17531: file: 0522b371. */
3707 if (linfo
.li_line_range
== 0)
3709 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3712 reset_state_machine (linfo
.li_default_is_stmt
);
3716 unsigned char *hdrptr
;
3718 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3719 & end_of_sequence
)) == NULL
)
3722 /* PR 17531: file: 0522b371. */
3723 if (linfo
.li_line_range
== 0)
3725 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3726 linfo
.li_line_range
= 1;
3728 reset_state_machine (linfo
.li_default_is_stmt
);
3730 /* Save a pointer to the contents of the Opcodes table. */
3731 standard_opcodes
= hdrptr
;
3733 /* Traverse the Directory table just to count entries. */
3734 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3738 warn (_("opcode base of %d extends beyond end of section\n"),
3739 linfo
.li_opcode_base
);
3743 if (linfo
.li_version
>= 5)
3745 unsigned char *format_start
, format_count
, *format
;
3746 dwarf_vma formati
, entryi
;
3747 unsigned int bytes_read
;
3749 load_debug_section (line_str
, fileptr
);
3751 /* Skip directories format. */
3752 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3753 format_start
= data
;
3754 for (formati
= 0; formati
< format_count
; formati
++)
3756 read_uleb128 (data
, & bytes_read
, end
);
3758 read_uleb128 (data
, & bytes_read
, end
);
3762 n_directories
= read_uleb128 (data
, & bytes_read
, end
);
3766 warn (_("Corrupt directories list\n"));
3770 directory_table
= (unsigned char **)
3771 xmalloc (n_directories
* sizeof (unsigned char *));
3773 for (entryi
= 0; entryi
< n_directories
; entryi
++)
3775 unsigned char **pathp
= &directory_table
[entryi
];
3777 format
= format_start
;
3778 for (formati
= 0; formati
< format_count
; formati
++)
3780 dwarf_vma content_type
, form
;
3783 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3784 format
+= bytes_read
;
3785 form
= read_uleb128 (format
, & bytes_read
, end
);
3786 format
+= bytes_read
;
3789 warn (_("Corrupt directories list\n"));
3792 switch (content_type
)
3797 case DW_FORM_string
:
3800 case DW_FORM_line_strp
:
3801 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
3803 /* Remove const by the cast. */
3804 *pathp
= (unsigned char *)
3805 fetch_indirect_line_string (uvalue
);
3810 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
3812 linfo
.li_offset_size
,
3819 warn (_("Corrupt directories list\n"));
3824 /* Skip files format. */
3825 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
3826 format_start
= data
;
3827 for (formati
= 0; formati
< format_count
; formati
++)
3829 read_uleb128 (data
, & bytes_read
, end
);
3831 read_uleb128 (data
, & bytes_read
, end
);
3835 n_files
= read_uleb128 (data
, & bytes_read
, end
);
3839 warn (_("Corrupt file name list\n"));
3843 file_table
= (File_Entry
*) xcalloc (1, n_files
3844 * sizeof (File_Entry
));
3846 for (entryi
= 0; entryi
< n_files
; entryi
++)
3848 File_Entry
*file
= &file_table
[entryi
];
3850 format
= format_start
;
3851 for (formati
= 0; formati
< format_count
; formati
++)
3853 dwarf_vma content_type
, form
;
3856 content_type
= read_uleb128 (format
, & bytes_read
, end
);
3857 format
+= bytes_read
;
3858 form
= read_uleb128 (format
, & bytes_read
, end
);
3859 format
+= bytes_read
;
3862 warn (_("Corrupt file name list\n"));
3865 switch (content_type
)
3870 case DW_FORM_string
:
3873 case DW_FORM_line_strp
:
3874 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
3876 /* Remove const by the cast. */
3877 file
->name
= (unsigned char *)
3878 fetch_indirect_line_string (uvalue
);
3882 case DW_LNCT_directory_index
:
3886 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
3890 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
3894 file
->directory_index
= read_uleb128 (data
, NULL
,
3900 data
= read_and_display_attr_value (0, form
, 0, data
, end
,
3902 linfo
.li_offset_size
,
3909 warn (_("Corrupt file name list\n"));
3918 unsigned char *ptr_directory_table
= data
;
3920 while (data
< end
&& *data
!= 0)
3922 data
+= strnlen ((char *) data
, end
- data
) + 1;
3929 warn (_("directory table ends unexpectedly\n"));
3934 /* Go through the directory table again to save the directories. */
3935 directory_table
= (unsigned char **)
3936 xmalloc (n_directories
* sizeof (unsigned char *));
3939 while (*ptr_directory_table
!= 0)
3941 directory_table
[i
] = ptr_directory_table
;
3942 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3943 ptr_directory_table
- end
) + 1;
3947 /* Skip the NUL at the end of the table. */
3950 /* Traverse the File Name table just to count the entries. */
3951 if (data
< end
&& *data
!= 0)
3953 unsigned char *ptr_file_name_table
= data
;
3955 while (data
< end
&& *data
!= 0)
3957 unsigned int bytes_read
;
3959 /* Skip Name, directory index, last modification time and length
3961 data
+= strnlen ((char *) data
, end
- data
) + 1;
3962 read_uleb128 (data
, & bytes_read
, end
);
3964 read_uleb128 (data
, & bytes_read
, end
);
3966 read_uleb128 (data
, & bytes_read
, end
);
3974 warn (_("file table ends unexpectedly\n"));
3979 /* Go through the file table again to save the strings. */
3980 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3983 while (*ptr_file_name_table
!= 0)
3985 unsigned int bytes_read
;
3987 file_table
[i
].name
= ptr_file_name_table
;
3988 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3989 end
- ptr_file_name_table
) + 1;
3991 /* We are not interested in directory, time or size. */
3992 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3994 ptr_file_name_table
+= bytes_read
;
3995 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3997 ptr_file_name_table
+= bytes_read
;
3998 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3999 ptr_file_name_table
+= bytes_read
;
4005 /* Skip the NUL at the end of the table. */
4009 /* Print the Compilation Unit's name and a header. */
4010 if (file_table
== NULL
)
4012 else if (directory_table
== NULL
)
4013 printf (_("CU: %s:\n"), file_table
[0].name
);
4016 unsigned int ix
= file_table
[0].directory_index
;
4017 const char *directory
;
4022 else if (n_directories
== 0)
4023 directory
= _("<unknown>");
4024 else if (ix
> n_directories
)
4026 warn (_("directory index %u > number of directories %s\n"),
4027 ix
, dwarf_vmatoa ("u", n_directories
));
4028 directory
= _("<corrupt>");
4031 directory
= (char *) directory_table
[ix
- 1];
4033 if (do_wide
|| strlen (directory
) < 76)
4034 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
4036 printf ("%s:\n", file_table
[0].name
);
4039 printf (_("File name Line number Starting address View\n"));
4040 saved_linfo
= linfo
;
4043 /* This loop iterates through the Dwarf Line Number Program. */
4044 while (data
< end_of_sequence
)
4046 unsigned char op_code
;
4049 unsigned long int uladv
;
4050 unsigned int bytes_read
;
4051 int is_special_opcode
= 0;
4056 if (op_code
>= linfo
.li_opcode_base
)
4058 op_code
-= linfo
.li_opcode_base
;
4059 uladv
= (op_code
/ linfo
.li_line_range
);
4060 if (linfo
.li_max_ops_per_insn
== 1)
4062 uladv
*= linfo
.li_min_insn_length
;
4063 state_machine_regs
.address
+= uladv
;
4065 state_machine_regs
.view
= 0;
4070 = ((state_machine_regs
.op_index
+ uladv
)
4071 / linfo
.li_max_ops_per_insn
)
4072 * linfo
.li_min_insn_length
;
4073 state_machine_regs
.address
4075 state_machine_regs
.op_index
4076 = (state_machine_regs
.op_index
+ uladv
)
4077 % linfo
.li_max_ops_per_insn
;
4079 state_machine_regs
.view
= 0;
4082 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4083 state_machine_regs
.line
+= adv
;
4084 is_special_opcode
= 1;
4085 /* Increment view after printing this row. */
4087 else switch (op_code
)
4089 case DW_LNS_extended_op
:
4091 unsigned int ext_op_code_len
;
4092 unsigned char ext_op_code
;
4093 unsigned char *op_code_data
= data
;
4095 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
4097 op_code_data
+= bytes_read
;
4099 if (ext_op_code_len
== 0)
4101 warn (_("Badly formed extended line op encountered!\n"));
4104 ext_op_code_len
+= bytes_read
;
4105 ext_op_code
= *op_code_data
++;
4109 switch (ext_op_code
)
4111 case DW_LNE_end_sequence
:
4112 /* Reset stuff after printing this row. */
4114 case DW_LNE_set_address
:
4115 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
4117 ext_op_code_len
- bytes_read
- 1,
4119 state_machine_regs
.op_index
= 0;
4120 state_machine_regs
.view
= 0;
4122 case DW_LNE_define_file
:
4124 file_table
= (File_Entry
*) xrealloc
4125 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
4127 ++state_machine_regs
.last_file_entry
;
4128 /* Source file name. */
4129 file_table
[n_files
].name
= op_code_data
;
4130 op_code_data
+= strlen ((char *) op_code_data
) + 1;
4131 /* Directory index. */
4132 file_table
[n_files
].directory_index
=
4133 read_uleb128 (op_code_data
, & bytes_read
,
4135 op_code_data
+= bytes_read
;
4136 /* Last modification time. */
4137 file_table
[n_files
].modification_date
=
4138 read_uleb128 (op_code_data
, & bytes_read
,
4140 op_code_data
+= bytes_read
;
4142 file_table
[n_files
].length
=
4143 read_uleb128 (op_code_data
, & bytes_read
,
4149 case DW_LNE_set_discriminator
:
4150 case DW_LNE_HP_set_sequence
:
4151 /* Simply ignored. */
4155 printf (_("UNKNOWN (%u): length %d\n"),
4156 ext_op_code
, ext_op_code_len
- bytes_read
);
4159 data
+= ext_op_code_len
;
4163 /* Increment view after printing this row. */
4166 case DW_LNS_advance_pc
:
4167 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4169 if (linfo
.li_max_ops_per_insn
== 1)
4171 uladv
*= linfo
.li_min_insn_length
;
4172 state_machine_regs
.address
+= uladv
;
4174 state_machine_regs
.view
= 0;
4179 = ((state_machine_regs
.op_index
+ uladv
)
4180 / linfo
.li_max_ops_per_insn
)
4181 * linfo
.li_min_insn_length
;
4182 state_machine_regs
.address
4184 state_machine_regs
.op_index
4185 = (state_machine_regs
.op_index
+ uladv
)
4186 % linfo
.li_max_ops_per_insn
;
4188 state_machine_regs
.view
= 0;
4192 case DW_LNS_advance_line
:
4193 adv
= read_sleb128 (data
, & bytes_read
, end
);
4195 state_machine_regs
.line
+= adv
;
4198 case DW_LNS_set_file
:
4199 adv
= read_uleb128 (data
, & bytes_read
, end
);
4201 state_machine_regs
.file
= adv
;
4204 unsigned file
= state_machine_regs
.file
- 1;
4207 if (file_table
== NULL
|| n_files
== 0)
4208 printf (_("\n [Use file table entry %d]\n"), file
);
4210 else if (file
>= n_files
)
4212 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
4213 printf (_("\n <over large file table index %u>"), file
);
4215 else if ((dir
= file_table
[file
].directory_index
) == 0)
4216 /* If directory index is 0, that means current directory. */
4217 printf ("\n./%s:[++]\n", file_table
[file
].name
);
4218 else if (directory_table
== NULL
|| n_directories
== 0)
4219 printf (_("\n [Use file %s in directory table entry %d]\n"),
4220 file_table
[file
].name
, dir
);
4222 else if (dir
> n_directories
)
4224 warn (_("directory index %u > number of directories %s\n"),
4225 dir
, dwarf_vmatoa ("u", n_directories
));
4226 printf (_("\n <over large directory table entry %u>\n"), dir
);
4229 printf ("\n%s/%s:\n",
4230 /* The directory index starts counting at 1. */
4231 directory_table
[dir
- 1], file_table
[file
].name
);
4235 case DW_LNS_set_column
:
4236 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4238 state_machine_regs
.column
= uladv
;
4241 case DW_LNS_negate_stmt
:
4242 adv
= state_machine_regs
.is_stmt
;
4244 state_machine_regs
.is_stmt
= adv
;
4247 case DW_LNS_set_basic_block
:
4248 state_machine_regs
.basic_block
= 1;
4251 case DW_LNS_const_add_pc
:
4252 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4253 if (linfo
.li_max_ops_per_insn
== 1)
4255 uladv
*= linfo
.li_min_insn_length
;
4256 state_machine_regs
.address
+= uladv
;
4258 state_machine_regs
.view
= 0;
4263 = ((state_machine_regs
.op_index
+ uladv
)
4264 / linfo
.li_max_ops_per_insn
)
4265 * linfo
.li_min_insn_length
;
4266 state_machine_regs
.address
4268 state_machine_regs
.op_index
4269 = (state_machine_regs
.op_index
+ uladv
)
4270 % linfo
.li_max_ops_per_insn
;
4272 state_machine_regs
.view
= 0;
4276 case DW_LNS_fixed_advance_pc
:
4277 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4278 state_machine_regs
.address
+= uladv
;
4279 state_machine_regs
.op_index
= 0;
4280 /* Do NOT reset view. */
4283 case DW_LNS_set_prologue_end
:
4286 case DW_LNS_set_epilogue_begin
:
4289 case DW_LNS_set_isa
:
4290 uladv
= read_uleb128 (data
, & bytes_read
, end
);
4292 printf (_(" Set ISA to %lu\n"), uladv
);
4296 printf (_(" Unknown opcode %d with operands: "), op_code
);
4298 if (standard_opcodes
!= NULL
)
4299 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4301 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
4303 i
== 1 ? "" : ", ");
4310 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
4311 to the DWARF address/line matrix. */
4312 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
4313 || (xop
== DW_LNS_copy
))
4315 const unsigned int MAX_FILENAME_LENGTH
= 35;
4317 char *newFileName
= NULL
;
4318 size_t fileNameLength
;
4322 unsigned indx
= state_machine_regs
.file
- 1;
4324 if (indx
>= n_files
)
4326 warn (_("corrupt file index %u encountered\n"), indx
);
4327 fileName
= _("<corrupt>");
4330 fileName
= (char *) file_table
[indx
].name
;
4333 fileName
= _("<unknown>");
4335 fileNameLength
= strlen (fileName
);
4337 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
4339 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
4340 /* Truncate file name */
4341 strncpy (newFileName
,
4342 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
4343 MAX_FILENAME_LENGTH
+ 1);
4347 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
4348 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
4351 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
4353 if (linfo
.li_max_ops_per_insn
== 1)
4354 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
4355 newFileName
, state_machine_regs
.line
,
4356 state_machine_regs
.address
);
4358 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4359 newFileName
, state_machine_regs
.line
,
4360 state_machine_regs
.address
,
4361 state_machine_regs
.op_index
);
4365 if (linfo
.li_max_ops_per_insn
== 1)
4366 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
4367 newFileName
, state_machine_regs
.line
,
4368 state_machine_regs
.address
);
4370 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
4371 newFileName
, state_machine_regs
.line
,
4372 state_machine_regs
.address
,
4373 state_machine_regs
.op_index
);
4376 if (state_machine_regs
.view
)
4377 printf (" %6u\n", state_machine_regs
.view
);
4380 state_machine_regs
.view
++;
4382 if (xop
== -DW_LNE_end_sequence
)
4384 reset_state_machine (linfo
.li_default_is_stmt
);
4399 if (directory_table
)
4401 free (directory_table
);
4402 directory_table
= NULL
;
4413 display_debug_lines (struct dwarf_section
*section
, void *file
)
4415 unsigned char *data
= section
->start
;
4416 unsigned char *end
= data
+ section
->size
;
4418 int retValDecoded
= 1;
4420 if (do_debug_lines
== 0)
4421 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
4423 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
4424 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
4426 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
4427 retValDecoded
= display_debug_lines_decoded (section
, data
, end
, file
);
4429 if (!retValRaw
|| !retValDecoded
)
4436 find_debug_info_for_offset (unsigned long offset
)
4440 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4443 for (i
= 0; i
< num_debug_info_entries
; i
++)
4444 if (debug_information
[i
].cu_offset
== offset
)
4445 return debug_information
+ i
;
4451 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
4453 /* See gdb/gdb-index.h. */
4454 static const char * const kinds
[] =
4466 return _ (kinds
[kind
]);
4470 display_debug_pubnames_worker (struct dwarf_section
*section
,
4471 void *file ATTRIBUTE_UNUSED
,
4474 DWARF2_Internal_PubNames names
;
4475 unsigned char *start
= section
->start
;
4476 unsigned char *end
= start
+ section
->size
;
4478 /* It does not matter if this load fails,
4479 we test for that later on. */
4480 load_debug_info (file
);
4482 printf (_("Contents of the %s section:\n\n"), section
->name
);
4486 unsigned char *data
;
4487 unsigned long sec_off
;
4488 unsigned int offset_size
, initial_length_size
;
4490 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
4491 if (names
.pn_length
== 0xffffffff)
4493 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
4495 initial_length_size
= 12;
4500 initial_length_size
= 4;
4503 sec_off
= start
- section
->start
;
4504 if (sec_off
+ names
.pn_length
< sec_off
4505 || sec_off
+ names
.pn_length
> section
->size
)
4507 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
4509 sec_off
- initial_length_size
,
4510 dwarf_vmatoa ("x", names
.pn_length
));
4515 start
+= names
.pn_length
;
4517 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
4518 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
4520 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4521 && num_debug_info_entries
> 0
4522 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
4523 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4524 (unsigned long) names
.pn_offset
, section
->name
);
4526 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
4528 printf (_(" Length: %ld\n"),
4529 (long) names
.pn_length
);
4530 printf (_(" Version: %d\n"),
4532 printf (_(" Offset into .debug_info section: 0x%lx\n"),
4533 (unsigned long) names
.pn_offset
);
4534 printf (_(" Size of area in .debug_info section: %ld\n"),
4535 (long) names
.pn_size
);
4537 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
4539 static int warned
= 0;
4543 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
4551 printf (_("\n Offset Kind Name\n"));
4553 printf (_("\n Offset\tName\n"));
4557 bfd_size_type maxprint
;
4560 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
4565 data
+= offset_size
;
4568 maxprint
= (end
- data
) - 1;
4572 unsigned int kind_data
;
4573 gdb_index_symbol_kind kind
;
4574 const char *kind_name
;
4577 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
4580 /* GCC computes the kind as the upper byte in the CU index
4581 word, and then right shifts it by the CU index size.
4582 Left shift KIND to where the gdb-index.h accessor macros
4584 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
4585 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
4586 kind_name
= get_gdb_index_symbol_kind_name (kind
);
4587 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
4588 printf (" %-6lx %s,%-10s %.*s\n",
4589 (unsigned long) offset
, is_static
? _("s") : _("g"),
4590 kind_name
, (int) maxprint
, data
);
4593 printf (" %-6lx\t%.*s\n",
4594 (unsigned long) offset
, (int) maxprint
, data
);
4596 data
+= strnlen ((char *) data
, maxprint
) + 1;
4607 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
4609 return display_debug_pubnames_worker (section
, file
, 0);
4613 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
4615 return display_debug_pubnames_worker (section
, file
, 1);
4619 display_debug_macinfo (struct dwarf_section
*section
,
4620 void *file ATTRIBUTE_UNUSED
)
4622 unsigned char *start
= section
->start
;
4623 unsigned char *end
= start
+ section
->size
;
4624 unsigned char *curr
= start
;
4625 unsigned int bytes_read
;
4626 enum dwarf_macinfo_record_type op
;
4628 printf (_("Contents of the %s section:\n\n"), section
->name
);
4632 unsigned int lineno
;
4633 const unsigned char *string
;
4635 op
= (enum dwarf_macinfo_record_type
) *curr
;
4640 case DW_MACINFO_start_file
:
4642 unsigned int filenum
;
4644 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4646 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
4649 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
4654 case DW_MACINFO_end_file
:
4655 printf (_(" DW_MACINFO_end_file\n"));
4658 case DW_MACINFO_define
:
4659 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4662 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4663 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
4667 case DW_MACINFO_undef
:
4668 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
4671 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4672 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
4676 case DW_MACINFO_vendor_ext
:
4678 unsigned int constant
;
4680 constant
= read_uleb128 (curr
, & bytes_read
, end
);
4683 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4684 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
4694 /* Given LINE_OFFSET into the .debug_line section, attempt to return
4695 filename and dirname corresponding to file name table entry with index
4696 FILEIDX. Return NULL on failure. */
4698 static unsigned char *
4699 get_line_filename_and_dirname (dwarf_vma line_offset
,
4701 unsigned char **dir_name
)
4703 struct dwarf_section
*section
= &debug_displays
[line
].section
;
4704 unsigned char *hdrptr
, *dirtable
, *file_name
;
4705 unsigned int offset_size
, initial_length_size
;
4706 unsigned int version
, opcode_base
, bytes_read
;
4707 dwarf_vma length
, diridx
;
4708 const unsigned char * end
;
4711 if (section
->start
== NULL
4712 || line_offset
>= section
->size
4716 hdrptr
= section
->start
+ line_offset
;
4717 end
= section
->start
+ section
->size
;
4719 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
4720 if (length
== 0xffffffff)
4722 /* This section is 64-bit DWARF 3. */
4723 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
4725 initial_length_size
= 12;
4730 initial_length_size
= 4;
4732 if (length
+ initial_length_size
< length
4733 || length
+ initial_length_size
> section
->size
)
4736 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
4737 if (version
!= 2 && version
!= 3 && version
!= 4)
4739 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
4741 hdrptr
++; /* Skip max_ops_per_insn. */
4742 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
4744 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
4745 if (opcode_base
== 0)
4748 hdrptr
+= opcode_base
- 1;
4753 /* Skip over dirname table. */
4754 while (*hdrptr
!= '\0')
4756 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4760 hdrptr
++; /* Skip the NUL at the end of the table. */
4762 /* Now skip over preceding filename table entries. */
4763 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
4765 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4766 read_uleb128 (hdrptr
, &bytes_read
, end
);
4767 hdrptr
+= bytes_read
;
4768 read_uleb128 (hdrptr
, &bytes_read
, end
);
4769 hdrptr
+= bytes_read
;
4770 read_uleb128 (hdrptr
, &bytes_read
, end
);
4771 hdrptr
+= bytes_read
;
4773 if (hdrptr
>= end
|| *hdrptr
== '\0')
4777 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4780 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
4783 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
4784 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
4785 if (dirtable
>= end
|| *dirtable
== '\0')
4787 *dir_name
= dirtable
;
4792 display_debug_macro (struct dwarf_section
*section
,
4795 unsigned char *start
= section
->start
;
4796 unsigned char *end
= start
+ section
->size
;
4797 unsigned char *curr
= start
;
4798 unsigned char *extended_op_buf
[256];
4799 unsigned int bytes_read
;
4801 load_debug_section (str
, file
);
4802 load_debug_section (line
, file
);
4804 printf (_("Contents of the %s section:\n\n"), section
->name
);
4808 unsigned int lineno
, version
, flags
;
4809 unsigned int offset_size
= 4;
4810 const unsigned char *string
;
4811 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
4812 unsigned char **extended_ops
= NULL
;
4814 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
4815 if (version
!= 4 && version
!= 5)
4817 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
4822 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
4825 printf (_(" Offset: 0x%lx\n"),
4826 (unsigned long) sec_offset
);
4827 printf (_(" Version: %d\n"), version
);
4828 printf (_(" Offset size: %d\n"), offset_size
);
4831 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
4832 printf (_(" Offset into .debug_line: 0x%lx\n"),
4833 (unsigned long) line_offset
);
4837 unsigned int i
, count
, op
;
4840 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
4842 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
4843 extended_ops
= extended_op_buf
;
4846 printf (_(" Extension opcode arguments:\n"));
4847 for (i
= 0; i
< count
; i
++)
4849 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4850 extended_ops
[op
] = curr
;
4851 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
4854 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
4857 printf (_(" DW_MACRO_%02x arguments: "), op
);
4858 for (n
= 0; n
< nargs
; n
++)
4862 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
4863 printf ("%s%s", get_FORM_name (form
),
4864 n
== nargs
- 1 ? "\n" : ", ");
4874 case DW_FORM_block1
:
4875 case DW_FORM_block2
:
4876 case DW_FORM_block4
:
4878 case DW_FORM_string
:
4880 case DW_FORM_sec_offset
:
4883 error (_("Invalid extension opcode form %s\n"),
4884 get_FORM_name (form
));
4900 error (_(".debug_macro section not zero terminated\n"));
4904 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4910 case DW_MACRO_start_file
:
4912 unsigned int filenum
;
4913 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4915 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4917 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4920 if ((flags
& 2) == 0)
4921 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
4924 = get_line_filename_and_dirname (line_offset
, filenum
,
4926 if (file_name
== NULL
)
4927 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
4930 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4932 dir_name
!= NULL
? (const char *) dir_name
: "",
4933 dir_name
!= NULL
? "/" : "", file_name
);
4937 case DW_MACRO_end_file
:
4938 printf (_(" DW_MACRO_end_file\n"));
4941 case DW_MACRO_define
:
4942 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4945 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4946 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
4950 case DW_MACRO_undef
:
4951 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4954 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4955 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
4959 case DW_MACRO_define_strp
:
4960 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4962 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4963 string
= fetch_indirect_string (offset
);
4964 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
4968 case DW_MACRO_undef_strp
:
4969 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4971 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4972 string
= fetch_indirect_string (offset
);
4973 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
4977 case DW_MACRO_import
:
4978 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4979 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
4980 (unsigned long) offset
);
4983 case DW_MACRO_define_sup
:
4984 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4986 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4987 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
4988 lineno
, (unsigned long) offset
);
4991 case DW_MACRO_undef_sup
:
4992 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4994 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4995 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
4996 lineno
, (unsigned long) offset
);
4999 case DW_MACRO_import_sup
:
5000 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
5001 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
5002 (unsigned long) offset
);
5006 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
5008 error (_(" Unknown macro opcode %02x seen\n"), op
);
5013 /* Skip over unhandled opcodes. */
5015 unsigned char *desc
= extended_ops
[op
];
5016 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
5020 printf (_(" DW_MACRO_%02x\n"), op
);
5023 printf (_(" DW_MACRO_%02x -"), op
);
5024 for (n
= 0; n
< nargs
; n
++)
5028 /* DW_FORM_implicit_const is not expected here. */
5029 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
5031 = read_and_display_attr_value (0, val
, 0,
5032 curr
, end
, 0, 0, offset_size
,
5033 version
, NULL
, 0, NULL
,
5051 display_debug_abbrev (struct dwarf_section
*section
,
5052 void *file ATTRIBUTE_UNUSED
)
5054 abbrev_entry
*entry
;
5055 unsigned char *start
= section
->start
;
5056 unsigned char *end
= start
+ section
->size
;
5058 printf (_("Contents of the %s section:\n\n"), section
->name
);
5062 unsigned char *last
;
5067 start
= process_abbrev_section (start
, end
);
5069 if (first_abbrev
== NULL
)
5072 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
5074 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5078 printf (" %ld %s [%s]\n",
5080 get_TAG_name (entry
->tag
),
5081 entry
->children
? _("has children") : _("no children"));
5083 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5085 printf (" %-18s %s",
5086 get_AT_name (attr
->attribute
),
5087 get_FORM_name (attr
->form
));
5088 if (attr
->form
== DW_FORM_implicit_const
)
5089 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
5101 /* Return true when ADDR is the maximum address, when addresses are
5102 POINTER_SIZE bytes long. */
5105 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
5107 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
5108 return ((addr
& mask
) == mask
);
5111 /* Display a view pair list starting at *VSTART_PTR and ending at
5112 VLISTEND within SECTION. */
5115 display_view_pair_list (struct dwarf_section
*section
,
5116 unsigned char **vstart_ptr
,
5117 unsigned int debug_info_entry
,
5118 unsigned char *vlistend
)
5120 unsigned char *vstart
= *vstart_ptr
;
5121 unsigned char *section_end
= section
->start
+ section
->size
;
5122 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5124 if (vlistend
< section_end
)
5125 section_end
= vlistend
;
5129 while (vstart
< section_end
)
5131 dwarf_vma off
= vstart
- section
->start
;
5132 dwarf_vma vbegin
, vend
;
5134 unsigned int bytes_read
;
5135 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5136 vstart
+= bytes_read
;
5137 if (vstart
== section_end
)
5139 vstart
-= bytes_read
;
5143 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5144 vstart
+= bytes_read
;
5146 printf (" %8.8lx ", (unsigned long) off
);
5148 print_dwarf_view (vbegin
, pointer_size
, 1);
5149 print_dwarf_view (vend
, pointer_size
, 1);
5150 printf (_("location view pair\n"));
5154 *vstart_ptr
= vstart
;
5157 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
5160 display_loc_list (struct dwarf_section
*section
,
5161 unsigned char **start_ptr
,
5162 unsigned int debug_info_entry
,
5164 dwarf_vma base_address
,
5165 unsigned char **vstart_ptr
,
5168 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5169 unsigned char *section_end
= section
->start
+ section
->size
;
5170 unsigned long cu_offset
;
5171 unsigned int pointer_size
;
5172 unsigned int offset_size
;
5177 unsigned short length
;
5178 int need_frame_base
;
5180 if (debug_info_entry
>= num_debug_info_entries
)
5182 warn (_("No debug information available for loc lists of entry: %u\n"),
5187 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5188 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5189 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5190 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5192 if (pointer_size
< 2 || pointer_size
> 8)
5194 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5195 pointer_size
, debug_info_entry
);
5201 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5202 dwarf_vma vbegin
= vm1
, vend
= vm1
;
5204 if (start
+ 2 * pointer_size
> section_end
)
5206 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5207 (unsigned long) offset
);
5211 printf (" %8.8lx ", (unsigned long) off
);
5213 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
5214 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
5216 if (begin
== 0 && end
== 0)
5218 /* PR 18374: In a object file we can have a location list that
5219 starts with a begin and end of 0 because there are relocations
5220 that need to be applied to the addresses. Actually applying
5221 the relocations now does not help as they will probably resolve
5222 to 0, since the object file has not been fully linked. Real
5223 end of list markers will not have any relocations against them. */
5224 if (! reloc_at (section
, off
)
5225 && ! reloc_at (section
, off
+ pointer_size
))
5227 printf (_("<End of list>\n"));
5232 /* Check base address specifiers. */
5233 if (is_max_address (begin
, pointer_size
)
5234 && !is_max_address (end
, pointer_size
))
5237 print_dwarf_vma (begin
, pointer_size
);
5238 print_dwarf_vma (end
, pointer_size
);
5239 printf (_("(base address)\n"));
5245 unsigned int bytes_read
;
5247 off
= offset
+ (vstart
- *start_ptr
);
5249 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5250 vstart
+= bytes_read
;
5251 print_dwarf_view (vbegin
, pointer_size
, 1);
5253 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5254 vstart
+= bytes_read
;
5255 print_dwarf_view (vend
, pointer_size
, 1);
5257 printf (_("views at %8.8lx for:\n %*s "),
5258 (unsigned long) off
, 8, "");
5261 if (start
+ 2 > section_end
)
5263 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5264 (unsigned long) offset
);
5268 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5270 if (start
+ length
> section_end
)
5272 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5273 (unsigned long) offset
);
5277 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5278 print_dwarf_vma (end
+ base_address
, pointer_size
);
5281 need_frame_base
= decode_location_expression (start
,
5286 cu_offset
, section
);
5289 if (need_frame_base
&& !has_frame_base
)
5290 printf (_(" [without DW_AT_frame_base]"));
5292 if (begin
== end
&& vbegin
== vend
)
5293 fputs (_(" (start == end)"), stdout
);
5294 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5295 fputs (_(" (start > end)"), stdout
);
5303 *vstart_ptr
= vstart
;
5306 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
5309 display_loclists_list (struct dwarf_section
*section
,
5310 unsigned char **start_ptr
,
5311 unsigned int debug_info_entry
,
5313 dwarf_vma base_address
,
5314 unsigned char **vstart_ptr
,
5317 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5318 unsigned char *section_end
= section
->start
+ section
->size
;
5319 unsigned long cu_offset
;
5320 unsigned int pointer_size
;
5321 unsigned int offset_size
;
5323 unsigned int bytes_read
;
5325 /* Initialize it due to a false compiler warning. */
5326 dwarf_vma begin
= -1, vbegin
= -1;
5327 dwarf_vma end
= -1, vend
= -1;
5329 int need_frame_base
;
5331 if (debug_info_entry
>= num_debug_info_entries
)
5333 warn (_("No debug information available for "
5334 "loclists lists of entry: %u\n"),
5339 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5340 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5341 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5342 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5344 if (pointer_size
< 2 || pointer_size
> 8)
5346 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5347 pointer_size
, debug_info_entry
);
5353 dwarf_vma off
= offset
+ (start
- *start_ptr
);
5354 enum dwarf_location_list_entry_type llet
;
5356 if (start
+ 1 > section_end
)
5358 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5359 (unsigned long) offset
);
5363 printf (" %8.8lx ", (unsigned long) off
);
5365 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
5367 if (vstart
&& llet
== DW_LLE_offset_pair
)
5369 off
= offset
+ (vstart
- *start_ptr
);
5371 vbegin
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5372 vstart
+= bytes_read
;
5373 print_dwarf_view (vbegin
, pointer_size
, 1);
5375 vend
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5376 vstart
+= bytes_read
;
5377 print_dwarf_view (vend
, pointer_size
, 1);
5379 printf (_("views at %8.8lx for:\n %*s "),
5380 (unsigned long) off
, 8, "");
5385 case DW_LLE_end_of_list
:
5386 printf (_("<End of list>\n"));
5388 case DW_LLE_offset_pair
:
5389 begin
= read_uleb128 (start
, &bytes_read
, section_end
);
5390 start
+= bytes_read
;
5391 end
= read_uleb128 (start
, &bytes_read
, section_end
);
5392 start
+= bytes_read
;
5394 case DW_LLE_base_address
:
5395 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
5397 print_dwarf_vma (base_address
, pointer_size
);
5398 printf (_("(base address)\n"));
5400 #ifdef DW_LLE_view_pair
5401 case DW_LLE_view_pair
:
5403 printf (_("View pair entry in loclist with locviews attribute\n"));
5404 vbegin
= read_uleb128 (start
, &bytes_read
, section_end
);
5405 start
+= bytes_read
;
5406 print_dwarf_view (vbegin
, pointer_size
, 1);
5408 vend
= read_uleb128 (start
, &bytes_read
, section_end
);
5409 start
+= bytes_read
;
5410 print_dwarf_view (vend
, pointer_size
, 1);
5412 printf (_("views for:\n"));
5416 error (_("Invalid location list entry type %d\n"), llet
);
5419 if (llet
== DW_LLE_end_of_list
)
5421 if (llet
!= DW_LLE_offset_pair
)
5424 if (start
+ 2 > section_end
)
5426 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5427 (unsigned long) offset
);
5431 length
= read_uleb128 (start
, &bytes_read
, section_end
);
5432 start
+= bytes_read
;
5434 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5435 print_dwarf_vma (end
+ base_address
, pointer_size
);
5438 need_frame_base
= decode_location_expression (start
,
5443 cu_offset
, section
);
5446 if (need_frame_base
&& !has_frame_base
)
5447 printf (_(" [without DW_AT_frame_base]"));
5449 if (begin
== end
&& vbegin
== vend
)
5450 fputs (_(" (start == end)"), stdout
);
5451 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
5452 fputs (_(" (start > end)"), stdout
);
5460 if (vbegin
!= vm1
|| vend
!= vm1
)
5461 printf (_("Trailing view pair not used in a range"));
5464 *vstart_ptr
= vstart
;
5467 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
5468 right-adjusted in a field of length LEN, and followed by a space. */
5471 print_addr_index (unsigned int idx
, unsigned int len
)
5473 static char buf
[15];
5474 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
5475 printf ("%*s ", len
, buf
);
5478 /* Display a location list from a .dwo section. It uses address indexes rather
5479 than embedded addresses. This code closely follows display_loc_list, but the
5480 two are sufficiently different that combining things is very ugly. */
5483 display_loc_list_dwo (struct dwarf_section
*section
,
5484 unsigned char **start_ptr
,
5485 unsigned int debug_info_entry
,
5487 unsigned char **vstart_ptr
,
5490 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
5491 unsigned char *section_end
= section
->start
+ section
->size
;
5492 unsigned long cu_offset
;
5493 unsigned int pointer_size
;
5494 unsigned int offset_size
;
5497 unsigned short length
;
5498 int need_frame_base
;
5500 unsigned int bytes_read
;
5502 if (debug_info_entry
>= num_debug_info_entries
)
5504 warn (_("No debug information for loc lists of entry: %u\n"),
5509 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
5510 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
5511 offset_size
= debug_information
[debug_info_entry
].offset_size
;
5512 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
5514 if (pointer_size
< 2 || pointer_size
> 8)
5516 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
5517 pointer_size
, debug_info_entry
);
5523 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
5525 if (start
>= section_end
)
5527 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5528 (unsigned long) offset
);
5532 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
5545 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
5547 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5548 vstart
+= bytes_read
;
5549 print_dwarf_view (view
, 8, 1);
5551 view
= read_uleb128 (vstart
, &bytes_read
, section_end
);
5552 vstart
+= bytes_read
;
5553 print_dwarf_view (view
, 8, 1);
5555 printf (_("views at %8.8lx for:\n %*s "),
5556 (unsigned long) off
, 8, "");
5564 case 0: /* A terminating entry. */
5566 *vstart_ptr
= vstart
;
5567 printf (_("<End of list>\n"));
5569 case 1: /* A base-address entry. */
5570 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5571 start
+= bytes_read
;
5572 print_addr_index (idx
, 8);
5573 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
5574 printf (_("(base address selection entry)\n"));
5576 case 2: /* A start/end entry. */
5577 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5578 start
+= bytes_read
;
5579 print_addr_index (idx
, 8);
5580 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5581 start
+= bytes_read
;
5582 print_addr_index (idx
, 8);
5584 case 3: /* A start/length entry. */
5585 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
5586 start
+= bytes_read
;
5587 print_addr_index (idx
, 8);
5588 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5589 printf ("%08x ", idx
);
5591 case 4: /* An offset pair entry. */
5592 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5593 printf ("%08x ", idx
);
5594 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
5595 printf ("%08x ", idx
);
5598 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
5600 *vstart_ptr
= vstart
;
5604 if (start
+ 2 > section_end
)
5606 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5607 (unsigned long) offset
);
5611 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
5612 if (start
+ length
> section_end
)
5614 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
5615 (unsigned long) offset
);
5620 need_frame_base
= decode_location_expression (start
,
5625 cu_offset
, section
);
5628 if (need_frame_base
&& !has_frame_base
)
5629 printf (_(" [without DW_AT_frame_base]"));
5637 *vstart_ptr
= vstart
;
5640 /* Sort array of indexes in ascending order of loc_offsets[idx] and
5643 static dwarf_vma
*loc_offsets
, *loc_views
;
5646 loc_offsets_compar (const void *ap
, const void *bp
)
5648 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
5649 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
5651 int ret
= (a
> b
) - (b
> a
);
5655 a
= loc_views
[*(const unsigned int *) ap
];
5656 b
= loc_views
[*(const unsigned int *) bp
];
5658 ret
= (a
> b
) - (b
> a
);
5664 display_debug_loc (struct dwarf_section
*section
, void *file
)
5666 unsigned char *start
= section
->start
, *vstart
= NULL
;
5667 unsigned long bytes
;
5668 unsigned char *section_begin
= start
;
5669 unsigned int num_loc_list
= 0;
5670 unsigned long last_offset
= 0;
5671 unsigned long last_view
= 0;
5672 unsigned int first
= 0;
5675 int seen_first_offset
= 0;
5676 int locs_sorted
= 1;
5677 unsigned char *next
= start
, *vnext
= vstart
;
5678 unsigned int *array
= NULL
;
5679 const char *suffix
= strrchr (section
->name
, '.');
5681 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
5682 dwarf_vma expected_start
= 0;
5684 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
5687 bytes
= section
->size
;
5691 printf (_("\nThe %s section is empty.\n"), section
->name
);
5697 unsigned char *hdrptr
= section_begin
;
5698 dwarf_vma ll_length
;
5699 unsigned short ll_version
;
5700 unsigned char *end
= section_begin
+ section
->size
;
5701 unsigned char address_size
, segment_selector_size
;
5702 uint32_t offset_entry_count
;
5704 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
5705 if (ll_length
== 0xffffffff)
5706 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
5708 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
5709 if (ll_version
!= 5)
5711 warn (_("The %s section contains corrupt or "
5712 "unsupported version number: %d.\n"),
5713 section
->name
, ll_version
);
5717 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
5719 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
5720 if (segment_selector_size
!= 0)
5722 warn (_("The %s section contains "
5723 "unsupported segment selector size: %d.\n"),
5724 section
->name
, segment_selector_size
);
5728 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
5729 if (offset_entry_count
!= 0)
5731 warn (_("The %s section contains "
5732 "unsupported offset entry count: %d.\n"),
5733 section
->name
, offset_entry_count
);
5737 expected_start
= hdrptr
- section_begin
;
5740 if (load_debug_info (file
) == 0)
5742 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5747 /* Check the order of location list in .debug_info section. If
5748 offsets of location lists are in the ascending order, we can
5749 use `debug_information' directly. */
5750 for (i
= 0; i
< num_debug_info_entries
; i
++)
5754 num
= debug_information
[i
].num_loc_offsets
;
5755 if (num
> num_loc_list
)
5758 /* Check if we can use `debug_information' directly. */
5759 if (locs_sorted
&& num
!= 0)
5761 if (!seen_first_offset
)
5763 /* This is the first location list. */
5764 last_offset
= debug_information
[i
].loc_offsets
[0];
5765 last_view
= debug_information
[i
].loc_views
[0];
5767 seen_first_offset
= 1;
5773 for (; j
< num
; j
++)
5776 debug_information
[i
].loc_offsets
[j
]
5777 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
5778 && last_view
> debug_information
[i
].loc_views
[j
]))
5783 last_offset
= debug_information
[i
].loc_offsets
[j
];
5784 last_view
= debug_information
[i
].loc_views
[j
];
5789 if (!seen_first_offset
)
5790 error (_("No location lists in .debug_info section!\n"));
5792 if (debug_information
[first
].num_loc_offsets
> 0
5793 && debug_information
[first
].loc_offsets
[0] != expected_start
5794 && debug_information
[first
].loc_views
[0] != expected_start
)
5795 warn (_("Location lists in %s section start at 0x%s\n"),
5797 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
5800 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
5801 printf (_("Contents of the %s section:\n\n"), section
->name
);
5802 if (reloc_at (section
, 0))
5803 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
5804 printf (_(" Offset Begin End Expression\n"));
5806 seen_first_offset
= 0;
5807 for (i
= first
; i
< num_debug_info_entries
; i
++)
5809 dwarf_vma offset
, voffset
;
5810 dwarf_vma base_address
;
5816 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
5818 loc_offsets
= debug_information
[i
].loc_offsets
;
5819 loc_views
= debug_information
[i
].loc_views
;
5820 qsort (array
, debug_information
[i
].num_loc_offsets
,
5821 sizeof (*array
), loc_offsets_compar
);
5824 int adjacent_view_loclists
= 1;
5825 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
5827 j
= locs_sorted
? k
: array
[k
];
5829 && (debug_information
[i
].loc_offsets
[locs_sorted
5830 ? k
- 1 : array
[k
- 1]]
5831 == debug_information
[i
].loc_offsets
[j
])
5832 && (debug_information
[i
].loc_views
[locs_sorted
5833 ? k
- 1 : array
[k
- 1]]
5834 == debug_information
[i
].loc_views
[j
]))
5836 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
5837 offset
= debug_information
[i
].loc_offsets
[j
];
5838 next
= section_begin
+ offset
;
5839 voffset
= debug_information
[i
].loc_views
[j
];
5841 vnext
= section_begin
+ voffset
;
5844 base_address
= debug_information
[i
].base_address
;
5846 if (vnext
&& vnext
< next
)
5849 display_view_pair_list (section
, &vstart
, i
, next
);
5854 if (!seen_first_offset
|| !adjacent_view_loclists
)
5855 seen_first_offset
= 1;
5859 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
5860 (unsigned long) (start
- section_begin
),
5861 (unsigned long) offset
);
5862 else if (start
> next
)
5863 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
5864 (unsigned long) (start
- section_begin
),
5865 (unsigned long) offset
);
5870 if (offset
>= bytes
)
5872 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
5873 (unsigned long) offset
);
5877 if (vnext
&& voffset
>= bytes
)
5879 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
5880 (unsigned long) voffset
);
5887 display_loc_list_dwo (section
, &start
, i
, offset
,
5888 &vstart
, has_frame_base
);
5890 display_loc_list (section
, &start
, i
, offset
, base_address
,
5891 &vstart
, has_frame_base
);
5896 warn (_("DWO is not yet supported.\n"));
5898 display_loclists_list (section
, &start
, i
, offset
, base_address
,
5899 &vstart
, has_frame_base
);
5902 /* FIXME: this arrangement is quite simplistic. Nothing
5903 requires locview lists to be adjacent to corresponding
5904 loclists, and a single loclist could be augmented by
5905 different locview lists, and vice-versa, unlikely as it
5906 is that it would make sense to do so. Hopefully we'll
5907 have view pair support built into loclists before we ever
5908 need to address all these possibilities. */
5909 if (adjacent_view_loclists
&& vnext
5910 && vnext
!= start
&& vstart
!= next
)
5912 adjacent_view_loclists
= 0;
5913 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
5916 if (vnext
&& vnext
== start
)
5917 display_view_pair_list (section
, &start
, i
, vstart
);
5921 if (start
< section
->start
+ section
->size
)
5922 warn (_("There are %ld unused bytes at the end of section %s\n"),
5923 (long) (section
->start
+ section
->size
- start
), section
->name
);
5930 display_debug_str (struct dwarf_section
*section
,
5931 void *file ATTRIBUTE_UNUSED
)
5933 unsigned char *start
= section
->start
;
5934 unsigned long bytes
= section
->size
;
5935 dwarf_vma addr
= section
->address
;
5939 printf (_("\nThe %s section is empty.\n"), section
->name
);
5943 printf (_("Contents of the %s section:\n\n"), section
->name
);
5951 lbytes
= (bytes
> 16 ? 16 : bytes
);
5953 printf (" 0x%8.8lx ", (unsigned long) addr
);
5955 for (j
= 0; j
< 16; j
++)
5958 printf ("%2.2x", start
[j
]);
5966 for (j
= 0; j
< lbytes
; j
++)
5969 if (k
>= ' ' && k
< 0x80)
5988 display_debug_info (struct dwarf_section
*section
, void *file
)
5990 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
5994 display_debug_types (struct dwarf_section
*section
, void *file
)
5996 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
6000 display_trace_info (struct dwarf_section
*section
, void *file
)
6002 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
6006 display_debug_aranges (struct dwarf_section
*section
,
6007 void *file ATTRIBUTE_UNUSED
)
6009 unsigned char *start
= section
->start
;
6010 unsigned char *end
= start
+ section
->size
;
6012 printf (_("Contents of the %s section:\n\n"), section
->name
);
6014 /* It does not matter if this load fails,
6015 we test for that later on. */
6016 load_debug_info (file
);
6020 unsigned char *hdrptr
;
6021 DWARF2_Internal_ARange arange
;
6022 unsigned char *addr_ranges
;
6025 unsigned long sec_off
;
6026 unsigned char address_size
;
6028 unsigned int offset_size
;
6029 unsigned int initial_length_size
;
6033 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
6034 if (arange
.ar_length
== 0xffffffff)
6036 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
6038 initial_length_size
= 12;
6043 initial_length_size
= 4;
6046 sec_off
= hdrptr
- section
->start
;
6047 if (sec_off
+ arange
.ar_length
< sec_off
6048 || sec_off
+ arange
.ar_length
> section
->size
)
6050 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
6052 sec_off
- initial_length_size
,
6053 dwarf_vmatoa ("x", arange
.ar_length
));
6057 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
6058 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
6060 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
6061 && num_debug_info_entries
> 0
6062 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
6063 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
6064 (unsigned long) arange
.ar_info_offset
, section
->name
);
6066 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
6067 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
6069 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
6071 /* PR 19872: A version number of 0 probably means that there is
6072 padding at the end of the .debug_aranges section. Gold puts
6073 it there when performing an incremental link, for example.
6074 So do not generate a warning in this case. */
6075 if (arange
.ar_version
)
6076 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
6080 printf (_(" Length: %ld\n"),
6081 (long) arange
.ar_length
);
6082 printf (_(" Version: %d\n"), arange
.ar_version
);
6083 printf (_(" Offset into .debug_info: 0x%lx\n"),
6084 (unsigned long) arange
.ar_info_offset
);
6085 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6086 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6088 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
6090 /* PR 17512: file: 001-108546-0.001:0.1. */
6091 if (address_size
== 0 || address_size
> 8)
6093 error (_("Invalid address size in %s section!\n"),
6098 /* The DWARF spec does not require that the address size be a power
6099 of two, but we do. This will have to change if we ever encounter
6100 an uneven architecture. */
6101 if ((address_size
& (address_size
- 1)) != 0)
6103 warn (_("Pointer size + Segment size is not a power of two.\n"));
6107 if (address_size
> 4)
6108 printf (_("\n Address Length\n"));
6110 printf (_("\n Address Length\n"));
6112 addr_ranges
= hdrptr
;
6114 /* Must pad to an alignment boundary that is twice the address size. */
6115 excess
= (hdrptr
- start
) % (2 * address_size
);
6117 addr_ranges
+= (2 * address_size
) - excess
;
6119 start
+= arange
.ar_length
+ initial_length_size
;
6121 while (addr_ranges
+ 2 * address_size
<= start
)
6123 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
6124 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
6127 print_dwarf_vma (address
, address_size
);
6128 print_dwarf_vma (length
, address_size
);
6138 /* Comparison function for qsort. */
6140 comp_addr_base (const void * v0
, const void * v1
)
6142 debug_info
* info0
= (debug_info
*) v0
;
6143 debug_info
* info1
= (debug_info
*) v1
;
6144 return info0
->addr_base
- info1
->addr_base
;
6147 /* Display the debug_addr section. */
6149 display_debug_addr (struct dwarf_section
*section
,
6152 debug_info
**debug_addr_info
;
6153 unsigned char *entry
;
6158 if (section
->size
== 0)
6160 printf (_("\nThe %s section is empty.\n"), section
->name
);
6164 if (load_debug_info (file
) == 0)
6166 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6171 printf (_("Contents of the %s section:\n\n"), section
->name
);
6173 /* PR 17531: file: cf38d01b.
6174 We use xcalloc because a corrupt file may not have initialised all of the
6175 fields in the debug_info structure, which means that the sort below might
6176 try to move uninitialised data. */
6177 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
6178 sizeof (debug_info
*));
6181 for (i
= 0; i
< num_debug_info_entries
; i
++)
6182 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
6184 /* PR 17531: file: cf38d01b. */
6185 if (debug_information
[i
].addr_base
>= section
->size
)
6186 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
6187 (unsigned long) debug_information
[i
].addr_base
, i
);
6189 debug_addr_info
[count
++] = debug_information
+ i
;
6192 /* Add a sentinel to make iteration convenient. */
6193 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
6194 debug_addr_info
[count
]->addr_base
= section
->size
;
6195 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
6197 for (i
= 0; i
< count
; i
++)
6200 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
6202 printf (_(" For compilation unit at offset 0x%s:\n"),
6203 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
6205 printf (_("\tIndex\tAddress\n"));
6206 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
6207 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
6211 dwarf_vma base
= byte_get (entry
, address_size
);
6212 printf (_("\t%d:\t"), idx
);
6213 print_dwarf_vma (base
, address_size
);
6215 entry
+= address_size
;
6221 free (debug_addr_info
);
6225 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
6227 display_debug_str_offsets (struct dwarf_section
*section
,
6228 void *file ATTRIBUTE_UNUSED
)
6230 if (section
->size
== 0)
6232 printf (_("\nThe %s section is empty.\n"), section
->name
);
6235 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
6236 what the offset size is for this section. */
6240 /* Each debug_information[x].range_lists[y] gets this representation for
6241 sorting purposes. */
6245 /* The debug_information[x].range_lists[y] value. */
6246 dwarf_vma ranges_offset
;
6248 /* Original debug_information to find parameters of the data. */
6249 debug_info
*debug_info_p
;
6252 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
6255 range_entry_compar (const void *ap
, const void *bp
)
6257 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
6258 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
6259 const dwarf_vma a
= a_re
->ranges_offset
;
6260 const dwarf_vma b
= b_re
->ranges_offset
;
6262 return (a
> b
) - (b
> a
);
6266 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
6267 unsigned int pointer_size
, unsigned long offset
,
6268 unsigned long base_address
)
6270 while (start
< finish
)
6275 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6276 if (start
>= finish
)
6278 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6280 printf (" %8.8lx ", offset
);
6282 if (begin
== 0 && end
== 0)
6284 printf (_("<End of list>\n"));
6288 /* Check base address specifiers. */
6289 if (is_max_address (begin
, pointer_size
)
6290 && !is_max_address (end
, pointer_size
))
6293 print_dwarf_vma (begin
, pointer_size
);
6294 print_dwarf_vma (end
, pointer_size
);
6295 printf ("(base address)\n");
6299 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6300 print_dwarf_vma (end
+ base_address
, pointer_size
);
6303 fputs (_("(start == end)"), stdout
);
6304 else if (begin
> end
)
6305 fputs (_("(start > end)"), stdout
);
6312 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
6313 unsigned int pointer_size
, unsigned long offset
,
6314 unsigned long base_address
)
6316 unsigned char *next
= start
;
6320 unsigned long off
= offset
+ (start
- next
);
6321 enum dwarf_range_list_entry rlet
;
6322 /* Initialize it due to a false compiler warning. */
6323 dwarf_vma begin
= -1, length
, end
= -1;
6324 unsigned int bytes_read
;
6326 if (start
+ 1 > finish
)
6328 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
6333 printf (" %8.8lx ", off
);
6335 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
6339 case DW_RLE_end_of_list
:
6340 printf (_("<End of list>\n"));
6342 case DW_RLE_base_address
:
6343 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
6344 print_dwarf_vma (base_address
, pointer_size
);
6345 printf (_("(base address)\n"));
6347 case DW_RLE_start_length
:
6348 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6349 length
= read_uleb128 (start
, &bytes_read
, finish
);
6350 start
+= bytes_read
;
6351 end
= begin
+ length
;
6353 case DW_RLE_offset_pair
:
6354 begin
= read_uleb128 (start
, &bytes_read
, finish
);
6355 start
+= bytes_read
;
6356 end
= read_uleb128 (start
, &bytes_read
, finish
);
6357 start
+= bytes_read
;
6359 case DW_RLE_start_end
:
6360 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
6361 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
6364 error (_("Invalid range list entry type %d\n"), rlet
);
6365 rlet
= DW_RLE_end_of_list
;
6368 if (rlet
== DW_RLE_end_of_list
)
6370 if (rlet
== DW_RLE_base_address
)
6373 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6374 print_dwarf_vma (end
+ base_address
, pointer_size
);
6377 fputs (_("(start == end)"), stdout
);
6378 else if (begin
> end
)
6379 fputs (_("(start > end)"), stdout
);
6386 display_debug_ranges (struct dwarf_section
*section
,
6387 void *file ATTRIBUTE_UNUSED
)
6389 unsigned char *start
= section
->start
;
6390 unsigned char *last_start
= start
;
6391 unsigned long bytes
= section
->size
;
6392 unsigned char *section_begin
= start
;
6393 unsigned char *finish
= start
+ bytes
;
6394 unsigned int num_range_list
, i
;
6395 struct range_entry
*range_entries
, *range_entry_fill
;
6396 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
6397 /* Initialize it due to a false compiler warning. */
6398 unsigned char address_size
= 0;
6402 printf (_("\nThe %s section is empty.\n"), section
->name
);
6408 dwarf_vma initial_length
;
6409 unsigned int initial_length_size
;
6410 unsigned char segment_selector_size
;
6411 unsigned int offset_size
, offset_entry_count
;
6412 unsigned short version
;
6414 /* Get and check the length of the block. */
6415 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
6417 if (initial_length
== 0xffffffff)
6419 /* This section is 64-bit DWARF 3. */
6420 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
6422 initial_length_size
= 12;
6427 initial_length_size
= 4;
6430 if (initial_length
+ initial_length_size
> section
->size
)
6432 /* If the length field has a relocation against it, then we should
6433 not complain if it is inaccurate (and probably negative).
6434 It is copied from .debug_line handling code. */
6435 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
6437 initial_length
= (finish
- start
) - initial_length_size
;
6441 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
6442 (long) initial_length
);
6447 /* Get and check the version number. */
6448 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
6452 warn (_("Only DWARF version 5 debug_rnglists info "
6453 "is currently supported.\n"));
6457 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
6459 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
6460 if (segment_selector_size
!= 0)
6462 warn (_("The %s section contains "
6463 "unsupported segment selector size: %d.\n"),
6464 section
->name
, segment_selector_size
);
6468 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
6469 if (offset_entry_count
!= 0)
6471 warn (_("The %s section contains "
6472 "unsupported offset entry count: %u.\n"),
6473 section
->name
, offset_entry_count
);
6478 if (load_debug_info (file
) == 0)
6480 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6486 for (i
= 0; i
< num_debug_info_entries
; i
++)
6487 num_range_list
+= debug_information
[i
].num_range_lists
;
6489 if (num_range_list
== 0)
6491 /* This can happen when the file was compiled with -gsplit-debug
6492 which removes references to range lists from the primary .o file. */
6493 printf (_("No range lists in .debug_info section.\n"));
6497 range_entries
= (struct range_entry
*)
6498 xmalloc (sizeof (*range_entries
) * num_range_list
);
6499 range_entry_fill
= range_entries
;
6501 for (i
= 0; i
< num_debug_info_entries
; i
++)
6503 debug_info
*debug_info_p
= &debug_information
[i
];
6506 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
6508 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
6509 range_entry_fill
->debug_info_p
= debug_info_p
;
6514 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
6515 range_entry_compar
);
6517 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
6518 warn (_("Range lists in %s section start at 0x%lx\n"),
6519 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
6521 printf (_("Contents of the %s section:\n\n"), section
->name
);
6522 printf (_(" Offset Begin End\n"));
6524 for (i
= 0; i
< num_range_list
; i
++)
6526 struct range_entry
*range_entry
= &range_entries
[i
];
6527 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
6528 unsigned int pointer_size
;
6530 unsigned char *next
;
6531 dwarf_vma base_address
;
6533 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
6534 offset
= range_entry
->ranges_offset
;
6535 next
= section_begin
+ offset
;
6536 base_address
= debug_info_p
->base_address
;
6538 /* PR 17512: file: 001-101485-0.001:0.1. */
6539 if (pointer_size
< 2 || pointer_size
> 8)
6541 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
6542 pointer_size
, (unsigned long) offset
);
6546 if (dwarf_check
!= 0 && i
> 0)
6549 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
6550 (unsigned long) (start
- section_begin
),
6551 (unsigned long) (next
- section_begin
), section
->name
);
6552 else if (start
> next
)
6554 if (next
== last_start
)
6556 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
6557 (unsigned long) (start
- section_begin
),
6558 (unsigned long) (next
- section_begin
), section
->name
);
6564 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
6565 (start
, finish
, pointer_size
, offset
, base_address
);
6569 free (range_entries
);
6574 typedef struct Frame_Chunk
6576 struct Frame_Chunk
*next
;
6577 unsigned char *chunk_start
;
6579 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6580 short int *col_type
;
6583 unsigned int code_factor
;
6588 dwarf_vma cfa_offset
;
6590 unsigned char fde_encoding
;
6591 unsigned char cfa_exp
;
6592 unsigned char ptr_size
;
6593 unsigned char segment_size
;
6597 static const char *const *dwarf_regnames
;
6598 static unsigned int dwarf_regnames_count
;
6600 /* A marker for a col_type that means this column was never referenced
6601 in the frame info. */
6602 #define DW_CFA_unreferenced (-1)
6604 /* Return 0 if no more space is needed, 1 if more space is needed,
6605 -1 for invalid reg. */
6608 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
6610 unsigned int prev
= fc
->ncols
;
6612 if (reg
< (unsigned int) fc
->ncols
)
6615 if (dwarf_regnames_count
6616 && reg
> dwarf_regnames_count
)
6619 fc
->ncols
= reg
+ 1;
6620 /* PR 17512: file: 10450-2643-0.004.
6621 If reg == -1 then this can happen... */
6625 /* PR 17512: file: 2844a11d. */
6626 if (fc
->ncols
> 1024)
6628 error (_("Unfeasibly large register number: %u\n"), reg
);
6630 /* FIXME: 1024 is an arbitrary limit. Increase it if
6631 we ever encounter a valid binary that exceeds it. */
6635 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
6636 sizeof (short int));
6637 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
6638 /* PR 17512: file:002-10025-0.005. */
6639 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
6641 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
6647 while (prev
< fc
->ncols
)
6649 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
6650 fc
->col_offset
[prev
] = 0;
6656 static const char *const dwarf_regnames_i386
[] =
6658 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6659 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6660 "eip", "eflags", NULL
, /* 8 - 10 */
6661 "st0", "st1", "st2", "st3", /* 11 - 14 */
6662 "st4", "st5", "st6", "st7", /* 15 - 18 */
6663 NULL
, NULL
, /* 19 - 20 */
6664 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
6665 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
6666 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
6667 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
6668 "fcw", "fsw", "mxcsr", /* 37 - 39 */
6669 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
6670 "tr", "ldtr", /* 48 - 49 */
6671 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
6672 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
6673 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
6674 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
6675 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
6676 NULL
, NULL
, NULL
, /* 90 - 92 */
6677 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
6680 static const char *const dwarf_regnames_iamcu
[] =
6682 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
6683 "esp", "ebp", "esi", "edi", /* 4 - 7 */
6684 "eip", "eflags", NULL
, /* 8 - 10 */
6685 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
6686 NULL
, NULL
, /* 19 - 20 */
6687 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
6688 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
6689 NULL
, NULL
, NULL
, /* 37 - 39 */
6690 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
6691 "tr", "ldtr", /* 48 - 49 */
6692 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
6693 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
6694 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
6695 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
6696 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
6697 NULL
, NULL
, NULL
, /* 90 - 92 */
6698 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
6702 init_dwarf_regnames_i386 (void)
6704 dwarf_regnames
= dwarf_regnames_i386
;
6705 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
6709 init_dwarf_regnames_iamcu (void)
6711 dwarf_regnames
= dwarf_regnames_iamcu
;
6712 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
6715 static const char *const dwarf_regnames_x86_64
[] =
6717 "rax", "rdx", "rcx", "rbx",
6718 "rsi", "rdi", "rbp", "rsp",
6719 "r8", "r9", "r10", "r11",
6720 "r12", "r13", "r14", "r15",
6722 "xmm0", "xmm1", "xmm2", "xmm3",
6723 "xmm4", "xmm5", "xmm6", "xmm7",
6724 "xmm8", "xmm9", "xmm10", "xmm11",
6725 "xmm12", "xmm13", "xmm14", "xmm15",
6726 "st0", "st1", "st2", "st3",
6727 "st4", "st5", "st6", "st7",
6728 "mm0", "mm1", "mm2", "mm3",
6729 "mm4", "mm5", "mm6", "mm7",
6731 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
6732 "fs.base", "gs.base", NULL
, NULL
,
6734 "mxcsr", "fcw", "fsw",
6735 "xmm16", "xmm17", "xmm18", "xmm19",
6736 "xmm20", "xmm21", "xmm22", "xmm23",
6737 "xmm24", "xmm25", "xmm26", "xmm27",
6738 "xmm28", "xmm29", "xmm30", "xmm31",
6739 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
6740 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
6741 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
6742 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
6743 NULL
, NULL
, NULL
, /* 115 - 117 */
6744 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
6748 init_dwarf_regnames_x86_64 (void)
6750 dwarf_regnames
= dwarf_regnames_x86_64
;
6751 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
6754 static const char *const dwarf_regnames_aarch64
[] =
6756 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
6757 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
6758 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
6759 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
6760 NULL
, "elr", 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 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
6764 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
6765 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
6766 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
6767 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
6771 init_dwarf_regnames_aarch64 (void)
6773 dwarf_regnames
= dwarf_regnames_aarch64
;
6774 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
6777 static const char *const dwarf_regnames_s390
[] =
6779 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
6780 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
6781 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
6782 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
6783 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
6784 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
6785 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
6786 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
6787 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
6790 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
6791 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
6795 init_dwarf_regnames_s390 (void)
6797 dwarf_regnames
= dwarf_regnames_s390
;
6798 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
6802 init_dwarf_regnames (unsigned int e_machine
)
6807 init_dwarf_regnames_i386 ();
6811 init_dwarf_regnames_iamcu ();
6817 init_dwarf_regnames_x86_64 ();
6821 init_dwarf_regnames_aarch64 ();
6825 init_dwarf_regnames_s390 ();
6834 regname (unsigned int regno
, int row
)
6836 static char reg
[64];
6839 && regno
< dwarf_regnames_count
6840 && dwarf_regnames
[regno
] != NULL
)
6843 return dwarf_regnames
[regno
];
6844 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
6845 dwarf_regnames
[regno
]);
6848 snprintf (reg
, sizeof (reg
), "r%d", regno
);
6853 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
6858 if (*max_regs
!= fc
->ncols
)
6859 *max_regs
= fc
->ncols
;
6861 if (*need_col_headers
)
6863 static const char *sloc
= " LOC";
6865 *need_col_headers
= 0;
6867 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
6869 for (r
= 0; r
< *max_regs
; r
++)
6870 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
6875 printf ("%-5s ", regname (r
, 1));
6881 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
6883 strcpy (tmp
, "exp");
6885 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
6886 printf ("%-8s ", tmp
);
6888 for (r
= 0; r
< fc
->ncols
; r
++)
6890 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
6892 switch (fc
->col_type
[r
])
6894 case DW_CFA_undefined
:
6897 case DW_CFA_same_value
:
6901 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
6903 case DW_CFA_val_offset
:
6904 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
6906 case DW_CFA_register
:
6907 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
6909 case DW_CFA_expression
:
6910 strcpy (tmp
, "exp");
6912 case DW_CFA_val_expression
:
6913 strcpy (tmp
, "vexp");
6916 strcpy (tmp
, "n/a");
6919 printf ("%-5s ", tmp
);
6925 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
6927 static unsigned char *
6928 read_cie (unsigned char *start
, unsigned char *end
,
6929 Frame_Chunk
**p_cie
, int *p_version
,
6930 unsigned long *p_aug_len
, unsigned char **p_aug
)
6934 unsigned int length_return
;
6935 unsigned char *augmentation_data
= NULL
;
6936 unsigned long augmentation_data_len
= 0;
6939 /* PR 17512: file: 001-228113-0.004. */
6943 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6944 memset (fc
, 0, sizeof (Frame_Chunk
));
6946 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
6947 fc
->col_offset
= (int *) xmalloc (sizeof (int));
6951 fc
->augmentation
= (char *) start
;
6952 /* PR 17512: file: 001-228113-0.004.
6953 Skip past augmentation name, but avoid running off the end of the data. */
6955 if (* start
++ == '\0')
6959 warn (_("No terminator for augmentation name\n"));
6963 if (strcmp (fc
->augmentation
, "eh") == 0)
6964 start
+= eh_addr_size
;
6968 GET (fc
->ptr_size
, 1);
6969 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
6971 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
6975 GET (fc
->segment_size
, 1);
6976 /* PR 17512: file: e99d2804. */
6977 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
6979 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
6983 eh_addr_size
= fc
->ptr_size
;
6987 fc
->ptr_size
= eh_addr_size
;
6988 fc
->segment_size
= 0;
6990 READ_ULEB (fc
->code_factor
);
6991 READ_SLEB (fc
->data_factor
);
7001 if (fc
->augmentation
[0] == 'z')
7003 READ_ULEB (augmentation_data_len
);
7004 augmentation_data
= start
;
7005 /* PR 17512: file: 11042-2589-0.004. */
7006 if (augmentation_data_len
> (size_t) (end
- start
))
7008 warn (_("Augmentation data too long: %#lx, expected at most %#lx\n"),
7009 augmentation_data_len
, (unsigned long) (end
- start
));
7012 start
+= augmentation_data_len
;
7015 if (augmentation_data_len
)
7019 unsigned char *qend
;
7021 p
= (unsigned char *) fc
->augmentation
+ 1;
7022 q
= augmentation_data
;
7023 qend
= q
+ augmentation_data_len
;
7025 while (p
< end
&& q
< qend
)
7030 q
+= 1 + size_of_encoded_value (*q
);
7032 fc
->fde_encoding
= *q
++;
7039 /* Note - it is OK if this loop terminates with q < qend.
7040 Padding may have been inserted to align the end of the CIE. */
7045 *p_version
= version
;
7048 *p_aug_len
= augmentation_data_len
;
7049 *p_aug
= augmentation_data
;
7055 display_debug_frames (struct dwarf_section
*section
,
7056 void *file ATTRIBUTE_UNUSED
)
7058 unsigned char *start
= section
->start
;
7059 unsigned char *end
= start
+ section
->size
;
7060 unsigned char *section_start
= start
;
7061 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
7062 Frame_Chunk
*remembered_state
= 0;
7064 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
7065 unsigned int length_return
;
7066 unsigned int max_regs
= 0;
7067 const char *bad_reg
= _("bad register: ");
7068 unsigned int saved_eh_addr_size
= eh_addr_size
;
7070 printf (_("Contents of the %s section:\n"), section
->name
);
7074 unsigned char *saved_start
;
7075 unsigned char *block_end
;
7080 int need_col_headers
= 1;
7081 unsigned char *augmentation_data
= NULL
;
7082 unsigned long augmentation_data_len
= 0;
7083 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
7084 unsigned int offset_size
;
7085 unsigned int initial_length_size
;
7086 bfd_boolean all_nops
;
7088 saved_start
= start
;
7090 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
7094 printf ("\n%08lx ZERO terminator\n\n",
7095 (unsigned long)(saved_start
- section_start
));
7096 /* Skip any zero terminators that directly follow.
7097 A corrupt section size could have loaded a whole
7098 slew of zero filled memory bytes. eg
7099 PR 17512: file: 070-19381-0.004. */
7100 while (start
< end
&& * start
== 0)
7105 if (length
== 0xffffffff)
7107 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
7109 initial_length_size
= 12;
7114 initial_length_size
= 4;
7117 block_end
= saved_start
+ length
+ initial_length_size
;
7118 if (block_end
> end
|| block_end
< start
)
7120 warn ("Invalid length 0x%s in FDE at %#08lx\n",
7121 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
7122 (unsigned long) (saved_start
- section_start
));
7126 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
7128 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
7129 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
7134 start
= read_cie (start
, end
, &cie
, &version
,
7135 &augmentation_data_len
, &augmentation_data
);
7136 /* PR 17512: file: 027-135133-0.005. */
7143 fc
->chunk_start
= saved_start
;
7144 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7147 if (frame_need_space (fc
, mreg
) < 0)
7149 if (fc
->fde_encoding
)
7150 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7152 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
7153 print_dwarf_vma (length
, fc
->ptr_size
);
7154 print_dwarf_vma (cie_id
, offset_size
);
7156 if (do_debug_frames_interp
)
7158 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
7159 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7164 printf (" Version: %d\n", version
);
7165 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7168 printf (" Pointer Size: %u\n", fc
->ptr_size
);
7169 printf (" Segment Size: %u\n", fc
->segment_size
);
7171 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7172 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7173 printf (" Return address column: %d\n", fc
->ra
);
7175 if (augmentation_data_len
)
7179 printf (" Augmentation data: ");
7180 for (i
= 0; i
< augmentation_data_len
; ++i
)
7181 /* FIXME: If do_wide is FALSE, then we should
7182 add carriage returns at 80 columns... */
7183 printf (" %02x", augmentation_data
[i
]);
7191 unsigned char *look_for
;
7192 static Frame_Chunk fde_fc
;
7193 unsigned long segment_selector
;
7197 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
7198 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
7201 look_for
= section_start
+ cie_id
;
7203 if (look_for
<= saved_start
)
7205 for (cie
= chunks
; cie
; cie
= cie
->next
)
7206 if (cie
->chunk_start
== look_for
)
7211 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
7212 if (cie
->chunk_start
== look_for
)
7216 unsigned int off_size
;
7217 unsigned char *cie_scan
;
7219 cie_scan
= look_for
;
7221 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
7222 if (length
== 0xffffffff)
7224 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
7231 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
7234 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
7235 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
7240 read_cie (cie_scan
, end
, &cie
, &version
,
7241 &augmentation_data_len
, &augmentation_data
);
7242 /* PR 17512: file: 3450-2098-0.004. */
7245 warn (_("Failed to read CIE information\n"));
7248 cie
->next
= forward_refs
;
7250 cie
->chunk_start
= look_for
;
7251 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
7254 if (frame_need_space (cie
, mreg
) < 0)
7256 warn (_("Invalid max register\n"));
7259 if (cie
->fde_encoding
)
7261 = size_of_encoded_value (cie
->fde_encoding
);
7268 memset (fc
, 0, sizeof (Frame_Chunk
));
7272 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
7273 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7274 (unsigned long) (saved_start
- section_start
));
7276 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7277 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7278 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
7280 warn (_("Invalid max register\n"));
7284 fc
->augmentation
= "";
7285 fc
->fde_encoding
= 0;
7286 fc
->ptr_size
= eh_addr_size
;
7287 fc
->segment_size
= 0;
7291 fc
->ncols
= cie
->ncols
;
7292 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
7293 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
7294 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
7295 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
7296 fc
->augmentation
= cie
->augmentation
;
7297 fc
->ptr_size
= cie
->ptr_size
;
7298 eh_addr_size
= cie
->ptr_size
;
7299 fc
->segment_size
= cie
->segment_size
;
7300 fc
->code_factor
= cie
->code_factor
;
7301 fc
->data_factor
= cie
->data_factor
;
7302 fc
->cfa_reg
= cie
->cfa_reg
;
7303 fc
->cfa_offset
= cie
->cfa_offset
;
7305 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
7307 warn (_("Invalid max register\n"));
7310 fc
->fde_encoding
= cie
->fde_encoding
;
7313 if (fc
->fde_encoding
)
7314 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7316 segment_selector
= 0;
7317 if (fc
->segment_size
)
7319 if (fc
->segment_size
> sizeof (segment_selector
))
7321 /* PR 17512: file: 9e196b3e. */
7322 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
7323 fc
->segment_size
= 4;
7325 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
7328 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
7330 /* FIXME: It appears that sometimes the final pc_range value is
7331 encoded in less than encoded_ptr_size bytes. See the x86_64
7332 run of the "objcopy on compressed debug sections" test for an
7334 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
7336 if (cie
->augmentation
[0] == 'z')
7338 READ_ULEB (augmentation_data_len
);
7339 augmentation_data
= start
;
7340 start
+= augmentation_data_len
;
7341 /* PR 17512: file: 722-8446-0.004. */
7342 if (start
>= end
|| ((signed long) augmentation_data_len
) < 0)
7344 warn (_("Corrupt augmentation data length: %lx\n"),
7345 augmentation_data_len
);
7347 augmentation_data
= NULL
;
7348 augmentation_data_len
= 0;
7352 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
7353 (unsigned long)(saved_start
- section_start
),
7354 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
7355 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
7356 (unsigned long)(cie
->chunk_start
- section_start
));
7358 if (fc
->segment_size
)
7359 printf ("%04lx:", segment_selector
);
7362 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
7363 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
7365 if (! do_debug_frames_interp
&& augmentation_data_len
)
7369 printf (" Augmentation data: ");
7370 for (i
= 0; i
< augmentation_data_len
; ++i
)
7371 printf (" %02x", augmentation_data
[i
]);
7377 /* At this point, fc is the current chunk, cie (if any) is set, and
7378 we're about to interpret instructions for the chunk. */
7379 /* ??? At present we need to do this always, since this sizes the
7380 fc->col_type and fc->col_offset arrays, which we write into always.
7381 We should probably split the interpreted and non-interpreted bits
7382 into two different routines, since there's so much that doesn't
7383 really overlap between them. */
7384 if (1 || do_debug_frames_interp
)
7386 /* Start by making a pass over the chunk, allocating storage
7387 and taking note of what registers are used. */
7388 unsigned char *tmp
= start
;
7390 while (start
< block_end
)
7392 unsigned int reg
, op
, opa
;
7394 unsigned char * new_start
;
7401 /* Warning: if you add any more cases to this switch, be
7402 sure to add them to the corresponding switch below. */
7405 case DW_CFA_advance_loc
:
7409 if (frame_need_space (fc
, opa
) >= 0)
7410 fc
->col_type
[opa
] = DW_CFA_undefined
;
7412 case DW_CFA_restore
:
7413 if (frame_need_space (fc
, opa
) >= 0)
7414 fc
->col_type
[opa
] = DW_CFA_undefined
;
7416 case DW_CFA_set_loc
:
7417 start
+= encoded_ptr_size
;
7419 case DW_CFA_advance_loc1
:
7422 case DW_CFA_advance_loc2
:
7425 case DW_CFA_advance_loc4
:
7428 case DW_CFA_offset_extended
:
7429 case DW_CFA_val_offset
:
7432 if (frame_need_space (fc
, reg
) >= 0)
7433 fc
->col_type
[reg
] = DW_CFA_undefined
;
7435 case DW_CFA_restore_extended
:
7437 if (frame_need_space (fc
, reg
) >= 0)
7438 fc
->col_type
[reg
] = DW_CFA_undefined
;
7440 case DW_CFA_undefined
:
7442 if (frame_need_space (fc
, reg
) >= 0)
7443 fc
->col_type
[reg
] = DW_CFA_undefined
;
7445 case DW_CFA_same_value
:
7447 if (frame_need_space (fc
, reg
) >= 0)
7448 fc
->col_type
[reg
] = DW_CFA_undefined
;
7450 case DW_CFA_register
:
7453 if (frame_need_space (fc
, reg
) >= 0)
7454 fc
->col_type
[reg
] = DW_CFA_undefined
;
7456 case DW_CFA_def_cfa
:
7460 case DW_CFA_def_cfa_register
:
7463 case DW_CFA_def_cfa_offset
:
7466 case DW_CFA_def_cfa_expression
:
7468 new_start
= start
+ temp
;
7469 if (new_start
< start
)
7471 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
7477 case DW_CFA_expression
:
7478 case DW_CFA_val_expression
:
7481 new_start
= start
+ temp
;
7482 if (new_start
< start
)
7484 /* PR 17512: file:306-192417-0.005. */
7485 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
7490 if (frame_need_space (fc
, reg
) >= 0)
7491 fc
->col_type
[reg
] = DW_CFA_undefined
;
7493 case DW_CFA_offset_extended_sf
:
7494 case DW_CFA_val_offset_sf
:
7497 if (frame_need_space (fc
, reg
) >= 0)
7498 fc
->col_type
[reg
] = DW_CFA_undefined
;
7500 case DW_CFA_def_cfa_sf
:
7504 case DW_CFA_def_cfa_offset_sf
:
7507 case DW_CFA_MIPS_advance_loc8
:
7510 case DW_CFA_GNU_args_size
:
7513 case DW_CFA_GNU_negative_offset_extended
:
7516 if (frame_need_space (fc
, reg
) >= 0)
7517 fc
->col_type
[reg
] = DW_CFA_undefined
;
7528 /* Now we know what registers are used, make a second pass over
7529 the chunk, this time actually printing out the info. */
7531 while (start
< block_end
)
7533 unsigned char * tmp
;
7535 unsigned long ul
, roffs
;
7536 /* Note: It is tempting to use an unsigned long for 'reg' but there
7537 are various functions, notably frame_space_needed() that assume that
7538 reg is an unsigned int. */
7543 const char *reg_prefix
= "";
7550 /* Make a note if something other than DW_CFA_nop happens. */
7551 if (op
!= DW_CFA_nop
)
7554 /* Warning: if you add any more cases to this switch, be
7555 sure to add them to the corresponding switch above. */
7558 case DW_CFA_advance_loc
:
7559 if (do_debug_frames_interp
)
7560 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7562 printf (" DW_CFA_advance_loc: %d to %s\n",
7563 opa
* fc
->code_factor
,
7564 dwarf_vmatoa_1 (NULL
,
7565 fc
->pc_begin
+ opa
* fc
->code_factor
,
7567 fc
->pc_begin
+= opa
* fc
->code_factor
;
7572 if (opa
>= (unsigned int) fc
->ncols
)
7573 reg_prefix
= bad_reg
;
7574 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7575 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
7576 reg_prefix
, regname (opa
, 0),
7577 roffs
* fc
->data_factor
);
7578 if (*reg_prefix
== '\0')
7580 fc
->col_type
[opa
] = DW_CFA_offset
;
7581 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
7585 case DW_CFA_restore
:
7586 if (opa
>= (unsigned int) fc
->ncols
)
7587 reg_prefix
= bad_reg
;
7588 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7589 printf (" DW_CFA_restore: %s%s\n",
7590 reg_prefix
, regname (opa
, 0));
7591 if (*reg_prefix
!= '\0')
7594 if (opa
>= (unsigned int) cie
->ncols
7595 || (do_debug_frames_interp
7596 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
7598 fc
->col_type
[opa
] = DW_CFA_undefined
;
7599 fc
->col_offset
[opa
] = 0;
7603 fc
->col_type
[opa
] = cie
->col_type
[opa
];
7604 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
7608 case DW_CFA_set_loc
:
7609 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
7610 if (do_debug_frames_interp
)
7611 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7613 printf (" DW_CFA_set_loc: %s\n",
7614 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
7618 case DW_CFA_advance_loc1
:
7619 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
7620 if (do_debug_frames_interp
)
7621 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7623 printf (" DW_CFA_advance_loc1: %ld to %s\n",
7624 (unsigned long) (ofs
* fc
->code_factor
),
7625 dwarf_vmatoa_1 (NULL
,
7626 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7628 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7631 case DW_CFA_advance_loc2
:
7632 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
7633 if (do_debug_frames_interp
)
7634 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7636 printf (" DW_CFA_advance_loc2: %ld to %s\n",
7637 (unsigned long) (ofs
* fc
->code_factor
),
7638 dwarf_vmatoa_1 (NULL
,
7639 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7641 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7644 case DW_CFA_advance_loc4
:
7645 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
7646 if (do_debug_frames_interp
)
7647 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7649 printf (" DW_CFA_advance_loc4: %ld to %s\n",
7650 (unsigned long) (ofs
* fc
->code_factor
),
7651 dwarf_vmatoa_1 (NULL
,
7652 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7654 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7657 case DW_CFA_offset_extended
:
7660 if (reg
>= (unsigned int) fc
->ncols
)
7661 reg_prefix
= bad_reg
;
7662 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7663 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
7664 reg_prefix
, regname (reg
, 0),
7665 roffs
* fc
->data_factor
);
7666 if (*reg_prefix
== '\0')
7668 fc
->col_type
[reg
] = DW_CFA_offset
;
7669 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
7673 case DW_CFA_val_offset
:
7676 if (reg
>= (unsigned int) fc
->ncols
)
7677 reg_prefix
= bad_reg
;
7678 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7679 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
7680 reg_prefix
, regname (reg
, 0),
7681 roffs
* fc
->data_factor
);
7682 if (*reg_prefix
== '\0')
7684 fc
->col_type
[reg
] = DW_CFA_val_offset
;
7685 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
7689 case DW_CFA_restore_extended
:
7691 if (reg
>= (unsigned int) fc
->ncols
)
7692 reg_prefix
= bad_reg
;
7693 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7694 printf (" DW_CFA_restore_extended: %s%s\n",
7695 reg_prefix
, regname (reg
, 0));
7696 if (*reg_prefix
!= '\0')
7699 if (reg
>= (unsigned int) cie
->ncols
)
7701 fc
->col_type
[reg
] = DW_CFA_undefined
;
7702 fc
->col_offset
[reg
] = 0;
7706 fc
->col_type
[reg
] = cie
->col_type
[reg
];
7707 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
7711 case DW_CFA_undefined
:
7713 if (reg
>= (unsigned int) fc
->ncols
)
7714 reg_prefix
= bad_reg
;
7715 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7716 printf (" DW_CFA_undefined: %s%s\n",
7717 reg_prefix
, regname (reg
, 0));
7718 if (*reg_prefix
== '\0')
7720 fc
->col_type
[reg
] = DW_CFA_undefined
;
7721 fc
->col_offset
[reg
] = 0;
7725 case DW_CFA_same_value
:
7727 if (reg
>= (unsigned int) fc
->ncols
)
7728 reg_prefix
= bad_reg
;
7729 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7730 printf (" DW_CFA_same_value: %s%s\n",
7731 reg_prefix
, regname (reg
, 0));
7732 if (*reg_prefix
== '\0')
7734 fc
->col_type
[reg
] = DW_CFA_same_value
;
7735 fc
->col_offset
[reg
] = 0;
7739 case DW_CFA_register
:
7742 if (reg
>= (unsigned int) fc
->ncols
)
7743 reg_prefix
= bad_reg
;
7744 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7746 printf (" DW_CFA_register: %s%s in ",
7747 reg_prefix
, regname (reg
, 0));
7748 puts (regname (roffs
, 0));
7750 if (*reg_prefix
== '\0')
7752 fc
->col_type
[reg
] = DW_CFA_register
;
7753 fc
->col_offset
[reg
] = roffs
;
7757 case DW_CFA_remember_state
:
7758 if (! do_debug_frames_interp
)
7759 printf (" DW_CFA_remember_state\n");
7760 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7761 rs
->cfa_offset
= fc
->cfa_offset
;
7762 rs
->cfa_reg
= fc
->cfa_reg
;
7764 rs
->cfa_exp
= fc
->cfa_exp
;
7765 rs
->ncols
= fc
->ncols
;
7766 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
7767 sizeof (* rs
->col_type
));
7768 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
7769 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
7770 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
7771 rs
->next
= remembered_state
;
7772 remembered_state
= rs
;
7775 case DW_CFA_restore_state
:
7776 if (! do_debug_frames_interp
)
7777 printf (" DW_CFA_restore_state\n");
7778 rs
= remembered_state
;
7781 remembered_state
= rs
->next
;
7782 fc
->cfa_offset
= rs
->cfa_offset
;
7783 fc
->cfa_reg
= rs
->cfa_reg
;
7785 fc
->cfa_exp
= rs
->cfa_exp
;
7786 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
7788 warn (_("Invalid column number in saved frame state\n"));
7792 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
7793 memcpy (fc
->col_offset
, rs
->col_offset
,
7794 rs
->ncols
* sizeof (* rs
->col_offset
));
7795 free (rs
->col_type
);
7796 free (rs
->col_offset
);
7799 else if (do_debug_frames_interp
)
7800 printf ("Mismatched DW_CFA_restore_state\n");
7803 case DW_CFA_def_cfa
:
7804 READ_SLEB (fc
->cfa_reg
);
7805 READ_ULEB (fc
->cfa_offset
);
7807 if (! do_debug_frames_interp
)
7808 printf (" DW_CFA_def_cfa: %s ofs %d\n",
7809 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
7812 case DW_CFA_def_cfa_register
:
7813 READ_SLEB (fc
->cfa_reg
);
7815 if (! do_debug_frames_interp
)
7816 printf (" DW_CFA_def_cfa_register: %s\n",
7817 regname (fc
->cfa_reg
, 0));
7820 case DW_CFA_def_cfa_offset
:
7821 READ_ULEB (fc
->cfa_offset
);
7822 if (! do_debug_frames_interp
)
7823 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
7827 if (! do_debug_frames_interp
)
7828 printf (" DW_CFA_nop\n");
7831 case DW_CFA_def_cfa_expression
:
7833 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
7835 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
7838 if (! do_debug_frames_interp
)
7840 printf (" DW_CFA_def_cfa_expression (");
7841 decode_location_expression (start
, eh_addr_size
, 0, -1,
7849 case DW_CFA_expression
:
7852 if (reg
>= (unsigned int) fc
->ncols
)
7853 reg_prefix
= bad_reg
;
7854 /* PR 17512: file: 069-133014-0.006. */
7855 /* PR 17512: file: 98c02eb4. */
7857 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
7859 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
7862 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7864 printf (" DW_CFA_expression: %s%s (",
7865 reg_prefix
, regname (reg
, 0));
7866 decode_location_expression (start
, eh_addr_size
, 0, -1,
7870 if (*reg_prefix
== '\0')
7871 fc
->col_type
[reg
] = DW_CFA_expression
;
7875 case DW_CFA_val_expression
:
7878 if (reg
>= (unsigned int) fc
->ncols
)
7879 reg_prefix
= bad_reg
;
7881 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
7883 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
7886 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7888 printf (" DW_CFA_val_expression: %s%s (",
7889 reg_prefix
, regname (reg
, 0));
7890 decode_location_expression (start
, eh_addr_size
, 0, -1,
7894 if (*reg_prefix
== '\0')
7895 fc
->col_type
[reg
] = DW_CFA_val_expression
;
7899 case DW_CFA_offset_extended_sf
:
7902 if (frame_need_space (fc
, reg
) < 0)
7903 reg_prefix
= bad_reg
;
7904 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7905 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
7906 reg_prefix
, regname (reg
, 0),
7907 (long)(l
* fc
->data_factor
));
7908 if (*reg_prefix
== '\0')
7910 fc
->col_type
[reg
] = DW_CFA_offset
;
7911 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
7915 case DW_CFA_val_offset_sf
:
7918 if (frame_need_space (fc
, reg
) < 0)
7919 reg_prefix
= bad_reg
;
7920 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7921 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
7922 reg_prefix
, regname (reg
, 0),
7923 (long)(l
* fc
->data_factor
));
7924 if (*reg_prefix
== '\0')
7926 fc
->col_type
[reg
] = DW_CFA_val_offset
;
7927 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
7931 case DW_CFA_def_cfa_sf
:
7932 READ_SLEB (fc
->cfa_reg
);
7933 READ_ULEB (fc
->cfa_offset
);
7934 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
7936 if (! do_debug_frames_interp
)
7937 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
7938 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
7941 case DW_CFA_def_cfa_offset_sf
:
7942 READ_ULEB (fc
->cfa_offset
);
7943 fc
->cfa_offset
*= fc
->data_factor
;
7944 if (! do_debug_frames_interp
)
7945 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
7948 case DW_CFA_MIPS_advance_loc8
:
7949 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
7950 if (do_debug_frames_interp
)
7951 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7953 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
7954 (unsigned long) (ofs
* fc
->code_factor
),
7955 dwarf_vmatoa_1 (NULL
,
7956 fc
->pc_begin
+ ofs
* fc
->code_factor
,
7958 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7961 case DW_CFA_GNU_window_save
:
7962 if (! do_debug_frames_interp
)
7963 printf (" DW_CFA_GNU_window_save\n");
7966 case DW_CFA_GNU_args_size
:
7968 if (! do_debug_frames_interp
)
7969 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
7972 case DW_CFA_GNU_negative_offset_extended
:
7976 if (frame_need_space (fc
, reg
) < 0)
7977 reg_prefix
= bad_reg
;
7978 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
7979 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
7980 reg_prefix
, regname (reg
, 0),
7981 (long)(l
* fc
->data_factor
));
7982 if (*reg_prefix
== '\0')
7984 fc
->col_type
[reg
] = DW_CFA_offset
;
7985 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
7990 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
7991 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
7993 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
7998 /* Interpret the CFA - as long as it is not completely full of NOPs. */
7999 if (do_debug_frames_interp
&& ! all_nops
)
8000 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8003 eh_addr_size
= saved_eh_addr_size
;
8014 display_debug_names (struct dwarf_section
*section
, void *file
)
8016 unsigned char *hdrptr
= section
->start
;
8017 dwarf_vma unit_length
;
8018 unsigned char *unit_start
;
8019 const unsigned char *const section_end
= section
->start
+ section
->size
;
8020 unsigned char *unit_end
;
8022 printf (_("Contents of the %s section:\n"), section
->name
);
8024 load_debug_section (str
, file
);
8026 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
8028 unsigned int offset_size
;
8029 uint16_t dwarf_version
, padding
;
8030 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
8031 uint32_t bucket_count
, name_count
, abbrev_table_size
;
8032 uint32_t augmentation_string_size
;
8034 unsigned long sec_off
;
8036 unit_start
= hdrptr
;
8038 /* Get and check the length of the block. */
8039 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
8041 if (unit_length
== 0xffffffff)
8043 /* This section is 64-bit DWARF. */
8044 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
8049 unit_end
= hdrptr
+ unit_length
;
8051 sec_off
= hdrptr
- section
->start
;
8052 if (sec_off
+ unit_length
< sec_off
8053 || sec_off
+ unit_length
> section
->size
)
8055 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
8057 (unsigned long) (unit_start
- section
->start
),
8058 dwarf_vmatoa ("x", unit_length
));
8062 /* Get and check the version number. */
8063 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
8064 printf (_("Version %ld\n"), (long) dwarf_version
);
8066 /* Prior versions did not exist, and future versions may not be
8067 backwards compatible. */
8068 if (dwarf_version
!= 5)
8070 warn (_("Only DWARF version 5 .debug_names "
8071 "is currently supported.\n"));
8075 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
8077 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
8080 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
8081 if (comp_unit_count
== 0)
8082 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
8084 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
8085 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
8086 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
8087 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
8088 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
8090 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
8091 if (augmentation_string_size
% 4 != 0)
8093 warn (_("Augmentation string length %u must be rounded up "
8094 "to a multiple of 4 in .debug_names.\n"),
8095 augmentation_string_size
);
8096 augmentation_string_size
+= (-augmentation_string_size
) & 3;
8098 printf (_("Augmentation string:"));
8099 for (i
= 0; i
< augmentation_string_size
; i
++)
8103 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
8104 printf (" %02x", uc
);
8109 printf (_("CU table:\n"));
8110 for (i
= 0; i
< comp_unit_count
; i
++)
8114 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
8115 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
8119 printf (_("TU table:\n"));
8120 for (i
= 0; i
< local_type_unit_count
; i
++)
8124 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
8125 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
8129 printf (_("Foreign TU table:\n"));
8130 for (i
= 0; i
< foreign_type_unit_count
; i
++)
8134 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
8135 printf (_("[%3u] "), i
);
8136 print_dwarf_vma (signature
, 8);
8141 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
8142 hdrptr
+= bucket_count
* sizeof (uint32_t);
8143 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
8144 hdrptr
+= name_count
* sizeof (uint32_t);
8145 unsigned char *const name_table_string_offsets
= hdrptr
;
8146 hdrptr
+= name_count
* offset_size
;
8147 unsigned char *const name_table_entry_offsets
= hdrptr
;
8148 hdrptr
+= name_count
* offset_size
;
8149 unsigned char *const abbrev_table
= hdrptr
;
8150 hdrptr
+= abbrev_table_size
;
8151 const unsigned char *const abbrev_table_end
= hdrptr
;
8152 unsigned char *const entry_pool
= hdrptr
;
8153 if (hdrptr
> unit_end
)
8155 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
8156 "for unit 0x%lx in the debug_names\n"),
8157 (long) (hdrptr
- section
->start
),
8158 (long) (unit_end
- section
->start
),
8159 (long) (unit_start
- section
->start
));
8163 size_t buckets_filled
= 0;
8165 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
8167 const uint32_t bucket
= hash_table_buckets
[bucketi
];
8172 printf (_("Used %zu of %lu buckets.\n"), buckets_filled
,
8173 (unsigned long) bucket_count
);
8175 uint32_t hash_prev
= 0;
8176 size_t hash_clash_count
= 0;
8177 size_t longest_clash
= 0;
8178 size_t this_length
= 0;
8180 for (hashi
= 0; hashi
< name_count
; hashi
++)
8182 const uint32_t hash_this
= hash_table_hashes
[hashi
];
8186 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
8190 longest_clash
= MAX (longest_clash
, this_length
);
8195 hash_prev
= hash_this
;
8197 printf (_("Out of %lu items there are %zu bucket clashes"
8198 " (longest of %zu entries).\n"),
8199 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
8200 assert (name_count
== buckets_filled
+ hash_clash_count
);
8202 struct abbrev_lookup_entry
8204 dwarf_vma abbrev_tag
;
8205 unsigned char *abbrev_lookup_ptr
;
8207 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
8208 size_t abbrev_lookup_used
= 0;
8209 size_t abbrev_lookup_allocated
= 0;
8211 unsigned char *abbrevptr
= abbrev_table
;
8214 unsigned int bytes_read
;
8215 const dwarf_vma abbrev_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8217 abbrevptr
+= bytes_read
;
8218 if (abbrev_tag
== 0)
8220 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
8222 abbrev_lookup_allocated
= MAX (0x100,
8223 abbrev_lookup_allocated
* 2);
8224 abbrev_lookup
= xrealloc (abbrev_lookup
,
8225 (abbrev_lookup_allocated
8226 * sizeof (*abbrev_lookup
)));
8228 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
8229 struct abbrev_lookup_entry
*entry
;
8230 for (entry
= abbrev_lookup
;
8231 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8233 if (entry
->abbrev_tag
== abbrev_tag
)
8235 warn (_("Duplicate abbreviation tag %lu "
8236 "in unit 0x%lx in the debug_names\n"),
8237 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
8240 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
8241 entry
->abbrev_tag
= abbrev_tag
;
8242 entry
->abbrev_lookup_ptr
= abbrevptr
;
8244 /* Skip DWARF tag. */
8245 read_uleb128 (abbrevptr
, &bytes_read
, abbrev_table_end
);
8246 abbrevptr
+= bytes_read
;
8249 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8252 abbrevptr
+= bytes_read
;
8253 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8255 abbrevptr
+= bytes_read
;
8256 if (xindex
== 0 && form
== 0)
8261 printf (_("\nSymbol table:\n"));
8263 for (namei
= 0; namei
< name_count
; ++namei
)
8265 uint64_t string_offset
, entry_offset
;
8267 SAFE_BYTE_GET (string_offset
,
8268 name_table_string_offsets
+ namei
* offset_size
,
8269 offset_size
, unit_end
);
8270 SAFE_BYTE_GET (entry_offset
,
8271 name_table_entry_offsets
+ namei
* offset_size
,
8272 offset_size
, unit_end
);
8274 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
8275 fetch_indirect_string (string_offset
));
8277 unsigned char *entryptr
= entry_pool
+ entry_offset
;
8279 // We need to scan first whether there is a single or multiple
8280 // entries. TAGNO is -2 for the first entry, it is -1 for the
8281 // initial tag read of the second entry, then it becomes 0 for the
8282 // first entry for real printing etc.
8284 /* Initialize it due to a false compiler warning. */
8285 dwarf_vma second_abbrev_tag
= -1;
8288 unsigned int bytes_read
;
8289 const dwarf_vma abbrev_tag
= read_uleb128 (entryptr
, &bytes_read
,
8291 entryptr
+= bytes_read
;
8294 second_abbrev_tag
= abbrev_tag
;
8296 entryptr
= entry_pool
+ entry_offset
;
8299 if (abbrev_tag
== 0)
8303 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
8304 (unsigned long) abbrev_tag
);
8306 const struct abbrev_lookup_entry
*entry
;
8307 for (entry
= abbrev_lookup
;
8308 entry
< abbrev_lookup
+ abbrev_lookup_used
;
8310 if (entry
->abbrev_tag
== abbrev_tag
)
8312 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
8314 warn (_("Undefined abbreviation tag %lu "
8315 "in unit 0x%lx in the debug_names\n"),
8317 (long) (unit_start
- section
->start
));
8320 abbrevptr
= entry
->abbrev_lookup_ptr
;
8321 const dwarf_vma dwarf_tag
= read_uleb128 (abbrevptr
, &bytes_read
,
8323 abbrevptr
+= bytes_read
;
8325 printf (" %s", get_TAG_name (dwarf_tag
));
8328 const dwarf_vma xindex
= read_uleb128 (abbrevptr
,
8331 abbrevptr
+= bytes_read
;
8332 const dwarf_vma form
= read_uleb128 (abbrevptr
, &bytes_read
,
8334 abbrevptr
+= bytes_read
;
8335 if (xindex
== 0 && form
== 0)
8339 printf (" %s", get_IDX_name (xindex
));
8340 entryptr
= read_and_display_attr_value (0, form
, 0, entryptr
,
8343 dwarf_version
, NULL
,
8350 printf (_(" <no entries>"));
8354 free (abbrev_lookup
);
8361 display_gdb_index (struct dwarf_section
*section
,
8362 void *file ATTRIBUTE_UNUSED
)
8364 unsigned char *start
= section
->start
;
8366 uint32_t cu_list_offset
, tu_list_offset
;
8367 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
8368 unsigned int cu_list_elements
, tu_list_elements
;
8369 unsigned int address_table_size
, symbol_table_slots
;
8370 unsigned char *cu_list
, *tu_list
;
8371 unsigned char *address_table
, *symbol_table
, *constant_pool
;
8374 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
8376 printf (_("Contents of the %s section:\n"), section
->name
);
8378 if (section
->size
< 6 * sizeof (uint32_t))
8380 warn (_("Truncated header in the %s section.\n"), section
->name
);
8384 version
= byte_get_little_endian (start
, 4);
8385 printf (_("Version %ld\n"), (long) version
);
8387 /* Prior versions are obsolete, and future versions may not be
8388 backwards compatible. */
8389 if (version
< 3 || version
> 8)
8391 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
8395 warn (_("The address table data in version 3 may be wrong.\n"));
8397 warn (_("Version 4 does not support case insensitive lookups.\n"));
8399 warn (_("Version 5 does not include inlined functions.\n"));
8401 warn (_("Version 6 does not include symbol attributes.\n"));
8402 /* Version 7 indices generated by Gold have bad type unit references,
8403 PR binutils/15021. But we don't know if the index was generated by
8404 Gold or not, so to avoid worrying users with gdb-generated indices
8405 we say nothing for version 7 here. */
8407 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
8408 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
8409 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
8410 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
8411 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
8413 if (cu_list_offset
> section
->size
8414 || tu_list_offset
> section
->size
8415 || address_table_offset
> section
->size
8416 || symbol_table_offset
> section
->size
8417 || constant_pool_offset
> section
->size
)
8419 warn (_("Corrupt header in the %s section.\n"), section
->name
);
8423 /* PR 17531: file: 418d0a8a. */
8424 if (tu_list_offset
< cu_list_offset
)
8426 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
8427 tu_list_offset
, cu_list_offset
);
8431 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
8433 if (address_table_offset
< tu_list_offset
)
8435 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
8436 address_table_offset
, tu_list_offset
);
8440 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
8442 /* PR 17531: file: 18a47d3d. */
8443 if (symbol_table_offset
< address_table_offset
)
8445 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
8446 symbol_table_offset
, address_table_offset
);
8450 address_table_size
= symbol_table_offset
- address_table_offset
;
8452 if (constant_pool_offset
< symbol_table_offset
)
8454 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
8455 constant_pool_offset
, symbol_table_offset
);
8459 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
8461 cu_list
= start
+ cu_list_offset
;
8462 tu_list
= start
+ tu_list_offset
;
8463 address_table
= start
+ address_table_offset
;
8464 symbol_table
= start
+ symbol_table_offset
;
8465 constant_pool
= start
+ constant_pool_offset
;
8467 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
8469 warn (_("Address table extends beyond end of section.\n"));
8473 printf (_("\nCU table:\n"));
8474 for (i
= 0; i
< cu_list_elements
; i
+= 2)
8476 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
8477 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
8479 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
8480 (unsigned long) cu_offset
,
8481 (unsigned long) (cu_offset
+ cu_length
- 1));
8484 printf (_("\nTU table:\n"));
8485 for (i
= 0; i
< tu_list_elements
; i
+= 3)
8487 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
8488 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
8489 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
8491 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
8492 (unsigned long) tu_offset
,
8493 (unsigned long) type_offset
);
8494 print_dwarf_vma (signature
, 8);
8498 printf (_("\nAddress table:\n"));
8499 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
8502 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
8503 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
8504 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
8506 print_dwarf_vma (low
, 8);
8507 print_dwarf_vma (high
, 8);
8508 printf (_("%lu\n"), (unsigned long) cu_index
);
8511 printf (_("\nSymbol table:\n"));
8512 for (i
= 0; i
< symbol_table_slots
; ++i
)
8514 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
8515 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
8516 uint32_t num_cus
, cu
;
8518 if (name_offset
!= 0
8519 || cu_vector_offset
!= 0)
8522 unsigned char * adr
;
8524 adr
= constant_pool
+ name_offset
;
8525 /* PR 17531: file: 5b7b07ad. */
8526 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
8528 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
8529 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
8533 printf ("[%3u] %.*s:", i
,
8534 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
8535 constant_pool
+ name_offset
);
8537 adr
= constant_pool
+ cu_vector_offset
;
8538 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
8540 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
8541 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
8542 cu_vector_offset
, i
);
8546 num_cus
= byte_get_little_endian (adr
, 4);
8548 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
8549 if (num_cus
* 4 < num_cus
8550 || adr
>= section
->start
+ section
->size
8551 || adr
< constant_pool
)
8553 printf ("<invalid number of CUs: %d>\n", num_cus
);
8554 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
8562 for (j
= 0; j
< num_cus
; ++j
)
8565 gdb_index_symbol_kind kind
;
8567 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
8568 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
8569 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
8570 cu
= GDB_INDEX_CU_VALUE (cu
);
8571 /* Convert to TU number if it's for a type unit. */
8572 if (cu
>= cu_list_elements
/ 2)
8573 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
8574 (unsigned long) (cu
- cu_list_elements
/ 2));
8576 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
8578 printf (" [%s, %s]",
8579 is_static
? _("static") : _("global"),
8580 get_gdb_index_symbol_kind_name (kind
));
8592 /* Pre-allocate enough space for the CU/TU sets needed. */
8595 prealloc_cu_tu_list (unsigned int nshndx
)
8597 if (shndx_pool
== NULL
)
8599 shndx_pool_size
= nshndx
;
8600 shndx_pool_used
= 0;
8601 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
8602 sizeof (unsigned int));
8606 shndx_pool_size
= shndx_pool_used
+ nshndx
;
8607 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
8608 sizeof (unsigned int));
8613 add_shndx_to_cu_tu_entry (unsigned int shndx
)
8615 if (shndx_pool_used
>= shndx_pool_size
)
8617 error (_("Internal error: out of space in the shndx pool.\n"));
8620 shndx_pool
[shndx_pool_used
++] = shndx
;
8624 end_cu_tu_entry (void)
8626 if (shndx_pool_used
>= shndx_pool_size
)
8628 error (_("Internal error: out of space in the shndx pool.\n"));
8631 shndx_pool
[shndx_pool_used
++] = 0;
8634 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
8637 get_DW_SECT_short_name (unsigned int dw_sect
)
8639 static char buf
[16];
8647 case DW_SECT_ABBREV
:
8653 case DW_SECT_STR_OFFSETS
:
8655 case DW_SECT_MACINFO
:
8663 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
8667 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
8668 These sections are extensions for Fission.
8669 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
8672 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
8674 unsigned char *phdr
= section
->start
;
8675 unsigned char *limit
= phdr
+ section
->size
;
8676 unsigned char *phash
;
8677 unsigned char *pindex
;
8678 unsigned char *ppool
;
8679 unsigned int version
;
8680 unsigned int ncols
= 0;
8682 unsigned int nslots
;
8685 dwarf_vma signature_high
;
8686 dwarf_vma signature_low
;
8689 /* PR 17512: file: 002-168123-0.004. */
8692 warn (_("Section %s is empty\n"), section
->name
);
8695 /* PR 17512: file: 002-376-0.004. */
8696 if (section
->size
< 24)
8698 warn (_("Section %s is too small to contain a CU/TU header\n"),
8703 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
8705 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
8706 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
8707 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
8710 pindex
= phash
+ nslots
* 8;
8711 ppool
= pindex
+ nslots
* 4;
8713 /* PR 17531: file: 45d69832. */
8714 if (pindex
< phash
|| ppool
< phdr
|| (pindex
== phash
&& nslots
!= 0))
8716 warn (_("Section %s is too small for %d slots\n"),
8717 section
->name
, nslots
);
8723 printf (_("Contents of the %s section:\n\n"), section
->name
);
8724 printf (_(" Version: %d\n"), version
);
8726 printf (_(" Number of columns: %d\n"), ncols
);
8727 printf (_(" Number of used entries: %d\n"), nused
);
8728 printf (_(" Number of slots: %d\n\n"), nslots
);
8731 if (ppool
> limit
|| ppool
< phdr
)
8733 warn (_("Section %s too small for %d hash table entries\n"),
8734 section
->name
, nslots
);
8741 prealloc_cu_tu_list ((limit
- ppool
) / 4);
8742 for (i
= 0; i
< nslots
; i
++)
8744 unsigned char *shndx_list
;
8747 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
8748 if (signature_high
!= 0 || signature_low
!= 0)
8750 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
8751 shndx_list
= ppool
+ j
* 4;
8752 /* PR 17531: file: 705e010d. */
8753 if (shndx_list
< ppool
)
8755 warn (_("Section index pool located before start of section\n"));
8760 printf (_(" [%3d] Signature: 0x%s Sections: "),
8761 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
8762 buf
, sizeof (buf
)));
8765 if (shndx_list
>= limit
)
8767 warn (_("Section %s too small for shndx pool\n"),
8771 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
8775 printf (" %d", shndx
);
8777 add_shndx_to_cu_tu_entry (shndx
);
8789 else if (version
== 2)
8792 unsigned int dw_sect
;
8793 unsigned char *ph
= phash
;
8794 unsigned char *pi
= pindex
;
8795 unsigned char *poffsets
= ppool
+ ncols
* 4;
8796 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
8797 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
8798 bfd_boolean is_tu_index
;
8799 struct cu_tu_set
*this_set
= NULL
;
8801 unsigned char *prow
;
8803 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
8805 /* PR 17531: file: 0dd159bf.
8806 Check for wraparound with an overlarge ncols value. */
8807 if (poffsets
< ppool
|| (unsigned int) ((poffsets
- ppool
) / 4) != ncols
)
8809 warn (_("Overlarge number of columns: %x\n"), ncols
);
8815 warn (_("Section %s too small for offset and size tables\n"),
8822 printf (_(" Offset table\n"));
8823 printf (" slot %-16s ",
8824 is_tu_index
? _("signature") : _("dwo_id"));
8831 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
8837 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
8844 for (j
= 0; j
< ncols
; j
++)
8846 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
8847 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
8852 for (i
= 0; i
< nslots
; i
++)
8854 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
8856 SAFE_BYTE_GET (row
, pi
, 4, limit
);
8859 /* PR 17531: file: a05f6ab3. */
8862 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
8868 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
8870 prow
= poffsets
+ (row
- 1) * ncols
* 4;
8871 /* PR 17531: file: b8ce60a8. */
8872 if (prow
< poffsets
|| prow
> limit
)
8874 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
8880 printf (_(" [%3d] 0x%s"),
8881 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
8882 buf
, sizeof (buf
)));
8883 for (j
= 0; j
< ncols
; j
++)
8885 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
8887 printf (" %8d", val
);
8890 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
8892 /* PR 17531: file: 10796eb3. */
8893 if (dw_sect
>= DW_SECT_MAX
)
8894 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
8896 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
8912 printf (_(" Size table\n"));
8913 printf (" slot %-16s ",
8914 is_tu_index
? _("signature") : _("dwo_id"));
8917 for (j
= 0; j
< ncols
; j
++)
8919 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
8921 printf (" %8s", get_DW_SECT_short_name (val
));
8927 for (i
= 0; i
< nslots
; i
++)
8929 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
8931 SAFE_BYTE_GET (row
, pi
, 4, limit
);
8934 prow
= psizes
+ (row
- 1) * ncols
* 4;
8937 printf (_(" [%3d] 0x%s"),
8938 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
8939 buf
, sizeof (buf
)));
8941 for (j
= 0; j
< ncols
; j
++)
8943 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
8945 printf (" %8d", val
);
8948 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
8949 if (dw_sect
>= DW_SECT_MAX
)
8950 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
8952 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
8964 else if (do_display
)
8965 printf (_(" Unsupported version (%d)\n"), version
);
8973 /* Load the CU and TU indexes if present. This will build a list of
8974 section sets that we can use to associate a .debug_info.dwo section
8975 with its associated .debug_abbrev.dwo section in a .dwp file. */
8978 load_cu_tu_indexes (void *file
)
8980 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
8982 /* If we have already loaded (or tried to load) the CU and TU indexes
8983 then do not bother to repeat the task. */
8984 if (cu_tu_indexes_read
== -1)
8986 cu_tu_indexes_read
= TRUE
;
8988 if (load_debug_section (dwp_cu_index
, file
))
8989 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
8990 cu_tu_indexes_read
= FALSE
;
8992 if (load_debug_section (dwp_tu_index
, file
))
8993 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
8994 cu_tu_indexes_read
= FALSE
;
8997 return (bfd_boolean
) cu_tu_indexes_read
;
9000 /* Find the set of sections that includes section SHNDX. */
9003 find_cu_tu_set (void *file
, unsigned int shndx
)
9007 if (! load_cu_tu_indexes (file
))
9010 /* Find SHNDX in the shndx pool. */
9011 for (i
= 0; i
< shndx_pool_used
; i
++)
9012 if (shndx_pool
[i
] == shndx
)
9015 if (i
>= shndx_pool_used
)
9018 /* Now backup to find the first entry in the set. */
9019 while (i
> 0 && shndx_pool
[i
- 1] != 0)
9022 return shndx_pool
+ i
;
9025 /* Display a .debug_cu_index or .debug_tu_index section. */
9028 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
9030 return process_cu_tu_index (section
, 1);
9034 display_debug_not_supported (struct dwarf_section
*section
,
9035 void *file ATTRIBUTE_UNUSED
)
9037 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9043 /* Like malloc, but takes two parameters like calloc.
9044 Verifies that the first parameter is not too large.
9045 Note: does *not* initialise the allocated memory to zero. */
9047 cmalloc (size_t nmemb
, size_t size
)
9049 /* Check for overflow. */
9050 if (nmemb
>= ~(size_t) 0 / size
)
9053 return xmalloc (nmemb
* size
);
9056 /* Like xmalloc, but takes two parameters like calloc.
9057 Verifies that the first parameter is not too large.
9058 Note: does *not* initialise the allocated memory to zero. */
9060 xcmalloc (size_t nmemb
, size_t size
)
9062 /* Check for overflow. */
9063 if (nmemb
>= ~(size_t) 0 / size
)
9066 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
9071 return xmalloc (nmemb
* size
);
9074 /* Like xrealloc, but takes three parameters.
9075 Verifies that the second parameter is not too large.
9076 Note: does *not* initialise any new memory to zero. */
9078 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
9080 /* Check for overflow. */
9081 if (nmemb
>= ~(size_t) 0 / size
)
9084 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
9089 return xrealloc (ptr
, nmemb
* size
);
9092 /* Like xcalloc, but verifies that the first parameter is not too large. */
9094 xcalloc2 (size_t nmemb
, size_t size
)
9096 /* Check for overflow. */
9097 if (nmemb
>= ~(size_t) 0 / size
)
9100 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
9105 return xcalloc (nmemb
, size
);
9109 free_debug_memory (void)
9115 for (i
= 0; i
< max
; i
++)
9116 free_debug_section ((enum dwarf_section_display_enum
) i
);
9118 if (debug_information
!= NULL
)
9120 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
9122 for (i
= 0; i
< num_debug_info_entries
; i
++)
9124 if (!debug_information
[i
].max_loc_offsets
)
9126 free (debug_information
[i
].loc_offsets
);
9127 free (debug_information
[i
].have_frame_base
);
9129 if (!debug_information
[i
].max_range_lists
)
9130 free (debug_information
[i
].range_lists
);
9133 free (debug_information
);
9134 debug_information
= NULL
;
9135 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
9140 dwarf_select_sections_by_names (const char *names
)
9144 const char * option
;
9148 debug_dump_long_opts
;
9150 static const debug_dump_long_opts opts_table
[] =
9152 /* Please keep this table alpha- sorted. */
9153 { "Ranges", & do_debug_ranges
, 1 },
9154 { "abbrev", & do_debug_abbrevs
, 1 },
9155 { "addr", & do_debug_addr
, 1 },
9156 { "aranges", & do_debug_aranges
, 1 },
9157 { "cu_index", & do_debug_cu_index
, 1 },
9158 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
9159 { "frames", & do_debug_frames
, 1 },
9160 { "frames-interp", & do_debug_frames_interp
, 1 },
9161 /* The special .gdb_index section. */
9162 { "gdb_index", & do_gdb_index
, 1 },
9163 { "info", & do_debug_info
, 1 },
9164 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
9165 { "loc", & do_debug_loc
, 1 },
9166 { "macro", & do_debug_macinfo
, 1 },
9167 { "pubnames", & do_debug_pubnames
, 1 },
9168 { "pubtypes", & do_debug_pubtypes
, 1 },
9169 /* This entry is for compatibility
9170 with earlier versions of readelf. */
9171 { "ranges", & do_debug_aranges
, 1 },
9172 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
9173 { "str", & do_debug_str
, 1 },
9174 /* These trace_* sections are used by Itanium VMS. */
9175 { "trace_abbrev", & do_trace_abbrevs
, 1 },
9176 { "trace_aranges", & do_trace_aranges
, 1 },
9177 { "trace_info", & do_trace_info
, 1 },
9186 const debug_dump_long_opts
* entry
;
9188 for (entry
= opts_table
; entry
->option
; entry
++)
9190 size_t len
= strlen (entry
->option
);
9192 if (strncmp (p
, entry
->option
, len
) == 0
9193 && (p
[len
] == ',' || p
[len
] == '\0'))
9195 * entry
->variable
|= entry
->val
;
9197 /* The --debug-dump=frames-interp option also
9198 enables the --debug-dump=frames option. */
9199 if (do_debug_frames_interp
)
9200 do_debug_frames
= 1;
9207 if (entry
->option
== NULL
)
9209 warn (_("Unrecognized debug option '%s'\n"), p
);
9210 p
= strchr (p
, ',');
9221 dwarf_select_sections_by_letters (const char *letters
)
9223 unsigned int lindex
= 0;
9225 while (letters
[lindex
])
9226 switch (letters
[lindex
++])
9233 do_debug_abbrevs
= 1;
9237 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
9241 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
9245 do_debug_pubnames
= 1;
9249 do_debug_pubtypes
= 1;
9253 do_debug_aranges
= 1;
9257 do_debug_ranges
= 1;
9261 do_debug_frames_interp
= 1;
9264 do_debug_frames
= 1;
9268 do_debug_macinfo
= 1;
9280 warn (_("Unrecognized debug option '%s'\n"), letters
);
9286 dwarf_select_sections_all (void)
9289 do_debug_abbrevs
= 1;
9290 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
9291 do_debug_pubnames
= 1;
9292 do_debug_pubtypes
= 1;
9293 do_debug_aranges
= 1;
9294 do_debug_ranges
= 1;
9295 do_debug_frames
= 1;
9296 do_debug_macinfo
= 1;
9301 do_trace_abbrevs
= 1;
9302 do_trace_aranges
= 1;
9304 do_debug_cu_index
= 1;
9307 struct dwarf_section_display debug_displays
[] =
9309 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9310 display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
9311 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9312 display_debug_aranges
, &do_debug_aranges
, TRUE
},
9313 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9314 display_debug_frames
, &do_debug_frames
, TRUE
},
9315 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
, NULL
, 0, NULL
},
9316 display_debug_info
, &do_debug_info
, TRUE
},
9317 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9318 display_debug_lines
, &do_debug_lines
, TRUE
},
9319 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9320 display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
9321 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9322 display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
9323 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9324 display_debug_frames
, &do_debug_frames
, TRUE
},
9325 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9326 display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
9327 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9328 display_debug_macro
, &do_debug_macinfo
, TRUE
},
9329 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9330 display_debug_str
, &do_debug_str
, FALSE
},
9331 { { ".debug_line_str", ".zdebug_line_str", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9332 display_debug_str
, &do_debug_str
, FALSE
},
9333 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9334 display_debug_loc
, &do_debug_loc
, TRUE
},
9335 { { ".debug_loclists", ".zdebug_loclists", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9336 display_debug_loc
, &do_debug_loc
, TRUE
},
9337 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9338 display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
9339 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9340 display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
9341 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9342 display_debug_ranges
, &do_debug_ranges
, TRUE
},
9343 { { ".debug_rnglists", ".zdebug_rnglists", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9344 display_debug_ranges
, &do_debug_ranges
, TRUE
},
9345 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9346 display_debug_not_supported
, NULL
, FALSE
},
9347 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9348 display_debug_not_supported
, NULL
, FALSE
},
9349 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
, NULL
, 0, NULL
},
9350 display_debug_types
, &do_debug_info
, TRUE
},
9351 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9352 display_debug_not_supported
, NULL
, FALSE
},
9353 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9354 display_gdb_index
, &do_gdb_index
, FALSE
},
9355 { { ".debug_names", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9356 display_debug_names
, &do_gdb_index
, FALSE
},
9357 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
, NULL
, 0, NULL
},
9358 display_trace_info
, &do_trace_info
, TRUE
},
9359 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9360 display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
9361 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9362 display_debug_aranges
, &do_trace_aranges
, FALSE
},
9363 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
, 0, NULL
},
9364 display_debug_info
, &do_debug_info
, TRUE
},
9365 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9366 display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
9367 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
, 0, NULL
},
9368 display_debug_types
, &do_debug_info
, TRUE
},
9369 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9370 display_debug_lines
, &do_debug_lines
, TRUE
},
9371 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9372 display_debug_loc
, &do_debug_loc
, TRUE
},
9373 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9374 display_debug_macro
, &do_debug_macinfo
, TRUE
},
9375 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9376 display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
9377 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9378 display_debug_str
, &do_debug_str
, TRUE
},
9379 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9380 display_debug_str_offsets
, NULL
, FALSE
},
9381 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9382 display_debug_str_offsets
, NULL
, FALSE
},
9383 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9384 display_debug_addr
, &do_debug_addr
, TRUE
},
9385 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9386 display_cu_index
, &do_debug_cu_index
, FALSE
},
9387 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
9388 display_cu_index
, &do_debug_cu_index
, FALSE
},
9391 /* A static assertion. */
9392 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];