1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2015 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"
32 static const char *regname (unsigned int regno
, int row
);
34 static int have_frame_base
;
35 static int need_base_address
;
37 static unsigned int last_pointer_size
= 0;
38 static int warned_about_missing_comp_units
= FALSE
;
40 static unsigned int num_debug_info_entries
= 0;
41 static unsigned int alloc_num_debug_info_entries
= 0;
42 static debug_info
*debug_information
= NULL
;
43 /* Special value for num_debug_info_entries to indicate
44 that the .debug_info section could not be loaded/parsed. */
45 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
52 int do_debug_pubnames
;
53 int do_debug_pubtypes
;
57 int do_debug_frames_interp
;
66 int do_debug_cu_index
;
69 int dwarf_cutoff_level
= -1;
70 unsigned long dwarf_start_die
;
74 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
75 sections. For version 1 package files, each set is stored in SHNDX_POOL
76 as a zero-terminated list of section indexes comprising one set of debug
77 sections from a .dwo file. */
79 static int cu_tu_indexes_read
= 0;
80 static unsigned int *shndx_pool
= NULL
;
81 static unsigned int shndx_pool_size
= 0;
82 static unsigned int shndx_pool_used
= 0;
84 /* For version 2 package files, each set contains an array of section offsets
85 and an array of section sizes, giving the offset and size of the
86 contribution from a CU or TU within one of the debug sections.
87 When displaying debug info from a package file, we need to use these
88 tables to locate the corresponding contributions to each section. */
93 dwarf_vma section_offsets
[DW_SECT_MAX
];
94 size_t section_sizes
[DW_SECT_MAX
];
97 static int cu_count
= 0;
98 static int tu_count
= 0;
99 static struct cu_tu_set
*cu_sets
= NULL
;
100 static struct cu_tu_set
*tu_sets
= NULL
;
102 static void load_cu_tu_indexes (void *file
);
104 /* Values for do_debug_lines. */
105 #define FLAG_DEBUG_LINES_RAW 1
106 #define FLAG_DEBUG_LINES_DECODED 2
109 size_of_encoded_value (int encoding
)
111 switch (encoding
& 0x7)
114 case 0: return eh_addr_size
;
122 get_encoded_value (unsigned char **pdata
,
124 struct dwarf_section
*section
,
127 unsigned char * data
= * pdata
;
128 unsigned int size
= size_of_encoded_value (encoding
);
131 if (data
+ size
>= end
)
133 warn (_("Encoded value extends past end of section\n"));
138 /* PR 17512: file: 002-829853-0.004. */
141 warn (_("Encoded size of %d is too large to read\n"), size
);
146 /* PR 17512: file: 1085-5603-0.004. */
149 warn (_("Encoded size of 0 is too small to read\n"));
154 if (encoding
& DW_EH_PE_signed
)
155 val
= byte_get_signed (data
, size
);
157 val
= byte_get (data
, size
);
159 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
160 val
+= section
->address
+ (data
- section
->start
);
162 * pdata
= data
+ size
;
166 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
168 # define DWARF_VMA_FMT "ll"
169 # define DWARF_VMA_FMT_LONG "%16.16llx"
171 # define DWARF_VMA_FMT "I64"
172 # define DWARF_VMA_FMT_LONG "%016I64x"
175 # define DWARF_VMA_FMT "l"
176 # define DWARF_VMA_FMT_LONG "%16.16lx"
179 /* Convert a dwarf vma value into a string. Returns a pointer to a static
180 buffer containing the converted VALUE. The value is converted according
181 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
182 it specifies the maximum number of bytes to be displayed in the converted
183 value and FMTCH is ignored - hex is always used. */
186 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
188 /* As dwarf_vmatoa is used more then once in a printf call
189 for output, we are cycling through an fixed array of pointers
190 for return address. */
191 static int buf_pos
= 0;
192 static struct dwarf_vmatoa_buf
198 ret
= buf
[buf_pos
++].place
;
199 buf_pos
%= ARRAY_SIZE (buf
);
203 /* Printf does not have a way of specifiying a maximum field width for an
204 integer value, so we print the full value into a buffer and then select
205 the precision we need. */
206 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
209 return ret
+ (16 - 2 * num_bytes
);
215 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
216 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
221 static inline const char *
222 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
224 return dwarf_vmatoa_1 (fmtch
, value
, 0);
227 /* Print a dwarf_vma value (typically an address, offset or length) in
228 hexadecimal format, followed by a space. The length of the VALUE (and
229 hence the precision displayed) is determined by the NUM_BYTES parameter. */
232 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
234 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
237 /* Format a 64-bit value, given as two 32-bit values, in hex.
238 For reentrancy, this uses a buffer provided by the caller. */
241 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
242 unsigned int buf_len
)
247 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
250 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
251 snprintf (buf
+ len
, buf_len
- len
,
252 "%08" DWARF_VMA_FMT
"x", lvalue
);
258 /* Read in a LEB128 encoded value starting at address DATA.
259 If SIGN is true, return a signed LEB128 value.
260 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
261 No bytes will be read at address END or beyond. */
264 read_leb128 (unsigned char *data
,
265 unsigned int *length_return
,
267 const unsigned char * const end
)
269 dwarf_vma result
= 0;
270 unsigned int num_read
= 0;
271 unsigned int shift
= 0;
272 unsigned char byte
= 0;
279 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
282 if ((byte
& 0x80) == 0)
286 if (length_return
!= NULL
)
287 *length_return
= num_read
;
289 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
290 result
|= (dwarf_vma
) -1 << shift
;
295 /* Create a signed version to avoid painful typecasts. */
296 static inline dwarf_signed_vma
297 read_sleb128 (unsigned char * data
,
298 unsigned int * length_return
,
299 const unsigned char * const end
)
301 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
304 static inline dwarf_vma
305 read_uleb128 (unsigned char * data
,
306 unsigned int * length_return
,
307 const unsigned char * const end
)
309 return read_leb128 (data
, length_return
, FALSE
, end
);
312 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
315 int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
316 unsigned int amount = (AMOUNT); \
317 if (((PTR) + amount) >= (END)) \
320 amount = (END) - (PTR); \
324 if (amount == 0 || amount > 8) \
327 VAL = byte_get ((PTR), amount); \
331 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
334 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
339 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
342 unsigned int amount = (AMOUNT); \
343 if (((PTR) + amount) >= (END)) \
346 amount = (END) - (PTR); \
351 VAL = byte_get_signed ((PTR), amount); \
357 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
360 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
365 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
368 if (((PTR) + 8) <= (END)) \
370 byte_get_64 ((PTR), (HIGH), (LOW)); \
374 * (LOW) = * (HIGH) = 0; \
379 typedef struct State_Machine_Registers
387 unsigned char op_index
;
388 unsigned char end_sequence
;
389 /* This variable hold the number of the last entry seen
390 in the File Table. */
391 unsigned int last_file_entry
;
394 static SMR state_machine_regs
;
397 reset_state_machine (int is_stmt
)
399 state_machine_regs
.address
= 0;
400 state_machine_regs
.op_index
= 0;
401 state_machine_regs
.file
= 1;
402 state_machine_regs
.line
= 1;
403 state_machine_regs
.column
= 0;
404 state_machine_regs
.is_stmt
= is_stmt
;
405 state_machine_regs
.basic_block
= 0;
406 state_machine_regs
.end_sequence
= 0;
407 state_machine_regs
.last_file_entry
= 0;
410 /* Handled an extend line op.
411 Returns the number of bytes read. */
414 process_extended_line_op (unsigned char * data
,
418 unsigned char op_code
;
419 unsigned int bytes_read
;
422 unsigned char *orig_data
= data
;
425 len
= read_uleb128 (data
, & bytes_read
, end
);
428 if (len
== 0 || data
== end
|| len
> (uintptr_t) (end
- data
))
430 warn (_("Badly formed extended line op encountered!\n"));
437 printf (_(" Extended opcode %d: "), op_code
);
441 case DW_LNE_end_sequence
:
442 printf (_("End of Sequence\n\n"));
443 reset_state_machine (is_stmt
);
446 case DW_LNE_set_address
:
447 /* PR 17512: file: 002-100480-0.004. */
448 if (len
- bytes_read
- 1 > 8)
449 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
450 len
- bytes_read
- 1);
451 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
452 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
453 state_machine_regs
.address
= adr
;
454 state_machine_regs
.op_index
= 0;
457 case DW_LNE_define_file
:
458 printf (_("define new File Table entry\n"));
459 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
460 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
463 data
+= strnlen ((char *) data
, end
- data
) + 1;
464 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
466 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
468 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
470 printf ("%s\n\n", name
);
472 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
473 warn (_("DW_LNE_define_file: Bad opcode length\n"));
476 case DW_LNE_set_discriminator
:
477 printf (_("set Discriminator to %s\n"),
478 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
482 case DW_LNE_HP_negate_is_UV_update
:
483 printf ("DW_LNE_HP_negate_is_UV_update\n");
485 case DW_LNE_HP_push_context
:
486 printf ("DW_LNE_HP_push_context\n");
488 case DW_LNE_HP_pop_context
:
489 printf ("DW_LNE_HP_pop_context\n");
491 case DW_LNE_HP_set_file_line_column
:
492 printf ("DW_LNE_HP_set_file_line_column\n");
494 case DW_LNE_HP_set_routine_name
:
495 printf ("DW_LNE_HP_set_routine_name\n");
497 case DW_LNE_HP_set_sequence
:
498 printf ("DW_LNE_HP_set_sequence\n");
500 case DW_LNE_HP_negate_post_semantics
:
501 printf ("DW_LNE_HP_negate_post_semantics\n");
503 case DW_LNE_HP_negate_function_exit
:
504 printf ("DW_LNE_HP_negate_function_exit\n");
506 case DW_LNE_HP_negate_front_end_logical
:
507 printf ("DW_LNE_HP_negate_front_end_logical\n");
509 case DW_LNE_HP_define_proc
:
510 printf ("DW_LNE_HP_define_proc\n");
512 case DW_LNE_HP_source_file_correlation
:
514 unsigned char *edata
= data
+ len
- bytes_read
- 1;
516 printf ("DW_LNE_HP_source_file_correlation\n");
522 opc
= read_uleb128 (data
, & bytes_read
, edata
);
527 case DW_LNE_HP_SFC_formfeed
:
528 printf (" DW_LNE_HP_SFC_formfeed\n");
530 case DW_LNE_HP_SFC_set_listing_line
:
531 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
533 read_uleb128 (data
, & bytes_read
, edata
)));
536 case DW_LNE_HP_SFC_associate
:
537 printf (" DW_LNE_HP_SFC_associate ");
540 read_uleb128 (data
, & bytes_read
, edata
)));
544 read_uleb128 (data
, & bytes_read
, edata
)));
548 read_uleb128 (data
, & bytes_read
, edata
)));
552 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
562 unsigned int rlen
= len
- bytes_read
- 1;
564 if (op_code
>= DW_LNE_lo_user
565 /* The test against DW_LNW_hi_user is redundant due to
566 the limited range of the unsigned char data type used
568 /*&& op_code <= DW_LNE_hi_user*/)
569 printf (_("user defined: "));
571 printf (_("UNKNOWN: "));
572 printf (_("length %d ["), rlen
);
574 printf (" %02x", *data
++);
583 static const unsigned char *
584 fetch_indirect_string (dwarf_vma offset
)
586 struct dwarf_section
*section
= &debug_displays
[str
].section
;
588 if (section
->start
== NULL
)
589 return (const unsigned char *) _("<no .debug_str section>");
591 if (offset
> section
->size
)
593 warn (_("DW_FORM_strp offset too big: %s\n"),
594 dwarf_vmatoa ("x", offset
));
595 return (const unsigned char *) _("<offset is too big>");
598 return (const unsigned char *) section
->start
+ offset
;
602 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
603 dwarf_vma offset_size
, int dwo
)
605 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
606 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
607 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
608 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
609 dwarf_vma index_offset
= idx
* offset_size
;
610 dwarf_vma str_offset
;
612 if (index_section
->start
== NULL
)
613 return (dwo
? _("<no .debug_str_offsets.dwo section>")
614 : _("<no .debug_str_offsets section>"));
616 if (this_set
!= NULL
)
617 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
618 if (index_offset
> index_section
->size
)
620 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
621 dwarf_vmatoa ("x", index_offset
));
622 return _("<index offset is too big>");
625 if (str_section
->start
== NULL
)
626 return (dwo
? _("<no .debug_str.dwo section>")
627 : _("<no .debug_str section>"));
629 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
630 str_offset
-= str_section
->address
;
631 if (str_offset
> str_section
->size
)
633 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
634 dwarf_vmatoa ("x", str_offset
));
635 return _("<indirect index offset is too big>");
638 return (const char *) str_section
->start
+ str_offset
;
642 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
644 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
646 if (section
->start
== NULL
)
647 return (_("<no .debug_addr section>"));
649 if (offset
+ bytes
> section
->size
)
651 warn (_("Offset into section %s too big: %s\n"),
652 section
->name
, dwarf_vmatoa ("x", offset
));
653 return "<offset too big>";
656 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
660 /* FIXME: There are better and more efficient ways to handle
661 these structures. For now though, I just want something that
662 is simple to implement. */
663 typedef struct abbrev_attr
665 unsigned long attribute
;
667 struct abbrev_attr
*next
;
671 typedef struct abbrev_entry
676 struct abbrev_attr
*first_attr
;
677 struct abbrev_attr
*last_attr
;
678 struct abbrev_entry
*next
;
682 static abbrev_entry
*first_abbrev
= NULL
;
683 static abbrev_entry
*last_abbrev
= NULL
;
690 for (abbrv
= first_abbrev
; abbrv
;)
692 abbrev_entry
*next_abbrev
= abbrv
->next
;
695 for (attr
= abbrv
->first_attr
; attr
;)
697 abbrev_attr
*next_attr
= attr
->next
;
707 last_abbrev
= first_abbrev
= NULL
;
711 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
715 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
720 entry
->entry
= number
;
722 entry
->children
= children
;
723 entry
->first_attr
= NULL
;
724 entry
->last_attr
= NULL
;
727 if (first_abbrev
== NULL
)
728 first_abbrev
= entry
;
730 last_abbrev
->next
= entry
;
736 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
740 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
745 attr
->attribute
= attribute
;
749 if (last_abbrev
->first_attr
== NULL
)
750 last_abbrev
->first_attr
= attr
;
752 last_abbrev
->last_attr
->next
= attr
;
754 last_abbrev
->last_attr
= attr
;
757 /* Processes the (partial) contents of a .debug_abbrev section.
758 Returns NULL if the end of the section was encountered.
759 Returns the address after the last byte read if the end of
760 an abbreviation set was found. */
762 static unsigned char *
763 process_abbrev_section (unsigned char *start
, unsigned char *end
)
765 if (first_abbrev
!= NULL
)
770 unsigned int bytes_read
;
773 unsigned long attribute
;
776 entry
= read_uleb128 (start
, & bytes_read
, end
);
779 /* A single zero is supposed to end the section according
780 to the standard. If there's more, then signal that to
787 tag
= read_uleb128 (start
, & bytes_read
, end
);
794 add_abbrev (entry
, tag
, children
);
800 attribute
= read_uleb128 (start
, & bytes_read
, end
);
805 form
= read_uleb128 (start
, & bytes_read
, end
);
810 add_abbrev_attr (attribute
, form
);
812 while (attribute
!= 0);
815 /* Report the missing single zero which ends the section. */
816 error (_(".debug_abbrev section not zero terminated\n"));
822 get_TAG_name (unsigned long tag
)
824 const char *name
= get_DW_TAG_name ((unsigned int)tag
);
828 static char buffer
[100];
830 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
838 get_FORM_name (unsigned long form
)
843 return "DW_FORM value: 0";
845 name
= get_DW_FORM_name (form
);
848 static char buffer
[100];
850 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
857 static unsigned char *
858 display_block (unsigned char *data
,
860 const unsigned char * const end
)
864 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length
));
866 return (unsigned char *) end
;
868 maxlen
= (dwarf_vma
) (end
- data
);
869 length
= length
> maxlen
? maxlen
: length
;
872 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
878 decode_location_expression (unsigned char * data
,
879 unsigned int pointer_size
,
880 unsigned int offset_size
,
884 struct dwarf_section
* section
)
887 unsigned int bytes_read
;
889 dwarf_signed_vma svalue
;
890 unsigned char *end
= data
+ length
;
891 int need_frame_base
= 0;
900 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
901 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
904 printf ("DW_OP_deref");
907 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
908 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
911 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
912 printf ("DW_OP_const1s: %ld", (long) svalue
);
915 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
916 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
919 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
920 printf ("DW_OP_const2s: %ld", (long) svalue
);
923 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
924 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
927 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
928 printf ("DW_OP_const4s: %ld", (long) svalue
);
931 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
932 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
933 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
934 printf ("%lu", (unsigned long) uvalue
);
937 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
938 printf ("DW_OP_const8s: %ld ", (long) svalue
);
939 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
940 printf ("%ld", (long) svalue
);
943 printf ("DW_OP_constu: %s",
944 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
948 printf ("DW_OP_consts: %s",
949 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
953 printf ("DW_OP_dup");
956 printf ("DW_OP_drop");
959 printf ("DW_OP_over");
962 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
963 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
966 printf ("DW_OP_swap");
969 printf ("DW_OP_rot");
972 printf ("DW_OP_xderef");
975 printf ("DW_OP_abs");
978 printf ("DW_OP_and");
981 printf ("DW_OP_div");
984 printf ("DW_OP_minus");
987 printf ("DW_OP_mod");
990 printf ("DW_OP_mul");
993 printf ("DW_OP_neg");
996 printf ("DW_OP_not");
1002 printf ("DW_OP_plus");
1004 case DW_OP_plus_uconst
:
1005 printf ("DW_OP_plus_uconst: %s",
1006 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1010 printf ("DW_OP_shl");
1013 printf ("DW_OP_shr");
1016 printf ("DW_OP_shra");
1019 printf ("DW_OP_xor");
1022 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1023 printf ("DW_OP_bra: %ld", (long) svalue
);
1026 printf ("DW_OP_eq");
1029 printf ("DW_OP_ge");
1032 printf ("DW_OP_gt");
1035 printf ("DW_OP_le");
1038 printf ("DW_OP_lt");
1041 printf ("DW_OP_ne");
1044 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1045 printf ("DW_OP_skip: %ld", (long) svalue
);
1080 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1115 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1116 regname (op
- DW_OP_reg0
, 1));
1151 printf ("DW_OP_breg%d (%s): %s",
1153 regname (op
- DW_OP_breg0
, 1),
1154 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1159 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1161 printf ("DW_OP_regx: %s (%s)",
1162 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1165 need_frame_base
= 1;
1166 printf ("DW_OP_fbreg: %s",
1167 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1171 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1173 printf ("DW_OP_bregx: %s (%s) %s",
1174 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1175 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1179 printf ("DW_OP_piece: %s",
1180 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1183 case DW_OP_deref_size
:
1184 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1185 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1187 case DW_OP_xderef_size
:
1188 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1189 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1192 printf ("DW_OP_nop");
1195 /* DWARF 3 extensions. */
1196 case DW_OP_push_object_address
:
1197 printf ("DW_OP_push_object_address");
1200 /* XXX: Strictly speaking for 64-bit DWARF3 files
1201 this ought to be an 8-byte wide computation. */
1202 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1203 printf ("DW_OP_call2: <0x%s>",
1204 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1207 /* XXX: Strictly speaking for 64-bit DWARF3 files
1208 this ought to be an 8-byte wide computation. */
1209 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1210 printf ("DW_OP_call4: <0x%s>",
1211 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1213 case DW_OP_call_ref
:
1214 /* XXX: Strictly speaking for 64-bit DWARF3 files
1215 this ought to be an 8-byte wide computation. */
1216 if (dwarf_version
== -1)
1218 printf (_("(DW_OP_call_ref in frame info)"));
1219 /* No way to tell where the next op is, so just bail. */
1220 return need_frame_base
;
1222 if (dwarf_version
== 2)
1224 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1228 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1230 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1232 case DW_OP_form_tls_address
:
1233 printf ("DW_OP_form_tls_address");
1235 case DW_OP_call_frame_cfa
:
1236 printf ("DW_OP_call_frame_cfa");
1238 case DW_OP_bit_piece
:
1239 printf ("DW_OP_bit_piece: ");
1240 printf (_("size: %s "),
1241 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1243 printf (_("offset: %s "),
1244 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1248 /* DWARF 4 extensions. */
1249 case DW_OP_stack_value
:
1250 printf ("DW_OP_stack_value");
1253 case DW_OP_implicit_value
:
1254 printf ("DW_OP_implicit_value");
1255 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1257 data
= display_block (data
, uvalue
, end
);
1260 /* GNU extensions. */
1261 case DW_OP_GNU_push_tls_address
:
1262 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1264 case DW_OP_GNU_uninit
:
1265 printf ("DW_OP_GNU_uninit");
1266 /* FIXME: Is there data associated with this OP ? */
1268 case DW_OP_GNU_encoded_addr
:
1275 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1277 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1278 print_dwarf_vma (addr
, pointer_size
);
1281 case DW_OP_GNU_implicit_pointer
:
1282 /* XXX: Strictly speaking for 64-bit DWARF3 files
1283 this ought to be an 8-byte wide computation. */
1284 if (dwarf_version
== -1)
1286 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1287 /* No way to tell where the next op is, so just bail. */
1288 return need_frame_base
;
1290 if (dwarf_version
== 2)
1292 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1296 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1298 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1299 dwarf_vmatoa ("x", uvalue
),
1300 dwarf_vmatoa ("d", read_sleb128 (data
,
1301 &bytes_read
, end
)));
1304 case DW_OP_GNU_entry_value
:
1305 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1307 /* PR 17531: file: 0cc9cd00. */
1308 if (uvalue
> (dwarf_vma
) (end
- data
))
1309 uvalue
= end
- data
;
1310 printf ("DW_OP_GNU_entry_value: (");
1311 if (decode_location_expression (data
, pointer_size
, offset_size
,
1312 dwarf_version
, uvalue
,
1313 cu_offset
, section
))
1314 need_frame_base
= 1;
1320 case DW_OP_GNU_const_type
:
1321 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1323 printf ("DW_OP_GNU_const_type: <0x%s> ",
1324 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1325 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1326 data
= display_block (data
, uvalue
, end
);
1328 case DW_OP_GNU_regval_type
:
1329 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1331 printf ("DW_OP_GNU_regval_type: %s (%s)",
1332 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1333 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1335 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1337 case DW_OP_GNU_deref_type
:
1338 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1339 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue
);
1340 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1342 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1344 case DW_OP_GNU_convert
:
1345 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1347 printf ("DW_OP_GNU_convert <0x%s>",
1348 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1350 case DW_OP_GNU_reinterpret
:
1351 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1353 printf ("DW_OP_GNU_reinterpret <0x%s>",
1354 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1356 case DW_OP_GNU_parameter_ref
:
1357 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1358 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1359 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1361 case DW_OP_GNU_addr_index
:
1362 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1364 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1366 case DW_OP_GNU_const_index
:
1367 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1369 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1372 /* HP extensions. */
1373 case DW_OP_HP_is_value
:
1374 printf ("DW_OP_HP_is_value");
1375 /* FIXME: Is there data associated with this OP ? */
1377 case DW_OP_HP_fltconst4
:
1378 printf ("DW_OP_HP_fltconst4");
1379 /* FIXME: Is there data associated with this OP ? */
1381 case DW_OP_HP_fltconst8
:
1382 printf ("DW_OP_HP_fltconst8");
1383 /* FIXME: Is there data associated with this OP ? */
1385 case DW_OP_HP_mod_range
:
1386 printf ("DW_OP_HP_mod_range");
1387 /* FIXME: Is there data associated with this OP ? */
1389 case DW_OP_HP_unmod_range
:
1390 printf ("DW_OP_HP_unmod_range");
1391 /* FIXME: Is there data associated with this OP ? */
1394 printf ("DW_OP_HP_tls");
1395 /* FIXME: Is there data associated with this OP ? */
1398 /* PGI (STMicroelectronics) extensions. */
1399 case DW_OP_PGI_omp_thread_num
:
1400 /* Pushes the thread number for the current thread as it would be
1401 returned by the standard OpenMP library function:
1402 omp_get_thread_num(). The "current thread" is the thread for
1403 which the expression is being evaluated. */
1404 printf ("DW_OP_PGI_omp_thread_num");
1408 if (op
>= DW_OP_lo_user
1409 && op
<= DW_OP_hi_user
)
1410 printf (_("(User defined location op)"));
1412 printf (_("(Unknown location op)"));
1413 /* No way to tell where the next op is, so just bail. */
1414 return need_frame_base
;
1417 /* Separate the ops. */
1422 return need_frame_base
;
1425 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1426 This is used for DWARF package files. */
1428 static struct cu_tu_set
*
1429 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1431 struct cu_tu_set
*p
;
1433 unsigned int dw_sect
;
1439 dw_sect
= DW_SECT_TYPES
;
1445 dw_sect
= DW_SECT_INFO
;
1449 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1457 /* Add INC to HIGH_BITS:LOW_BITS. */
1459 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1461 dwarf_vma tmp
= * low_bits
;
1465 /* FIXME: There is probably a better way of handling this:
1467 We need to cope with dwarf_vma being a 32-bit or 64-bit
1468 type. Plus regardless of its size LOW_BITS is meant to
1469 only hold 32-bits, so if there is overflow or wrap around
1470 we must propagate into HIGH_BITS. */
1471 if (tmp
< * low_bits
)
1475 else if (sizeof (tmp
) > 8
1485 static unsigned char *
1486 read_and_display_attr_value (unsigned long attribute
,
1488 unsigned char * data
,
1489 unsigned char * end
,
1490 dwarf_vma cu_offset
,
1491 dwarf_vma pointer_size
,
1492 dwarf_vma offset_size
,
1494 debug_info
* debug_info_p
,
1496 struct dwarf_section
* section
,
1497 struct cu_tu_set
* this_set
)
1499 dwarf_vma uvalue
= 0;
1500 unsigned char *block_start
= NULL
;
1501 unsigned char * orig_data
= data
;
1502 unsigned int bytes_read
;
1504 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
1506 warn (_("Corrupt attribute\n"));
1515 case DW_FORM_ref_addr
:
1516 if (dwarf_version
== 2)
1517 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1518 else if (dwarf_version
== 3 || dwarf_version
== 4)
1519 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1521 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1526 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1530 case DW_FORM_sec_offset
:
1531 case DW_FORM_GNU_ref_alt
:
1532 case DW_FORM_GNU_strp_alt
:
1533 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1536 case DW_FORM_flag_present
:
1543 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1548 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1553 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1557 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1561 case DW_FORM_GNU_str_index
:
1562 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1566 case DW_FORM_ref_udata
:
1568 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1572 case DW_FORM_indirect
:
1573 form
= read_uleb128 (data
, & bytes_read
, end
);
1576 printf (" %s", get_FORM_name (form
));
1577 return read_and_display_attr_value (attribute
, form
, data
, end
,
1578 cu_offset
, pointer_size
,
1579 offset_size
, dwarf_version
,
1580 debug_info_p
, do_loc
,
1582 case DW_FORM_GNU_addr_index
:
1583 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1590 case DW_FORM_ref_addr
:
1592 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue
));
1595 case DW_FORM_GNU_ref_alt
:
1597 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue
));
1603 case DW_FORM_ref_udata
:
1605 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1610 case DW_FORM_sec_offset
:
1612 printf (" 0x%s", dwarf_vmatoa ("x", uvalue
));
1615 case DW_FORM_flag_present
:
1622 printf (" %s", dwarf_vmatoa ("d", uvalue
));
1629 dwarf_vma high_bits
;
1633 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1635 if (form
== DW_FORM_ref8
)
1636 add64 (& high_bits
, & utmp
, cu_offset
);
1638 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1641 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1642 && num_debug_info_entries
== 0)
1644 if (sizeof (uvalue
) == 8)
1645 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1647 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1653 case DW_FORM_string
:
1655 printf (" %.*s", (int) (end
- data
), data
);
1656 data
+= strnlen ((char *) data
, end
- data
) + 1;
1660 case DW_FORM_exprloc
:
1661 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1662 block_start
= data
+ bytes_read
;
1663 if (block_start
>= end
)
1665 warn (_("Block ends prematurely\n"));
1669 /* PR 17512: file: 008-103549-0.001:0.1. */
1670 if (block_start
+ uvalue
> end
)
1672 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1673 uvalue
= end
- block_start
;
1676 data
= block_start
+ uvalue
;
1678 data
= display_block (block_start
, uvalue
, end
);
1681 case DW_FORM_block1
:
1682 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1683 block_start
= data
+ 1;
1684 if (block_start
>= end
)
1686 warn (_("Block ends prematurely\n"));
1690 if (block_start
+ uvalue
> end
)
1692 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1693 uvalue
= end
- block_start
;
1696 data
= block_start
+ uvalue
;
1698 data
= display_block (block_start
, uvalue
, end
);
1701 case DW_FORM_block2
:
1702 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1703 block_start
= data
+ 2;
1704 if (block_start
>= end
)
1706 warn (_("Block ends prematurely\n"));
1710 if (block_start
+ uvalue
> end
)
1712 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1713 uvalue
= end
- block_start
;
1716 data
= block_start
+ uvalue
;
1718 data
= display_block (block_start
, uvalue
, end
);
1721 case DW_FORM_block4
:
1722 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1723 block_start
= data
+ 4;
1724 /* PR 17512: file: 3371-3907-0.004. */
1725 if (block_start
>= end
)
1727 warn (_("Block ends prematurely\n"));
1731 if (block_start
+ uvalue
> end
)
1733 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1734 uvalue
= end
- block_start
;
1737 data
= block_start
+ uvalue
;
1739 data
= display_block (block_start
, uvalue
, end
);
1744 printf (_(" (indirect string, offset: 0x%s): %s"),
1745 dwarf_vmatoa ("x", uvalue
),
1746 fetch_indirect_string (uvalue
));
1749 case DW_FORM_GNU_str_index
:
1752 const char *suffix
= strrchr (section
->name
, '.');
1753 int dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? 1 : 0;
1755 printf (_(" (indexed string: 0x%s): %s"),
1756 dwarf_vmatoa ("x", uvalue
),
1757 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
1761 case DW_FORM_GNU_strp_alt
:
1763 printf (_(" (alt indirect string, offset: 0x%s)"),
1764 dwarf_vmatoa ("x", uvalue
));
1767 case DW_FORM_indirect
:
1768 /* Handled above. */
1771 case DW_FORM_ref_sig8
:
1774 dwarf_vma high_bits
;
1777 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1778 printf (" signature: 0x%s",
1779 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
1784 case DW_FORM_GNU_addr_index
:
1786 printf (_(" (addr_index: 0x%s): %s"),
1787 dwarf_vmatoa ("x", uvalue
),
1788 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
1792 warn (_("Unrecognized form: %lu\n"), form
);
1796 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1797 && num_debug_info_entries
== 0
1798 && debug_info_p
!= NULL
)
1802 case DW_AT_frame_base
:
1803 have_frame_base
= 1;
1804 case DW_AT_location
:
1805 case DW_AT_string_length
:
1806 case DW_AT_return_addr
:
1807 case DW_AT_data_member_location
:
1808 case DW_AT_vtable_elem_location
:
1810 case DW_AT_static_link
:
1811 case DW_AT_use_location
:
1812 case DW_AT_GNU_call_site_value
:
1813 case DW_AT_GNU_call_site_data_value
:
1814 case DW_AT_GNU_call_site_target
:
1815 case DW_AT_GNU_call_site_target_clobbered
:
1816 if ((dwarf_version
< 4
1817 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1818 || form
== DW_FORM_sec_offset
)
1820 /* Process location list. */
1821 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1822 unsigned int num
= debug_info_p
->num_loc_offsets
;
1824 if (lmax
== 0 || num
>= lmax
)
1827 debug_info_p
->loc_offsets
= (dwarf_vma
*)
1828 xcrealloc (debug_info_p
->loc_offsets
,
1829 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1830 debug_info_p
->have_frame_base
= (int *)
1831 xcrealloc (debug_info_p
->have_frame_base
,
1832 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1833 debug_info_p
->max_loc_offsets
= lmax
;
1835 if (this_set
!= NULL
)
1836 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
1837 debug_info_p
->loc_offsets
[num
] = uvalue
;
1838 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1839 debug_info_p
->num_loc_offsets
++;
1844 if (need_base_address
)
1845 debug_info_p
->base_address
= uvalue
;
1848 case DW_AT_GNU_addr_base
:
1849 debug_info_p
->addr_base
= uvalue
;
1852 case DW_AT_GNU_ranges_base
:
1853 debug_info_p
->ranges_base
= uvalue
;
1857 if ((dwarf_version
< 4
1858 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1859 || form
== DW_FORM_sec_offset
)
1861 /* Process range list. */
1862 unsigned int lmax
= debug_info_p
->max_range_lists
;
1863 unsigned int num
= debug_info_p
->num_range_lists
;
1865 if (lmax
== 0 || num
>= lmax
)
1868 debug_info_p
->range_lists
= (dwarf_vma
*)
1869 xcrealloc (debug_info_p
->range_lists
,
1870 lmax
, sizeof (*debug_info_p
->range_lists
));
1871 debug_info_p
->max_range_lists
= lmax
;
1873 debug_info_p
->range_lists
[num
] = uvalue
;
1874 debug_info_p
->num_range_lists
++;
1883 if (do_loc
|| attribute
== 0)
1886 /* For some attributes we can display further information. */
1893 case DW_INL_not_inlined
:
1894 printf (_("(not inlined)"));
1896 case DW_INL_inlined
:
1897 printf (_("(inlined)"));
1899 case DW_INL_declared_not_inlined
:
1900 printf (_("(declared as inline but ignored)"));
1902 case DW_INL_declared_inlined
:
1903 printf (_("(declared as inline and inlined)"));
1906 printf (_(" (Unknown inline attribute value: %s)"),
1907 dwarf_vmatoa ("x", uvalue
));
1912 case DW_AT_language
:
1916 /* Ordered by the numeric value of these constants. */
1917 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1918 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1919 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1920 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1921 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1922 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1923 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1924 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1925 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1926 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1927 /* DWARF 2.1 values. */
1928 case DW_LANG_Java
: printf ("(Java)"); break;
1929 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1930 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1931 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1932 /* DWARF 3 values. */
1933 case DW_LANG_PLI
: printf ("(PLI)"); break;
1934 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1935 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1936 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1937 case DW_LANG_D
: printf ("(D)"); break;
1938 /* DWARF 4 values. */
1939 case DW_LANG_Python
: printf ("(Python)"); break;
1940 /* DWARF 5 values. */
1941 case DW_LANG_Go
: printf ("(Go)"); break;
1942 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
1943 case DW_LANG_C11
: printf ("(C11)"); break;
1944 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
1945 /* MIPS extension. */
1946 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1947 /* UPC extension. */
1948 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1950 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1951 printf (_("(implementation defined: %s)"),
1952 dwarf_vmatoa ("x", uvalue
));
1954 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
1959 case DW_AT_encoding
:
1963 case DW_ATE_void
: printf ("(void)"); break;
1964 case DW_ATE_address
: printf ("(machine address)"); break;
1965 case DW_ATE_boolean
: printf ("(boolean)"); break;
1966 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1967 case DW_ATE_float
: printf ("(float)"); break;
1968 case DW_ATE_signed
: printf ("(signed)"); break;
1969 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1970 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1971 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1972 /* DWARF 2.1 values: */
1973 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1974 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1975 /* DWARF 3 values: */
1976 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1977 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1978 case DW_ATE_edited
: printf ("(edited)"); break;
1979 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1980 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1981 /* HP extensions: */
1982 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1983 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1984 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1985 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1986 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1987 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1988 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1991 if (uvalue
>= DW_ATE_lo_user
1992 && uvalue
<= DW_ATE_hi_user
)
1993 printf (_("(user defined type)"));
1995 printf (_("(unknown type)"));
2000 case DW_AT_accessibility
:
2004 case DW_ACCESS_public
: printf ("(public)"); break;
2005 case DW_ACCESS_protected
: printf ("(protected)"); break;
2006 case DW_ACCESS_private
: printf ("(private)"); break;
2008 printf (_("(unknown accessibility)"));
2013 case DW_AT_visibility
:
2017 case DW_VIS_local
: printf ("(local)"); break;
2018 case DW_VIS_exported
: printf ("(exported)"); break;
2019 case DW_VIS_qualified
: printf ("(qualified)"); break;
2020 default: printf (_("(unknown visibility)")); break;
2024 case DW_AT_virtuality
:
2028 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2029 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2030 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2031 default: printf (_("(unknown virtuality)")); break;
2035 case DW_AT_identifier_case
:
2039 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2040 case DW_ID_up_case
: printf ("(up_case)"); break;
2041 case DW_ID_down_case
: printf ("(down_case)"); break;
2042 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2043 default: printf (_("(unknown case)")); break;
2047 case DW_AT_calling_convention
:
2051 case DW_CC_normal
: printf ("(normal)"); break;
2052 case DW_CC_program
: printf ("(program)"); break;
2053 case DW_CC_nocall
: printf ("(nocall)"); break;
2055 if (uvalue
>= DW_CC_lo_user
2056 && uvalue
<= DW_CC_hi_user
)
2057 printf (_("(user defined)"));
2059 printf (_("(unknown convention)"));
2063 case DW_AT_ordering
:
2067 case -1: printf (_("(undefined)")); break;
2068 case 0: printf ("(row major)"); break;
2069 case 1: printf ("(column major)"); break;
2073 case DW_AT_frame_base
:
2074 have_frame_base
= 1;
2075 case DW_AT_location
:
2076 case DW_AT_string_length
:
2077 case DW_AT_return_addr
:
2078 case DW_AT_data_member_location
:
2079 case DW_AT_vtable_elem_location
:
2081 case DW_AT_static_link
:
2082 case DW_AT_use_location
:
2083 case DW_AT_GNU_call_site_value
:
2084 case DW_AT_GNU_call_site_data_value
:
2085 case DW_AT_GNU_call_site_target
:
2086 case DW_AT_GNU_call_site_target_clobbered
:
2087 if ((dwarf_version
< 4
2088 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2089 || form
== DW_FORM_sec_offset
)
2090 printf (_(" (location list)"));
2092 case DW_AT_allocated
:
2093 case DW_AT_associated
:
2094 case DW_AT_data_location
:
2096 case DW_AT_upper_bound
:
2097 case DW_AT_lower_bound
:
2100 int need_frame_base
;
2103 need_frame_base
= decode_location_expression (block_start
,
2108 cu_offset
, section
);
2110 if (need_frame_base
&& !have_frame_base
)
2111 printf (_(" [without DW_AT_frame_base]"));
2117 if (form
== DW_FORM_ref_sig8
2118 || form
== DW_FORM_GNU_ref_alt
)
2121 if (form
== DW_FORM_ref1
2122 || form
== DW_FORM_ref2
2123 || form
== DW_FORM_ref4
2124 || form
== DW_FORM_ref_udata
)
2125 uvalue
+= cu_offset
;
2127 if (uvalue
>= section
->size
)
2128 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2129 dwarf_vmatoa ("x", uvalue
),
2130 (unsigned long) (orig_data
- section
->start
));
2133 unsigned long abbrev_number
;
2134 abbrev_entry
* entry
;
2136 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2138 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2139 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2140 use different abbrev table, and we don't track .debug_info chunks
2142 if (form
!= DW_FORM_ref_addr
)
2144 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2145 if (entry
->entry
== abbrev_number
)
2148 printf (" (%s)", get_TAG_name (entry
->tag
));
2163 get_AT_name (unsigned long attribute
)
2168 return "DW_AT value: 0";
2170 /* One value is shared by the MIPS and HP extensions: */
2171 if (attribute
== DW_AT_MIPS_fde
)
2172 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2174 name
= get_DW_AT_name (attribute
);
2178 static char buffer
[100];
2180 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2188 static unsigned char *
2189 read_and_display_attr (unsigned long attribute
,
2191 unsigned char * data
,
2192 unsigned char * end
,
2193 dwarf_vma cu_offset
,
2194 dwarf_vma pointer_size
,
2195 dwarf_vma offset_size
,
2197 debug_info
* debug_info_p
,
2199 struct dwarf_section
* section
,
2200 struct cu_tu_set
* this_set
)
2203 printf (" %-18s:", get_AT_name (attribute
));
2204 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2205 cu_offset
, pointer_size
, offset_size
,
2206 dwarf_version
, debug_info_p
,
2207 do_loc
, section
, this_set
);
2213 /* Process the contents of a .debug_info section. If do_loc is non-zero
2214 then we are scanning for location lists and we do not want to display
2215 anything to the user. If do_types is non-zero, we are processing
2216 a .debug_types section instead of a .debug_info section. */
2219 process_debug_info (struct dwarf_section
*section
,
2221 enum dwarf_section_display_enum abbrev_sec
,
2225 unsigned char *start
= section
->start
;
2226 unsigned char *end
= start
+ section
->size
;
2227 unsigned char *section_begin
;
2229 unsigned int num_units
= 0;
2231 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2232 && num_debug_info_entries
== 0
2237 /* First scan the section to get the number of comp units. */
2238 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2241 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2242 will be the length. For a 64-bit DWARF section, it'll be
2243 the escape code 0xffffffff followed by an 8 byte length. */
2244 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2246 if (length
== 0xffffffff)
2248 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2249 section_begin
+= length
+ 12;
2251 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2253 warn (_("Reserved length value (0x%s) found in section %s\n"),
2254 dwarf_vmatoa ("x", length
), section
->name
);
2258 section_begin
+= length
+ 4;
2260 /* Negative values are illegal, they may even cause infinite
2261 looping. This can happen if we can't accurately apply
2262 relocations to an object file. */
2263 if ((signed long) length
<= 0)
2265 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2266 dwarf_vmatoa ("x", length
), section
->name
);
2273 error (_("No comp units in %s section ?\n"), section
->name
);
2277 /* Then allocate an array to hold the information. */
2278 debug_information
= (debug_info
*) cmalloc (num_units
,
2279 sizeof (* debug_information
));
2280 if (debug_information
== NULL
)
2282 error (_("Not enough memory for a debug info array of %u entries\n"),
2284 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
2287 alloc_num_debug_info_entries
= num_units
;
2292 if (dwarf_start_die
== 0)
2293 printf (_("Contents of the %s section:\n\n"), section
->name
);
2295 load_debug_section (str
, file
);
2296 load_debug_section (str_dwo
, file
);
2297 load_debug_section (str_index
, file
);
2298 load_debug_section (str_index_dwo
, file
);
2299 load_debug_section (debug_addr
, file
);
2302 load_debug_section (abbrev_sec
, file
);
2303 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2305 warn (_("Unable to locate %s section!\n"),
2306 debug_displays
[abbrev_sec
].section
.name
);
2310 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2312 DWARF2_Internal_CompUnit compunit
;
2313 unsigned char *hdrptr
;
2314 unsigned char *tags
;
2315 int level
, last_level
, saved_level
;
2316 dwarf_vma cu_offset
;
2317 unsigned int offset_size
;
2318 int initial_length_size
;
2319 dwarf_vma signature_high
= 0;
2320 dwarf_vma signature_low
= 0;
2321 dwarf_vma type_offset
= 0;
2322 struct cu_tu_set
*this_set
;
2323 dwarf_vma abbrev_base
;
2328 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2330 if (compunit
.cu_length
== 0xffffffff)
2332 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2334 initial_length_size
= 12;
2339 initial_length_size
= 4;
2342 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2344 cu_offset
= start
- section_begin
;
2346 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2348 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2350 if (this_set
== NULL
)
2353 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2357 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2358 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2361 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2362 /* PR 17512: file: 001-108546-0.001:0.1. */
2363 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2365 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2366 compunit
.cu_pointer_size
, offset_size
);
2367 compunit
.cu_pointer_size
= offset_size
;
2372 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2374 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2377 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2378 && num_debug_info_entries
== 0
2381 debug_information
[unit
].cu_offset
= cu_offset
;
2382 debug_information
[unit
].pointer_size
2383 = compunit
.cu_pointer_size
;
2384 debug_information
[unit
].offset_size
= offset_size
;
2385 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2386 debug_information
[unit
].base_address
= 0;
2387 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2388 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2389 debug_information
[unit
].loc_offsets
= NULL
;
2390 debug_information
[unit
].have_frame_base
= NULL
;
2391 debug_information
[unit
].max_loc_offsets
= 0;
2392 debug_information
[unit
].num_loc_offsets
= 0;
2393 debug_information
[unit
].range_lists
= NULL
;
2394 debug_information
[unit
].max_range_lists
= 0;
2395 debug_information
[unit
].num_range_lists
= 0;
2398 if (!do_loc
&& dwarf_start_die
== 0)
2400 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2401 dwarf_vmatoa ("x", cu_offset
));
2402 printf (_(" Length: 0x%s (%s)\n"),
2403 dwarf_vmatoa ("x", compunit
.cu_length
),
2404 offset_size
== 8 ? "64-bit" : "32-bit");
2405 printf (_(" Version: %d\n"), compunit
.cu_version
);
2406 printf (_(" Abbrev Offset: 0x%s\n"),
2407 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2408 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2413 printf (_(" Signature: 0x%s\n"),
2414 dwarf_vmatoa64 (signature_high
, signature_low
,
2415 buf
, sizeof (buf
)));
2416 printf (_(" Type Offset: 0x%s\n"),
2417 dwarf_vmatoa ("x", type_offset
));
2419 if (this_set
!= NULL
)
2421 dwarf_vma
*offsets
= this_set
->section_offsets
;
2422 size_t *sizes
= this_set
->section_sizes
;
2424 printf (_(" Section contributions:\n"));
2425 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2426 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2427 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2428 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2429 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2430 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2431 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2432 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2433 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2434 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2435 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2436 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2440 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2443 warn (_("Debug info is corrupted, length of CU at %s"
2444 " extends beyond end of section (length = %s)\n"),
2445 dwarf_vmatoa ("x", cu_offset
),
2446 dwarf_vmatoa ("x", compunit
.cu_length
));
2450 start
+= compunit
.cu_length
+ initial_length_size
;
2452 if (compunit
.cu_version
!= 2
2453 && compunit
.cu_version
!= 3
2454 && compunit
.cu_version
!= 4)
2456 warn (_("CU at offset %s contains corrupt or "
2457 "unsupported version number: %d.\n"),
2458 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2464 /* Process the abbrevs used by this compilation unit. */
2465 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2466 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2467 (unsigned long) compunit
.cu_abbrev_offset
,
2468 (unsigned long) abbrev_size
);
2469 /* PR 17531: file:4bcd9ce9. */
2470 else if (abbrev_base
>= abbrev_size
)
2471 warn (_("Debug info is corrupted, abbrev base (%lx) is larger than abbrev section size (%lx)\n"),
2472 (unsigned long) abbrev_base
,
2473 (unsigned long) abbrev_size
);
2475 process_abbrev_section
2476 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2477 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2478 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2479 + abbrev_base
+ abbrev_size
));
2484 while (tags
< start
)
2486 unsigned int bytes_read
;
2487 unsigned long abbrev_number
;
2488 unsigned long die_offset
;
2489 abbrev_entry
*entry
;
2491 int do_printing
= 1;
2493 die_offset
= tags
- section_begin
;
2495 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2498 /* A null DIE marks the end of a list of siblings or it may also be
2499 a section padding. */
2500 if (abbrev_number
== 0)
2502 /* Check if it can be a section padding for the last CU. */
2503 if (level
== 0 && start
== end
)
2507 for (chk
= tags
; chk
< start
; chk
++)
2514 if (!do_loc
&& die_offset
>= dwarf_start_die
2515 && (dwarf_cutoff_level
== -1
2516 || level
< dwarf_cutoff_level
))
2517 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2523 static unsigned num_bogus_warns
= 0;
2525 if (num_bogus_warns
< 3)
2527 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2528 die_offset
, section
->name
);
2530 if (num_bogus_warns
== 3)
2531 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2534 if (dwarf_start_die
!= 0 && level
< saved_level
)
2541 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2545 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2546 saved_level
= level
;
2547 do_printing
= (dwarf_cutoff_level
== -1
2548 || level
< dwarf_cutoff_level
);
2550 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2551 level
, die_offset
, abbrev_number
);
2552 else if (dwarf_cutoff_level
== -1
2553 || last_level
< dwarf_cutoff_level
)
2554 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2559 /* Scan through the abbreviation list until we reach the
2561 for (entry
= first_abbrev
;
2562 entry
&& entry
->entry
!= abbrev_number
;
2563 entry
= entry
->next
)
2568 if (!do_loc
&& do_printing
)
2573 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2574 die_offset
, abbrev_number
);
2578 if (!do_loc
&& do_printing
)
2579 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2584 need_base_address
= 0;
2586 case DW_TAG_compile_unit
:
2587 need_base_address
= 1;
2589 case DW_TAG_entry_point
:
2590 case DW_TAG_subprogram
:
2591 need_base_address
= 0;
2592 /* Assuming that there is no DW_AT_frame_base. */
2593 have_frame_base
= 0;
2597 for (attr
= entry
->first_attr
;
2598 attr
&& attr
->attribute
;
2603 if (! do_loc
&& do_printing
)
2604 /* Show the offset from where the tag was extracted. */
2605 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2607 if (debug_information
&& unit
< alloc_num_debug_info_entries
)
2608 arg
= debug_information
+ unit
;
2612 tags
= read_and_display_attr (attr
->attribute
,
2617 compunit
.cu_pointer_size
,
2619 compunit
.cu_version
,
2621 do_loc
|| ! do_printing
,
2626 if (entry
->children
)
2631 /* Set num_debug_info_entries here so that it can be used to check if
2632 we need to process .debug_loc and .debug_ranges sections. */
2633 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2634 && num_debug_info_entries
== 0
2637 if (num_units
> alloc_num_debug_info_entries
)
2638 num_debug_info_entries
= alloc_num_debug_info_entries
;
2640 num_debug_info_entries
= num_units
;
2649 /* Locate and scan the .debug_info section in the file and record the pointer
2650 sizes and offsets for the compilation units in it. Usually an executable
2651 will have just one pointer size, but this is not guaranteed, and so we try
2652 not to make any assumptions. Returns zero upon failure, or the number of
2653 compilation units upon success. */
2656 load_debug_info (void * file
)
2658 /* Reset the last pointer size so that we can issue correct error
2659 messages if we are displaying the contents of more than one section. */
2660 last_pointer_size
= 0;
2661 warned_about_missing_comp_units
= FALSE
;
2663 /* If we have already tried and failed to load the .debug_info
2664 section then do not bother to repeat the task. */
2665 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2668 /* If we already have the information there is nothing else to do. */
2669 if (num_debug_info_entries
> 0)
2670 return num_debug_info_entries
;
2672 /* If this is a DWARF package file, load the CU and TU indexes. */
2673 load_cu_tu_indexes (file
);
2675 if (load_debug_section (info
, file
)
2676 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2677 return num_debug_info_entries
;
2679 if (load_debug_section (info_dwo
, file
)
2680 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2682 return num_debug_info_entries
;
2684 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2688 /* Read a DWARF .debug_line section header starting at DATA.
2689 Upon success returns an updated DATA pointer and the LINFO
2690 structure and the END_OF_SEQUENCE pointer will be filled in.
2691 Otherwise returns NULL. */
2693 static unsigned char *
2694 read_debug_line_header (struct dwarf_section
* section
,
2695 unsigned char * data
,
2696 unsigned char * end
,
2697 DWARF2_Internal_LineInfo
* linfo
,
2698 unsigned char ** end_of_sequence
)
2700 unsigned char *hdrptr
;
2701 unsigned int offset_size
;
2702 unsigned int initial_length_size
;
2704 /* Extract information from the Line Number Program Header.
2705 (section 6.2.4 in the Dwarf3 doc). */
2708 /* Get and check the length of the block. */
2709 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2711 if (linfo
->li_length
== 0xffffffff)
2713 /* This section is 64-bit DWARF 3. */
2714 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2716 initial_length_size
= 12;
2721 initial_length_size
= 4;
2724 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2726 /* If the length is just a bias against the initial_length_size then
2727 this means that the field has a relocation against it which has not
2728 been applied. (Ie we are dealing with an object file, not a linked
2729 binary). Do not complain but instead assume that the rest of the
2730 section applies to this particular header. */
2731 if (linfo
->li_length
== - initial_length_size
)
2733 linfo
->li_length
= section
->size
- initial_length_size
;
2737 warn (_("The line info appears to be corrupt - the section is too small\n"));
2742 /* Get and check the version number. */
2743 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2745 if (linfo
->li_version
!= 2
2746 && linfo
->li_version
!= 3
2747 && linfo
->li_version
!= 4)
2749 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2753 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2754 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2756 if (linfo
->li_version
>= 4)
2758 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2760 if (linfo
->li_max_ops_per_insn
== 0)
2762 warn (_("Invalid maximum operations per insn.\n"));
2767 linfo
->li_max_ops_per_insn
= 1;
2769 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2770 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2771 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2772 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2774 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2775 /* PR 17512: file:002-117414-0.004. */
2776 if (* end_of_sequence
> end
)
2778 warn (_("Line length %s extends beyond end of section\n"),
2779 dwarf_vmatoa ("u", linfo
->li_length
));
2780 * end_of_sequence
= end
;
2788 display_debug_lines_raw (struct dwarf_section
*section
,
2789 unsigned char *data
,
2792 unsigned char *start
= section
->start
;
2794 printf (_("Raw dump of debug contents of section %s:\n\n"),
2799 static DWARF2_Internal_LineInfo saved_linfo
;
2800 DWARF2_Internal_LineInfo linfo
;
2801 unsigned char *standard_opcodes
;
2802 unsigned char *end_of_sequence
;
2803 unsigned int last_dir_entry
= 0;
2806 if (const_strneq (section
->name
, ".debug_line.")
2807 /* Note: the following does not apply to .debug_line.dwo sections.
2808 These are full debug_line sections. */
2809 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2811 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2812 section containing just the Line Number Statements. They are
2813 created by the assembler and intended to be used alongside gcc's
2814 -ffunction-sections command line option. When the linker's
2815 garbage collection decides to discard a .text.<foo> section it
2816 can then also discard the line number information in .debug_line.<foo>.
2818 Since the section is a fragment it does not have the details
2819 needed to fill out a LineInfo structure, so instead we use the
2820 details from the last full debug_line section that we processed. */
2821 end_of_sequence
= end
;
2822 standard_opcodes
= NULL
;
2823 linfo
= saved_linfo
;
2824 /* PR 17531: file: 0522b371. */
2825 if (linfo
.li_line_range
== 0)
2827 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section"));
2830 reset_state_machine (linfo
.li_default_is_stmt
);
2834 unsigned char * hdrptr
;
2836 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2837 & end_of_sequence
)) == NULL
)
2840 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2841 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2842 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2843 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2844 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2845 if (linfo
.li_version
>= 4)
2846 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2847 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2848 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2849 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2850 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2852 /* PR 17512: file: 1665-6428-0.004. */
2853 if (linfo
.li_line_range
== 0)
2855 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2856 linfo
.li_line_range
= 1;
2859 reset_state_machine (linfo
.li_default_is_stmt
);
2861 /* Display the contents of the Opcodes table. */
2862 standard_opcodes
= hdrptr
;
2864 /* PR 17512: file: 002-417945-0.004. */
2865 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
2867 warn (_("Line Base extends beyond end of section\n"));
2871 printf (_("\n Opcodes:\n"));
2873 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2874 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2876 /* Display the contents of the Directory table. */
2877 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2880 printf (_("\n The Directory Table is empty.\n"));
2883 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2884 (long)(data
- start
));
2886 while (data
< end
&& *data
!= 0)
2888 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
2890 data
+= strnlen ((char *) data
, end
- data
) + 1;
2893 /* PR 17512: file: 002-132094-0.004. */
2894 if (data
>= end
- 1)
2898 /* Skip the NUL at the end of the table. */
2901 /* Display the contents of the File Name table. */
2903 printf (_("\n The File Name Table is empty.\n"));
2906 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2907 (long)(data
- start
));
2908 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2910 while (data
< end
&& *data
!= 0)
2912 unsigned char *name
;
2913 unsigned int bytes_read
;
2915 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2917 data
+= strnlen ((char *) data
, end
- data
) + 1;
2920 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2923 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2926 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2928 printf ("%.*s\n", (int)(end
- name
), name
);
2932 warn (_("Corrupt file name table entry\n"));
2938 /* Skip the NUL at the end of the table. */
2941 saved_linfo
= linfo
;
2944 /* Now display the statements. */
2945 if (data
>= end_of_sequence
)
2946 printf (_(" No Line Number Statements.\n"));
2949 printf (_(" Line Number Statements:\n"));
2951 while (data
< end_of_sequence
)
2953 unsigned char op_code
;
2954 dwarf_signed_vma adv
;
2956 unsigned int bytes_read
;
2958 printf (" [0x%08lx]", (long)(data
- start
));
2962 if (op_code
>= linfo
.li_opcode_base
)
2964 op_code
-= linfo
.li_opcode_base
;
2965 uladv
= (op_code
/ linfo
.li_line_range
);
2966 if (linfo
.li_max_ops_per_insn
== 1)
2968 uladv
*= linfo
.li_min_insn_length
;
2969 state_machine_regs
.address
+= uladv
;
2970 printf (_(" Special opcode %d: "
2971 "advance Address by %s to 0x%s"),
2972 op_code
, dwarf_vmatoa ("u", uladv
),
2973 dwarf_vmatoa ("x", state_machine_regs
.address
));
2977 state_machine_regs
.address
2978 += ((state_machine_regs
.op_index
+ uladv
)
2979 / linfo
.li_max_ops_per_insn
)
2980 * linfo
.li_min_insn_length
;
2981 state_machine_regs
.op_index
2982 = (state_machine_regs
.op_index
+ uladv
)
2983 % linfo
.li_max_ops_per_insn
;
2984 printf (_(" Special opcode %d: "
2985 "advance Address by %s to 0x%s[%d]"),
2986 op_code
, dwarf_vmatoa ("u", uladv
),
2987 dwarf_vmatoa ("x", state_machine_regs
.address
),
2988 state_machine_regs
.op_index
);
2990 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2991 state_machine_regs
.line
+= adv
;
2992 printf (_(" and Line by %s to %d\n"),
2993 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
2995 else switch (op_code
)
2997 case DW_LNS_extended_op
:
2998 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3002 printf (_(" Copy\n"));
3005 case DW_LNS_advance_pc
:
3006 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3008 if (linfo
.li_max_ops_per_insn
== 1)
3010 uladv
*= linfo
.li_min_insn_length
;
3011 state_machine_regs
.address
+= uladv
;
3012 printf (_(" Advance PC by %s to 0x%s\n"),
3013 dwarf_vmatoa ("u", uladv
),
3014 dwarf_vmatoa ("x", state_machine_regs
.address
));
3018 state_machine_regs
.address
3019 += ((state_machine_regs
.op_index
+ uladv
)
3020 / linfo
.li_max_ops_per_insn
)
3021 * linfo
.li_min_insn_length
;
3022 state_machine_regs
.op_index
3023 = (state_machine_regs
.op_index
+ uladv
)
3024 % linfo
.li_max_ops_per_insn
;
3025 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3026 dwarf_vmatoa ("u", uladv
),
3027 dwarf_vmatoa ("x", state_machine_regs
.address
),
3028 state_machine_regs
.op_index
);
3032 case DW_LNS_advance_line
:
3033 adv
= read_sleb128 (data
, & bytes_read
, end
);
3035 state_machine_regs
.line
+= adv
;
3036 printf (_(" Advance Line by %s to %d\n"),
3037 dwarf_vmatoa ("d", adv
),
3038 state_machine_regs
.line
);
3041 case DW_LNS_set_file
:
3042 adv
= read_uleb128 (data
, & bytes_read
, end
);
3044 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3045 dwarf_vmatoa ("d", adv
));
3046 state_machine_regs
.file
= adv
;
3049 case DW_LNS_set_column
:
3050 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3052 printf (_(" Set column to %s\n"),
3053 dwarf_vmatoa ("u", uladv
));
3054 state_machine_regs
.column
= uladv
;
3057 case DW_LNS_negate_stmt
:
3058 adv
= state_machine_regs
.is_stmt
;
3060 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3061 state_machine_regs
.is_stmt
= adv
;
3064 case DW_LNS_set_basic_block
:
3065 printf (_(" Set basic block\n"));
3066 state_machine_regs
.basic_block
= 1;
3069 case DW_LNS_const_add_pc
:
3070 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3071 if (linfo
.li_max_ops_per_insn
)
3073 uladv
*= linfo
.li_min_insn_length
;
3074 state_machine_regs
.address
+= uladv
;
3075 printf (_(" Advance PC by constant %s to 0x%s\n"),
3076 dwarf_vmatoa ("u", uladv
),
3077 dwarf_vmatoa ("x", state_machine_regs
.address
));
3081 state_machine_regs
.address
3082 += ((state_machine_regs
.op_index
+ uladv
)
3083 / linfo
.li_max_ops_per_insn
)
3084 * linfo
.li_min_insn_length
;
3085 state_machine_regs
.op_index
3086 = (state_machine_regs
.op_index
+ uladv
)
3087 % linfo
.li_max_ops_per_insn
;
3088 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3089 dwarf_vmatoa ("u", uladv
),
3090 dwarf_vmatoa ("x", state_machine_regs
.address
),
3091 state_machine_regs
.op_index
);
3095 case DW_LNS_fixed_advance_pc
:
3096 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3097 state_machine_regs
.address
+= uladv
;
3098 state_machine_regs
.op_index
= 0;
3099 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3100 dwarf_vmatoa ("u", uladv
),
3101 dwarf_vmatoa ("x", state_machine_regs
.address
));
3104 case DW_LNS_set_prologue_end
:
3105 printf (_(" Set prologue_end to true\n"));
3108 case DW_LNS_set_epilogue_begin
:
3109 printf (_(" Set epilogue_begin to true\n"));
3112 case DW_LNS_set_isa
:
3113 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3115 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3119 printf (_(" Unknown opcode %d with operands: "), op_code
);
3121 if (standard_opcodes
!= NULL
)
3122 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3124 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3126 i
== 1 ? "" : ", ");
3142 unsigned char *name
;
3143 unsigned int directory_index
;
3144 unsigned int modification_date
;
3145 unsigned int length
;
3148 /* Output a decoded representation of the .debug_line section. */
3151 display_debug_lines_decoded (struct dwarf_section
*section
,
3152 unsigned char *data
,
3155 static DWARF2_Internal_LineInfo saved_linfo
;
3157 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3162 /* This loop amounts to one iteration per compilation unit. */
3163 DWARF2_Internal_LineInfo linfo
;
3164 unsigned char *standard_opcodes
;
3165 unsigned char *end_of_sequence
;
3167 File_Entry
*file_table
= NULL
;
3168 unsigned int n_files
= 0;
3169 unsigned char **directory_table
= NULL
;
3170 unsigned int n_directories
= 0;
3172 if (const_strneq (section
->name
, ".debug_line.")
3173 /* Note: the following does not apply to .debug_line.dwo sections.
3174 These are full debug_line sections. */
3175 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3177 /* See comment in display_debug_lines_raw(). */
3178 end_of_sequence
= end
;
3179 standard_opcodes
= NULL
;
3180 linfo
= saved_linfo
;
3181 /* PR 17531: file: 0522b371. */
3182 if (linfo
.li_line_range
== 0)
3184 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section"));
3187 reset_state_machine (linfo
.li_default_is_stmt
);
3191 unsigned char *hdrptr
;
3193 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3194 & end_of_sequence
)) == NULL
)
3197 /* PR 17531: file: 0522b371. */
3198 if (linfo
.li_line_range
== 0)
3200 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3201 linfo
.li_line_range
= 1;
3203 reset_state_machine (linfo
.li_default_is_stmt
);
3205 /* Save a pointer to the contents of the Opcodes table. */
3206 standard_opcodes
= hdrptr
;
3208 /* Traverse the Directory table just to count entries. */
3209 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3212 unsigned char *ptr_directory_table
= data
;
3216 data
+= strnlen ((char *) data
, end
- data
) + 1;
3220 /* Go through the directory table again to save the directories. */
3221 directory_table
= (unsigned char **)
3222 xmalloc (n_directories
* sizeof (unsigned char *));
3225 while (*ptr_directory_table
!= 0)
3227 directory_table
[i
] = ptr_directory_table
;
3228 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3229 ptr_directory_table
- end
) + 1;
3233 /* Skip the NUL at the end of the table. */
3236 /* Traverse the File Name table just to count the entries. */
3239 unsigned char *ptr_file_name_table
= data
;
3243 unsigned int bytes_read
;
3245 /* Skip Name, directory index, last modification time and length
3247 data
+= strnlen ((char *) data
, end
- data
) + 1;
3248 read_uleb128 (data
, & bytes_read
, end
);
3250 read_uleb128 (data
, & bytes_read
, end
);
3252 read_uleb128 (data
, & bytes_read
, end
);
3258 /* Go through the file table again to save the strings. */
3259 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3262 while (*ptr_file_name_table
!= 0)
3264 unsigned int bytes_read
;
3266 file_table
[i
].name
= ptr_file_name_table
;
3267 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3268 end
- ptr_file_name_table
) + 1;
3270 /* We are not interested in directory, time or size. */
3271 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3273 ptr_file_name_table
+= bytes_read
;
3274 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3276 ptr_file_name_table
+= bytes_read
;
3277 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3278 ptr_file_name_table
+= bytes_read
;
3283 /* Print the Compilation Unit's name and a header. */
3284 if (directory_table
== NULL
)
3286 printf (_("CU: %s:\n"), file_table
[0].name
);
3287 printf (_("File name Line number Starting address\n"));
3291 unsigned int ix
= file_table
[0].directory_index
;
3292 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3294 if (do_wide
|| strlen (directory
) < 76)
3295 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3297 printf ("%s:\n", file_table
[0].name
);
3299 printf (_("File name Line number Starting address\n"));
3303 /* Skip the NUL at the end of the table. */
3306 saved_linfo
= linfo
;
3309 /* This loop iterates through the Dwarf Line Number Program. */
3310 while (data
< end_of_sequence
)
3312 unsigned char op_code
;
3314 unsigned long int uladv
;
3315 unsigned int bytes_read
;
3316 int is_special_opcode
= 0;
3320 if (op_code
>= linfo
.li_opcode_base
)
3322 op_code
-= linfo
.li_opcode_base
;
3323 uladv
= (op_code
/ linfo
.li_line_range
);
3324 if (linfo
.li_max_ops_per_insn
== 1)
3326 uladv
*= linfo
.li_min_insn_length
;
3327 state_machine_regs
.address
+= uladv
;
3331 state_machine_regs
.address
3332 += ((state_machine_regs
.op_index
+ uladv
)
3333 / linfo
.li_max_ops_per_insn
)
3334 * linfo
.li_min_insn_length
;
3335 state_machine_regs
.op_index
3336 = (state_machine_regs
.op_index
+ uladv
)
3337 % linfo
.li_max_ops_per_insn
;
3340 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3341 state_machine_regs
.line
+= adv
;
3342 is_special_opcode
= 1;
3344 else switch (op_code
)
3346 case DW_LNS_extended_op
:
3348 unsigned int ext_op_code_len
;
3349 unsigned char ext_op_code
;
3350 unsigned char *op_code_data
= data
;
3352 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3354 op_code_data
+= bytes_read
;
3356 if (ext_op_code_len
== 0)
3358 warn (_("Badly formed extended line op encountered!\n"));
3361 ext_op_code_len
+= bytes_read
;
3362 ext_op_code
= *op_code_data
++;
3364 switch (ext_op_code
)
3366 case DW_LNE_end_sequence
:
3367 reset_state_machine (linfo
.li_default_is_stmt
);
3369 case DW_LNE_set_address
:
3370 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3372 ext_op_code_len
- bytes_read
- 1,
3374 state_machine_regs
.op_index
= 0;
3376 case DW_LNE_define_file
:
3378 file_table
= (File_Entry
*) xrealloc
3379 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3381 ++state_machine_regs
.last_file_entry
;
3382 /* Source file name. */
3383 file_table
[n_files
].name
= op_code_data
;
3384 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3385 /* Directory index. */
3386 file_table
[n_files
].directory_index
=
3387 read_uleb128 (op_code_data
, & bytes_read
,
3389 op_code_data
+= bytes_read
;
3390 /* Last modification time. */
3391 file_table
[n_files
].modification_date
=
3392 read_uleb128 (op_code_data
, & bytes_read
,
3394 op_code_data
+= bytes_read
;
3396 file_table
[n_files
].length
=
3397 read_uleb128 (op_code_data
, & bytes_read
,
3403 case DW_LNE_set_discriminator
:
3404 case DW_LNE_HP_set_sequence
:
3405 /* Simply ignored. */
3409 printf (_("UNKNOWN (%u): length %d\n"),
3410 ext_op_code
, ext_op_code_len
- bytes_read
);
3413 data
+= ext_op_code_len
;
3419 case DW_LNS_advance_pc
:
3420 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3422 if (linfo
.li_max_ops_per_insn
== 1)
3424 uladv
*= linfo
.li_min_insn_length
;
3425 state_machine_regs
.address
+= uladv
;
3429 state_machine_regs
.address
3430 += ((state_machine_regs
.op_index
+ uladv
)
3431 / linfo
.li_max_ops_per_insn
)
3432 * linfo
.li_min_insn_length
;
3433 state_machine_regs
.op_index
3434 = (state_machine_regs
.op_index
+ uladv
)
3435 % linfo
.li_max_ops_per_insn
;
3439 case DW_LNS_advance_line
:
3440 adv
= read_sleb128 (data
, & bytes_read
, end
);
3442 state_machine_regs
.line
+= adv
;
3445 case DW_LNS_set_file
:
3446 adv
= read_uleb128 (data
, & bytes_read
, end
);
3448 state_machine_regs
.file
= adv
;
3450 if (file_table
== NULL
)
3451 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3452 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3453 /* If directory index is 0, that means current directory. */
3454 printf ("\n./%s:[++]\n",
3455 file_table
[state_machine_regs
.file
- 1].name
);
3456 else if (directory_table
== NULL
)
3457 printf (_("\n [Use directory table entry %d]\n"),
3458 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3460 /* The directory index starts counting at 1. */
3461 printf ("\n%s/%s:\n",
3462 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3463 file_table
[state_machine_regs
.file
- 1].name
);
3466 case DW_LNS_set_column
:
3467 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3469 state_machine_regs
.column
= uladv
;
3472 case DW_LNS_negate_stmt
:
3473 adv
= state_machine_regs
.is_stmt
;
3475 state_machine_regs
.is_stmt
= adv
;
3478 case DW_LNS_set_basic_block
:
3479 state_machine_regs
.basic_block
= 1;
3482 case DW_LNS_const_add_pc
:
3483 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3484 if (linfo
.li_max_ops_per_insn
== 1)
3486 uladv
*= linfo
.li_min_insn_length
;
3487 state_machine_regs
.address
+= uladv
;
3491 state_machine_regs
.address
3492 += ((state_machine_regs
.op_index
+ uladv
)
3493 / linfo
.li_max_ops_per_insn
)
3494 * linfo
.li_min_insn_length
;
3495 state_machine_regs
.op_index
3496 = (state_machine_regs
.op_index
+ uladv
)
3497 % linfo
.li_max_ops_per_insn
;
3501 case DW_LNS_fixed_advance_pc
:
3502 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3503 state_machine_regs
.address
+= uladv
;
3504 state_machine_regs
.op_index
= 0;
3507 case DW_LNS_set_prologue_end
:
3510 case DW_LNS_set_epilogue_begin
:
3513 case DW_LNS_set_isa
:
3514 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3516 printf (_(" Set ISA to %lu\n"), uladv
);
3520 printf (_(" Unknown opcode %d with operands: "), op_code
);
3522 if (standard_opcodes
!= NULL
)
3523 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3525 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3527 i
== 1 ? "" : ", ");
3534 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3535 to the DWARF address/line matrix. */
3536 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3537 || (op_code
== DW_LNS_copy
))
3539 const unsigned int MAX_FILENAME_LENGTH
= 35;
3541 char *newFileName
= NULL
;
3542 size_t fileNameLength
;
3545 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3547 fileName
= "<unknown>";
3549 fileNameLength
= strlen (fileName
);
3551 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3553 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3554 /* Truncate file name */
3555 strncpy (newFileName
,
3556 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3557 MAX_FILENAME_LENGTH
+ 1);
3561 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3562 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3565 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3567 if (linfo
.li_max_ops_per_insn
== 1)
3568 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3569 newFileName
, state_machine_regs
.line
,
3570 state_machine_regs
.address
);
3572 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3573 newFileName
, state_machine_regs
.line
,
3574 state_machine_regs
.address
,
3575 state_machine_regs
.op_index
);
3579 if (linfo
.li_max_ops_per_insn
== 1)
3580 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3581 newFileName
, state_machine_regs
.line
,
3582 state_machine_regs
.address
);
3584 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3585 newFileName
, state_machine_regs
.line
,
3586 state_machine_regs
.address
,
3587 state_machine_regs
.op_index
);
3590 if (op_code
== DW_LNE_end_sequence
)
3604 if (directory_table
)
3606 free (directory_table
);
3607 directory_table
= NULL
;
3618 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3620 unsigned char *data
= section
->start
;
3621 unsigned char *end
= data
+ section
->size
;
3623 int retValDecoded
= 1;
3625 if (do_debug_lines
== 0)
3626 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3628 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3629 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3631 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3632 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3634 if (!retValRaw
|| !retValDecoded
)
3641 find_debug_info_for_offset (unsigned long offset
)
3645 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3648 for (i
= 0; i
< num_debug_info_entries
; i
++)
3649 if (debug_information
[i
].cu_offset
== offset
)
3650 return debug_information
+ i
;
3656 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
3658 /* See gdb/gdb-index.h. */
3659 static const char * const kinds
[] =
3671 return _ (kinds
[kind
]);
3675 display_debug_pubnames_worker (struct dwarf_section
*section
,
3676 void *file ATTRIBUTE_UNUSED
,
3679 DWARF2_Internal_PubNames names
;
3680 unsigned char *start
= section
->start
;
3681 unsigned char *end
= start
+ section
->size
;
3683 /* It does not matter if this load fails,
3684 we test for that later on. */
3685 load_debug_info (file
);
3687 printf (_("Contents of the %s section:\n\n"), section
->name
);
3691 unsigned char *data
;
3692 unsigned long offset
;
3693 unsigned int offset_size
, initial_length_size
;
3697 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3698 if (names
.pn_length
== 0xffffffff)
3700 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3702 initial_length_size
= 12;
3707 initial_length_size
= 4;
3710 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3711 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3713 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3714 && num_debug_info_entries
> 0
3715 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3716 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3717 (unsigned long) names
.pn_offset
, section
->name
);
3719 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3721 /* PR 17531: file: 7615b6b2. */
3722 if ((dwarf_signed_vma
) names
.pn_length
< 0)
3724 warn (_("Negative length for public name: 0x%lx\n"), (long) names
.pn_length
);
3728 start
+= names
.pn_length
+ initial_length_size
;
3730 printf (_(" Length: %ld\n"),
3731 (long) names
.pn_length
);
3732 printf (_(" Version: %d\n"),
3734 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3735 (unsigned long) names
.pn_offset
);
3736 printf (_(" Size of area in .debug_info section: %ld\n"),
3737 (long) names
.pn_size
);
3739 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3741 static int warned
= 0;
3745 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3753 printf (_("\n Offset Kind Name\n"));
3755 printf (_("\n Offset\tName\n"));
3759 bfd_size_type maxprint
;
3761 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3765 data
+= offset_size
;
3768 maxprint
= (end
- data
) - 1;
3772 unsigned int kind_data
;
3773 gdb_index_symbol_kind kind
;
3774 const char *kind_name
;
3777 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
3780 /* GCC computes the kind as the upper byte in the CU index
3781 word, and then right shifts it by the CU index size.
3782 Left shift KIND to where the gdb-index.h accessor macros
3784 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
3785 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
3786 kind_name
= get_gdb_index_symbol_kind_name (kind
);
3787 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
3788 printf (" %-6lx %s,%-10s %.*s\n",
3789 offset
, is_static
? _("s") : _("g"),
3790 kind_name
, (int) maxprint
, data
);
3793 printf (" %-6lx\t%.*s\n", offset
, (int) maxprint
, data
);
3795 data
+= strnlen ((char *) data
, maxprint
) + 1;
3800 while (offset
!= 0);
3808 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
3810 return display_debug_pubnames_worker (section
, file
, 0);
3814 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
3816 return display_debug_pubnames_worker (section
, file
, 1);
3820 display_debug_macinfo (struct dwarf_section
*section
,
3821 void *file ATTRIBUTE_UNUSED
)
3823 unsigned char *start
= section
->start
;
3824 unsigned char *end
= start
+ section
->size
;
3825 unsigned char *curr
= start
;
3826 unsigned int bytes_read
;
3827 enum dwarf_macinfo_record_type op
;
3829 printf (_("Contents of the %s section:\n\n"), section
->name
);
3833 unsigned int lineno
;
3834 const unsigned char *string
;
3836 op
= (enum dwarf_macinfo_record_type
) *curr
;
3841 case DW_MACINFO_start_file
:
3843 unsigned int filenum
;
3845 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3847 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3850 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3855 case DW_MACINFO_end_file
:
3856 printf (_(" DW_MACINFO_end_file\n"));
3859 case DW_MACINFO_define
:
3860 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3863 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3864 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3868 case DW_MACINFO_undef
:
3869 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3872 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3873 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3877 case DW_MACINFO_vendor_ext
:
3879 unsigned int constant
;
3881 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3884 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3885 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3895 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3896 filename and dirname corresponding to file name table entry with index
3897 FILEIDX. Return NULL on failure. */
3899 static unsigned char *
3900 get_line_filename_and_dirname (dwarf_vma line_offset
,
3902 unsigned char **dir_name
)
3904 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3905 unsigned char *hdrptr
, *dirtable
, *file_name
;
3906 unsigned int offset_size
, initial_length_size
;
3907 unsigned int version
, opcode_base
, bytes_read
;
3908 dwarf_vma length
, diridx
;
3909 const unsigned char * end
;
3912 if (section
->start
== NULL
3913 || line_offset
>= section
->size
3917 hdrptr
= section
->start
+ line_offset
;
3918 end
= section
->start
+ section
->size
;
3920 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3921 if (length
== 0xffffffff)
3923 /* This section is 64-bit DWARF 3. */
3924 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3926 initial_length_size
= 12;
3931 initial_length_size
= 4;
3933 if (length
+ initial_length_size
> section
->size
)
3936 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3937 if (version
!= 2 && version
!= 3 && version
!= 4)
3939 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3941 hdrptr
++; /* Skip max_ops_per_insn. */
3942 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3944 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3945 if (opcode_base
== 0)
3948 hdrptr
+= opcode_base
- 1;
3950 /* Skip over dirname table. */
3951 while (*hdrptr
!= '\0')
3952 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3953 hdrptr
++; /* Skip the NUL at the end of the table. */
3954 /* Now skip over preceding filename table entries. */
3955 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3957 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3958 read_uleb128 (hdrptr
, &bytes_read
, end
);
3959 hdrptr
+= bytes_read
;
3960 read_uleb128 (hdrptr
, &bytes_read
, end
);
3961 hdrptr
+= bytes_read
;
3962 read_uleb128 (hdrptr
, &bytes_read
, end
);
3963 hdrptr
+= bytes_read
;
3965 if (hdrptr
== end
|| *hdrptr
== '\0')
3968 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3969 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
3972 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
3973 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
3974 if (*dirtable
== '\0')
3976 *dir_name
= dirtable
;
3981 display_debug_macro (struct dwarf_section
*section
,
3984 unsigned char *start
= section
->start
;
3985 unsigned char *end
= start
+ section
->size
;
3986 unsigned char *curr
= start
;
3987 unsigned char *extended_op_buf
[256];
3988 unsigned int bytes_read
;
3990 load_debug_section (str
, file
);
3991 load_debug_section (line
, file
);
3993 printf (_("Contents of the %s section:\n\n"), section
->name
);
3997 unsigned int lineno
, version
, flags
;
3998 unsigned int offset_size
= 4;
3999 const unsigned char *string
;
4000 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
4001 unsigned char **extended_ops
= NULL
;
4003 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
4006 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4011 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
4014 printf (_(" Offset: 0x%lx\n"),
4015 (unsigned long) sec_offset
);
4016 printf (_(" Version: %d\n"), version
);
4017 printf (_(" Offset size: %d\n"), offset_size
);
4020 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
4021 printf (_(" Offset into .debug_line: 0x%lx\n"),
4022 (unsigned long) line_offset
);
4026 unsigned int i
, count
, op
;
4029 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
4031 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
4032 extended_ops
= extended_op_buf
;
4035 printf (_(" Extension opcode arguments:\n"));
4036 for (i
= 0; i
< count
; i
++)
4038 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4039 extended_ops
[op
] = curr
;
4040 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
4043 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
4046 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
4047 for (n
= 0; n
< nargs
; n
++)
4051 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
4052 printf ("%s%s", get_FORM_name (form
),
4053 n
== nargs
- 1 ? "\n" : ", ");
4063 case DW_FORM_block1
:
4064 case DW_FORM_block2
:
4065 case DW_FORM_block4
:
4067 case DW_FORM_string
:
4069 case DW_FORM_sec_offset
:
4072 error (_("Invalid extension opcode form %s\n"),
4073 get_FORM_name (form
));
4089 error (_(".debug_macro section not zero terminated\n"));
4093 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4099 case DW_MACRO_GNU_start_file
:
4101 unsigned int filenum
;
4102 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4104 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4106 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4109 if ((flags
& 2) == 0)
4110 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4113 = get_line_filename_and_dirname (line_offset
, filenum
,
4115 if (file_name
== NULL
)
4116 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4119 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4121 dir_name
!= NULL
? (const char *) dir_name
: "",
4122 dir_name
!= NULL
? "/" : "", file_name
);
4126 case DW_MACRO_GNU_end_file
:
4127 printf (_(" DW_MACRO_GNU_end_file\n"));
4130 case DW_MACRO_GNU_define
:
4131 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4134 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4135 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4139 case DW_MACRO_GNU_undef
:
4140 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4143 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4144 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4148 case DW_MACRO_GNU_define_indirect
:
4149 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4151 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4152 string
= fetch_indirect_string (offset
);
4153 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4157 case DW_MACRO_GNU_undef_indirect
:
4158 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4160 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4161 string
= fetch_indirect_string (offset
);
4162 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4166 case DW_MACRO_GNU_transparent_include
:
4167 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4168 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4169 (unsigned long) offset
);
4172 case DW_MACRO_GNU_define_indirect_alt
:
4173 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4175 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4176 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4177 lineno
, (unsigned long) offset
);
4180 case DW_MACRO_GNU_undef_indirect_alt
:
4181 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4183 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4184 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4185 lineno
, (unsigned long) offset
);
4188 case DW_MACRO_GNU_transparent_include_alt
:
4189 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4190 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4191 (unsigned long) offset
);
4195 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
4197 error (_(" Unknown macro opcode %02x seen\n"), op
);
4202 /* Skip over unhandled opcodes. */
4204 unsigned char *desc
= extended_ops
[op
];
4205 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
4209 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
4212 printf (_(" DW_MACRO_GNU_%02x -"), op
);
4213 for (n
= 0; n
< nargs
; n
++)
4217 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
4219 = read_and_display_attr_value (0, val
,
4220 curr
, end
, 0, 0, offset_size
,
4221 version
, NULL
, 0, NULL
,
4239 display_debug_abbrev (struct dwarf_section
*section
,
4240 void *file ATTRIBUTE_UNUSED
)
4242 abbrev_entry
*entry
;
4243 unsigned char *start
= section
->start
;
4244 unsigned char *end
= start
+ section
->size
;
4246 printf (_("Contents of the %s section:\n\n"), section
->name
);
4250 unsigned char *last
;
4255 start
= process_abbrev_section (start
, end
);
4257 if (first_abbrev
== NULL
)
4260 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4262 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4266 printf (" %ld %s [%s]\n",
4268 get_TAG_name (entry
->tag
),
4269 entry
->children
? _("has children") : _("no children"));
4271 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4272 printf (" %-18s %s\n",
4273 get_AT_name (attr
->attribute
),
4274 get_FORM_name (attr
->form
));
4284 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4287 display_loc_list (struct dwarf_section
*section
,
4288 unsigned char **start_ptr
,
4289 unsigned int debug_info_entry
,
4290 unsigned long offset
,
4291 unsigned long base_address
,
4294 unsigned char *start
= *start_ptr
;
4295 unsigned char *section_end
= section
->start
+ section
->size
;
4296 unsigned long cu_offset
;
4297 unsigned int pointer_size
;
4298 unsigned int offset_size
;
4303 unsigned short length
;
4304 int need_frame_base
;
4306 if (debug_info_entry
>= num_debug_info_entries
)
4308 warn (_("No debug information available for loc lists of entry: %u\n"),
4313 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4314 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4315 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4316 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4318 if (pointer_size
< 2 || pointer_size
> 8)
4320 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4321 pointer_size
, debug_info_entry
);
4327 if (start
+ 2 * pointer_size
> section_end
)
4329 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4334 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4336 /* Note: we use sign extension here in order to be sure that we can detect
4337 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4338 address will not affect the values that we display since we always show
4339 hex values, and always the bottom 32-bits. */
4340 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4341 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4343 if (begin
== 0 && end
== 0)
4345 printf (_("<End of list>\n"));
4349 /* Check base address specifiers. */
4350 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4353 print_dwarf_vma (begin
, pointer_size
);
4354 print_dwarf_vma (end
, pointer_size
);
4355 printf (_("(base address)\n"));
4359 if (start
+ 2 > section_end
)
4361 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4366 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4368 if (start
+ length
> section_end
)
4370 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4375 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4376 print_dwarf_vma (end
+ base_address
, pointer_size
);
4379 need_frame_base
= decode_location_expression (start
,
4384 cu_offset
, section
);
4387 if (need_frame_base
&& !has_frame_base
)
4388 printf (_(" [without DW_AT_frame_base]"));
4391 fputs (_(" (start == end)"), stdout
);
4392 else if (begin
> end
)
4393 fputs (_(" (start > end)"), stdout
);
4403 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4404 right-adjusted in a field of length LEN, and followed by a space. */
4407 print_addr_index (unsigned int idx
, unsigned int len
)
4409 static char buf
[15];
4410 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4411 printf ("%*s ", len
, buf
);
4414 /* Display a location list from a .dwo section. It uses address indexes rather
4415 than embedded addresses. This code closely follows display_loc_list, but the
4416 two are sufficiently different that combining things is very ugly. */
4419 display_loc_list_dwo (struct dwarf_section
*section
,
4420 unsigned char **start_ptr
,
4421 unsigned int debug_info_entry
,
4422 unsigned long offset
,
4425 unsigned char *start
= *start_ptr
;
4426 unsigned char *section_end
= section
->start
+ section
->size
;
4427 unsigned long cu_offset
;
4428 unsigned int pointer_size
;
4429 unsigned int offset_size
;
4432 unsigned short length
;
4433 int need_frame_base
;
4435 unsigned int bytes_read
;
4437 if (debug_info_entry
>= num_debug_info_entries
)
4439 warn (_("No debug information for loc lists of entry: %u\n"),
4444 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4445 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4446 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4447 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4449 if (pointer_size
< 2 || pointer_size
> 8)
4451 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4452 pointer_size
, debug_info_entry
);
4458 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4460 if (start
>= section_end
)
4462 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4467 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4470 case 0: /* A terminating entry. */
4472 printf (_("<End of list>\n"));
4474 case 1: /* A base-address entry. */
4475 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4476 start
+= bytes_read
;
4477 print_addr_index (idx
, 8);
4479 printf (_("(base address selection entry)\n"));
4481 case 2: /* A start/end entry. */
4482 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4483 start
+= bytes_read
;
4484 print_addr_index (idx
, 8);
4485 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4486 start
+= bytes_read
;
4487 print_addr_index (idx
, 8);
4489 case 3: /* A start/length entry. */
4490 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4491 start
+= bytes_read
;
4492 print_addr_index (idx
, 8);
4493 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4494 printf ("%08x ", idx
);
4496 case 4: /* An offset pair entry. */
4497 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4498 printf ("%08x ", idx
);
4499 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4500 printf ("%08x ", idx
);
4503 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4508 if (start
+ 2 > section_end
)
4510 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4515 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4516 if (start
+ length
> section_end
)
4518 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4524 need_frame_base
= decode_location_expression (start
,
4529 cu_offset
, section
);
4532 if (need_frame_base
&& !has_frame_base
)
4533 printf (_(" [without DW_AT_frame_base]"));
4543 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4545 static dwarf_vma
*loc_offsets
;
4548 loc_offsets_compar (const void *ap
, const void *bp
)
4550 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4551 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4553 return (a
> b
) - (b
> a
);
4557 display_debug_loc (struct dwarf_section
*section
, void *file
)
4559 unsigned char *start
= section
->start
;
4560 unsigned long bytes
;
4561 unsigned char *section_begin
= start
;
4562 unsigned int num_loc_list
= 0;
4563 unsigned long last_offset
= 0;
4564 unsigned int first
= 0;
4568 int seen_first_offset
= 0;
4569 int locs_sorted
= 1;
4570 unsigned char *next
;
4571 unsigned int *array
= NULL
;
4572 const char *suffix
= strrchr (section
->name
, '.');
4575 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4578 bytes
= section
->size
;
4582 printf (_("\nThe %s section is empty.\n"), section
->name
);
4586 if (load_debug_info (file
) == 0)
4588 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4593 /* Check the order of location list in .debug_info section. If
4594 offsets of location lists are in the ascending order, we can
4595 use `debug_information' directly. */
4596 for (i
= 0; i
< num_debug_info_entries
; i
++)
4600 num
= debug_information
[i
].num_loc_offsets
;
4601 if (num
> num_loc_list
)
4604 /* Check if we can use `debug_information' directly. */
4605 if (locs_sorted
&& num
!= 0)
4607 if (!seen_first_offset
)
4609 /* This is the first location list. */
4610 last_offset
= debug_information
[i
].loc_offsets
[0];
4612 seen_first_offset
= 1;
4618 for (; j
< num
; j
++)
4621 debug_information
[i
].loc_offsets
[j
])
4626 last_offset
= debug_information
[i
].loc_offsets
[j
];
4631 if (!seen_first_offset
)
4632 error (_("No location lists in .debug_info section!\n"));
4634 if (debug_information
[first
].num_loc_offsets
> 0
4635 && debug_information
[first
].loc_offsets
[0] != 0)
4636 warn (_("Location lists in %s section start at 0x%s\n"),
4638 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4641 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4642 printf (_("Contents of the %s section:\n\n"), section
->name
);
4643 printf (_(" Offset Begin End Expression\n"));
4645 seen_first_offset
= 0;
4646 for (i
= first
; i
< num_debug_info_entries
; i
++)
4648 unsigned long offset
;
4649 unsigned long base_address
;
4654 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4656 loc_offsets
= debug_information
[i
].loc_offsets
;
4657 qsort (array
, debug_information
[i
].num_loc_offsets
,
4658 sizeof (*array
), loc_offsets_compar
);
4661 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4663 j
= locs_sorted
? k
: array
[k
];
4665 && debug_information
[i
].loc_offsets
[locs_sorted
4666 ? k
- 1 : array
[k
- 1]]
4667 == debug_information
[i
].loc_offsets
[j
])
4669 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4670 offset
= debug_information
[i
].loc_offsets
[j
];
4671 next
= section_begin
+ offset
;
4672 base_address
= debug_information
[i
].base_address
;
4674 if (!seen_first_offset
)
4675 seen_first_offset
= 1;
4679 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4680 (unsigned long) (start
- section_begin
),
4681 (unsigned long) (next
- section_begin
));
4682 else if (start
> next
)
4683 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4684 (unsigned long) (start
- section_begin
),
4685 (unsigned long) (next
- section_begin
));
4689 if (offset
>= bytes
)
4691 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4697 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4699 display_loc_list (section
, &start
, i
, offset
, base_address
,
4704 if (start
< section
->start
+ section
->size
)
4705 warn (_("There are %ld unused bytes at the end of section %s\n"),
4706 (long) (section
->start
+ section
->size
- start
), section
->name
);
4713 display_debug_str (struct dwarf_section
*section
,
4714 void *file ATTRIBUTE_UNUSED
)
4716 unsigned char *start
= section
->start
;
4717 unsigned long bytes
= section
->size
;
4718 dwarf_vma addr
= section
->address
;
4722 printf (_("\nThe %s section is empty.\n"), section
->name
);
4726 printf (_("Contents of the %s section:\n\n"), section
->name
);
4734 lbytes
= (bytes
> 16 ? 16 : bytes
);
4736 printf (" 0x%8.8lx ", (unsigned long) addr
);
4738 for (j
= 0; j
< 16; j
++)
4741 printf ("%2.2x", start
[j
]);
4749 for (j
= 0; j
< lbytes
; j
++)
4752 if (k
>= ' ' && k
< 0x80)
4771 display_debug_info (struct dwarf_section
*section
, void *file
)
4773 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4777 display_debug_types (struct dwarf_section
*section
, void *file
)
4779 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4783 display_trace_info (struct dwarf_section
*section
, void *file
)
4785 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4789 display_debug_aranges (struct dwarf_section
*section
,
4790 void *file ATTRIBUTE_UNUSED
)
4792 unsigned char *start
= section
->start
;
4793 unsigned char *end
= start
+ section
->size
;
4795 printf (_("Contents of the %s section:\n\n"), section
->name
);
4797 /* It does not matter if this load fails,
4798 we test for that later on. */
4799 load_debug_info (file
);
4803 unsigned char *hdrptr
;
4804 DWARF2_Internal_ARange arange
;
4805 unsigned char *addr_ranges
;
4808 unsigned char address_size
;
4810 unsigned int offset_size
;
4811 unsigned int initial_length_size
;
4815 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4816 if (arange
.ar_length
== 0xffffffff)
4818 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4820 initial_length_size
= 12;
4825 initial_length_size
= 4;
4828 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4829 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4831 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4832 && num_debug_info_entries
> 0
4833 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4834 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4835 (unsigned long) arange
.ar_info_offset
, section
->name
);
4837 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4838 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4840 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4842 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4846 printf (_(" Length: %ld\n"),
4847 (long) arange
.ar_length
);
4848 printf (_(" Version: %d\n"), arange
.ar_version
);
4849 printf (_(" Offset into .debug_info: 0x%lx\n"),
4850 (unsigned long) arange
.ar_info_offset
);
4851 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4852 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4854 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4856 /* PR 17512: file: 001-108546-0.001:0.1. */
4857 if (address_size
== 0 || address_size
> 8)
4859 error (_("Invalid address size in %s section!\n"),
4864 /* The DWARF spec does not require that the address size be a power
4865 of two, but we do. This will have to change if we ever encounter
4866 an uneven architecture. */
4867 if ((address_size
& (address_size
- 1)) != 0)
4869 warn (_("Pointer size + Segment size is not a power of two.\n"));
4873 if (address_size
> 4)
4874 printf (_("\n Address Length\n"));
4876 printf (_("\n Address Length\n"));
4878 addr_ranges
= hdrptr
;
4880 /* Must pad to an alignment boundary that is twice the address size. */
4881 excess
= (hdrptr
- start
) % (2 * address_size
);
4883 addr_ranges
+= (2 * address_size
) - excess
;
4885 start
+= arange
.ar_length
+ initial_length_size
;
4887 while (addr_ranges
+ 2 * address_size
<= start
)
4889 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4890 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4893 print_dwarf_vma (address
, address_size
);
4894 print_dwarf_vma (length
, address_size
);
4904 /* Comparison function for qsort. */
4906 comp_addr_base (const void * v0
, const void * v1
)
4908 debug_info
* info0
= (debug_info
*) v0
;
4909 debug_info
* info1
= (debug_info
*) v1
;
4910 return info0
->addr_base
- info1
->addr_base
;
4913 /* Display the debug_addr section. */
4915 display_debug_addr (struct dwarf_section
*section
,
4918 debug_info
**debug_addr_info
;
4919 unsigned char *entry
;
4924 if (section
->size
== 0)
4926 printf (_("\nThe %s section is empty.\n"), section
->name
);
4930 if (load_debug_info (file
) == 0)
4932 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4937 printf (_("Contents of the %s section:\n\n"), section
->name
);
4939 debug_addr_info
= (debug_info
**) xmalloc ((num_debug_info_entries
+ 1)
4940 * sizeof (debug_info
*));
4943 for (i
= 0; i
< num_debug_info_entries
; i
++)
4944 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4945 debug_addr_info
[count
++] = debug_information
+ i
;
4947 /* Add a sentinel to make iteration convenient. */
4948 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
4949 debug_addr_info
[count
]->addr_base
= section
->size
;
4951 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
4952 for (i
= 0; i
< count
; i
++)
4955 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
4957 printf (_(" For compilation unit at offset 0x%s:\n"),
4958 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
4960 printf (_("\tIndex\tAddress\n"));
4961 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
4962 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
4966 dwarf_vma base
= byte_get (entry
, address_size
);
4967 printf (_("\t%d:\t"), idx
);
4968 print_dwarf_vma (base
, address_size
);
4970 entry
+= address_size
;
4976 free (debug_addr_info
);
4980 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4982 display_debug_str_offsets (struct dwarf_section
*section
,
4983 void *file ATTRIBUTE_UNUSED
)
4985 if (section
->size
== 0)
4987 printf (_("\nThe %s section is empty.\n"), section
->name
);
4990 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
4991 what the offset size is for this section. */
4995 /* Each debug_information[x].range_lists[y] gets this representation for
4996 sorting purposes. */
5000 /* The debug_information[x].range_lists[y] value. */
5001 unsigned long ranges_offset
;
5003 /* Original debug_information to find parameters of the data. */
5004 debug_info
*debug_info_p
;
5007 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5010 range_entry_compar (const void *ap
, const void *bp
)
5012 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
5013 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
5014 const unsigned long a
= a_re
->ranges_offset
;
5015 const unsigned long b
= b_re
->ranges_offset
;
5017 return (a
> b
) - (b
> a
);
5021 display_debug_ranges (struct dwarf_section
*section
,
5022 void *file ATTRIBUTE_UNUSED
)
5024 unsigned char *start
= section
->start
;
5025 unsigned char *last_start
= start
;
5026 unsigned long bytes
= section
->size
;
5027 unsigned char *section_begin
= start
;
5028 unsigned char *finish
= start
+ bytes
;
5029 unsigned int num_range_list
, i
;
5030 struct range_entry
*range_entries
, *range_entry_fill
;
5034 printf (_("\nThe %s section is empty.\n"), section
->name
);
5038 if (load_debug_info (file
) == 0)
5040 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5046 for (i
= 0; i
< num_debug_info_entries
; i
++)
5047 num_range_list
+= debug_information
[i
].num_range_lists
;
5049 if (num_range_list
== 0)
5051 /* This can happen when the file was compiled with -gsplit-debug
5052 which removes references to range lists from the primary .o file. */
5053 printf (_("No range lists in .debug_info section.\n"));
5057 range_entries
= (struct range_entry
*)
5058 xmalloc (sizeof (*range_entries
) * num_range_list
);
5059 range_entry_fill
= range_entries
;
5061 for (i
= 0; i
< num_debug_info_entries
; i
++)
5063 debug_info
*debug_info_p
= &debug_information
[i
];
5066 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
5068 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
5069 range_entry_fill
->debug_info_p
= debug_info_p
;
5074 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
5075 range_entry_compar
);
5077 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
5078 warn (_("Range lists in %s section start at 0x%lx\n"),
5079 section
->name
, range_entries
[0].ranges_offset
);
5081 printf (_("Contents of the %s section:\n\n"), section
->name
);
5082 printf (_(" Offset Begin End\n"));
5084 for (i
= 0; i
< num_range_list
; i
++)
5086 struct range_entry
*range_entry
= &range_entries
[i
];
5087 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
5088 unsigned int pointer_size
;
5089 unsigned long offset
;
5090 unsigned char *next
;
5091 unsigned long base_address
;
5093 pointer_size
= debug_info_p
->pointer_size
;
5094 offset
= range_entry
->ranges_offset
;
5095 next
= section_begin
+ offset
;
5096 base_address
= debug_info_p
->base_address
;
5098 /* PR 17512: file: 001-101485-0.001:0.1. */
5099 if (pointer_size
< 2 || pointer_size
> 8)
5101 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5102 pointer_size
, offset
);
5106 if (dwarf_check
!= 0 && i
> 0)
5109 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5110 (unsigned long) (start
- section_begin
),
5111 (unsigned long) (next
- section_begin
), section
->name
);
5112 else if (start
> next
)
5114 if (next
== last_start
)
5116 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5117 (unsigned long) (start
- section_begin
),
5118 (unsigned long) (next
- section_begin
), section
->name
);
5124 while (start
< finish
)
5129 /* Note: we use sign extension here in order to be sure that
5130 we can detect the -1 escape value. Sign extension into the
5131 top 32 bits of a 32-bit address will not affect the values
5132 that we display since we always show hex values, and always
5133 the bottom 32-bits. */
5134 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
5135 if (start
>= finish
)
5137 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
5139 printf (" %8.8lx ", offset
);
5141 if (begin
== 0 && end
== 0)
5143 printf (_("<End of list>\n"));
5147 /* Check base address specifiers. */
5148 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
5151 print_dwarf_vma (begin
, pointer_size
);
5152 print_dwarf_vma (end
, pointer_size
);
5153 printf ("(base address)\n");
5157 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5158 print_dwarf_vma (end
+ base_address
, pointer_size
);
5161 fputs (_("(start == end)"), stdout
);
5162 else if (begin
> end
)
5163 fputs (_("(start > end)"), stdout
);
5170 free (range_entries
);
5175 typedef struct Frame_Chunk
5177 struct Frame_Chunk
*next
;
5178 unsigned char *chunk_start
;
5180 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5181 short int *col_type
;
5184 unsigned int code_factor
;
5191 unsigned char fde_encoding
;
5192 unsigned char cfa_exp
;
5193 unsigned char ptr_size
;
5194 unsigned char segment_size
;
5198 static const char *const *dwarf_regnames
;
5199 static unsigned int dwarf_regnames_count
;
5201 /* A marker for a col_type that means this column was never referenced
5202 in the frame info. */
5203 #define DW_CFA_unreferenced (-1)
5205 /* Return 0 if no more space is needed, 1 if more space is needed,
5206 -1 for invalid reg. */
5209 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
5211 unsigned int prev
= fc
->ncols
;
5213 if (reg
< (unsigned int) fc
->ncols
)
5216 if (dwarf_regnames_count
5217 && reg
> dwarf_regnames_count
)
5220 fc
->ncols
= reg
+ 1;
5221 /* PR 17512: file: 10450-2643-0.004.
5222 If reg == -1 then this can happen... */
5226 /* PR 17512: file: 2844a11d. */
5227 if (fc
->ncols
> 1024)
5229 error (_("Unfeasibly large register number: %u\n"), reg
);
5231 /* FIXME: 1024 is an arbitrary limit. Increase it if
5232 we ever encounter a valid binary that exceeds it. */
5236 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
5237 sizeof (short int));
5238 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
5239 /* PR 17512: file:002-10025-0.005. */
5240 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
5242 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5248 while (prev
< fc
->ncols
)
5250 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
5251 fc
->col_offset
[prev
] = 0;
5257 static const char *const dwarf_regnames_i386
[] =
5259 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5260 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5261 "eip", "eflags", NULL
, /* 8 - 10 */
5262 "st0", "st1", "st2", "st3", /* 11 - 14 */
5263 "st4", "st5", "st6", "st7", /* 15 - 18 */
5264 NULL
, NULL
, /* 19 - 20 */
5265 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5266 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5267 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5268 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5269 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5270 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5271 "tr", "ldtr", /* 48 - 49 */
5272 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5273 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5274 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5275 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5276 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5277 NULL
, NULL
, NULL
, /* 90 - 92 */
5278 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5282 init_dwarf_regnames_i386 (void)
5284 dwarf_regnames
= dwarf_regnames_i386
;
5285 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5288 static const char *const dwarf_regnames_x86_64
[] =
5290 "rax", "rdx", "rcx", "rbx",
5291 "rsi", "rdi", "rbp", "rsp",
5292 "r8", "r9", "r10", "r11",
5293 "r12", "r13", "r14", "r15",
5295 "xmm0", "xmm1", "xmm2", "xmm3",
5296 "xmm4", "xmm5", "xmm6", "xmm7",
5297 "xmm8", "xmm9", "xmm10", "xmm11",
5298 "xmm12", "xmm13", "xmm14", "xmm15",
5299 "st0", "st1", "st2", "st3",
5300 "st4", "st5", "st6", "st7",
5301 "mm0", "mm1", "mm2", "mm3",
5302 "mm4", "mm5", "mm6", "mm7",
5304 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5305 "fs.base", "gs.base", NULL
, NULL
,
5307 "mxcsr", "fcw", "fsw",
5308 "xmm16", "xmm17", "xmm18", "xmm19",
5309 "xmm20", "xmm21", "xmm22", "xmm23",
5310 "xmm24", "xmm25", "xmm26", "xmm27",
5311 "xmm28", "xmm29", "xmm30", "xmm31",
5312 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5313 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5314 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5315 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5316 NULL
, NULL
, NULL
, /* 115 - 117 */
5317 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5321 init_dwarf_regnames_x86_64 (void)
5323 dwarf_regnames
= dwarf_regnames_x86_64
;
5324 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5327 static const char *const dwarf_regnames_aarch64
[] =
5329 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5330 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5331 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5332 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5333 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5334 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5335 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5336 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5337 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5338 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5339 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5340 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5344 init_dwarf_regnames_aarch64 (void)
5346 dwarf_regnames
= dwarf_regnames_aarch64
;
5347 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
5351 init_dwarf_regnames (unsigned int e_machine
)
5357 init_dwarf_regnames_i386 ();
5363 init_dwarf_regnames_x86_64 ();
5367 init_dwarf_regnames_aarch64 ();
5376 regname (unsigned int regno
, int row
)
5378 static char reg
[64];
5380 && regno
< dwarf_regnames_count
5381 && dwarf_regnames
[regno
] != NULL
)
5384 return dwarf_regnames
[regno
];
5385 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5386 dwarf_regnames
[regno
]);
5389 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5394 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
5399 if (*max_regs
< fc
->ncols
)
5400 *max_regs
= fc
->ncols
;
5402 if (*need_col_headers
)
5404 static const char *sloc
= " LOC";
5406 *need_col_headers
= 0;
5408 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5410 for (r
= 0; r
< *max_regs
; r
++)
5411 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5416 printf ("%-5s ", regname (r
, 1));
5422 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5424 strcpy (tmp
, "exp");
5426 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5427 printf ("%-8s ", tmp
);
5429 for (r
= 0; r
< fc
->ncols
; r
++)
5431 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5433 switch (fc
->col_type
[r
])
5435 case DW_CFA_undefined
:
5438 case DW_CFA_same_value
:
5442 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5444 case DW_CFA_val_offset
:
5445 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5447 case DW_CFA_register
:
5448 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5450 case DW_CFA_expression
:
5451 strcpy (tmp
, "exp");
5453 case DW_CFA_val_expression
:
5454 strcpy (tmp
, "vexp");
5457 strcpy (tmp
, "n/a");
5460 printf ("%-5s ", tmp
);
5466 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5467 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5468 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5470 static unsigned char *
5471 read_cie (unsigned char *start
, unsigned char *end
,
5472 Frame_Chunk
**p_cie
, int *p_version
,
5473 unsigned long *p_aug_len
, unsigned char **p_aug
)
5477 unsigned int length_return
;
5478 unsigned char *augmentation_data
= NULL
;
5479 unsigned long augmentation_data_len
= 0;
5482 /* PR 17512: file: 001-228113-0.004. */
5486 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5487 memset (fc
, 0, sizeof (Frame_Chunk
));
5489 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5490 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5494 fc
->augmentation
= (char *) start
;
5495 /* PR 17512: file: 001-228113-0.004.
5496 Skip past augmentation name, but avoid running off the end of the data. */
5498 if (* start
++ == '\0')
5502 warn (_("No terminator for augmentation name\n"));
5506 if (strcmp (fc
->augmentation
, "eh") == 0)
5507 start
+= eh_addr_size
;
5511 GET (fc
->ptr_size
, 1);
5512 GET (fc
->segment_size
, 1);
5513 eh_addr_size
= fc
->ptr_size
;
5517 fc
->ptr_size
= eh_addr_size
;
5518 fc
->segment_size
= 0;
5520 fc
->code_factor
= LEB ();
5521 fc
->data_factor
= SLEB ();
5531 if (fc
->augmentation
[0] == 'z')
5533 augmentation_data_len
= LEB ();
5534 augmentation_data
= start
;
5535 start
+= augmentation_data_len
;
5536 /* PR 17512: file: 11042-2589-0.004. */
5539 warn (_("Augmentation data too long: 0x%lx"), augmentation_data_len
);
5544 if (augmentation_data_len
)
5548 unsigned char *qend
;
5550 p
= (unsigned char *) fc
->augmentation
+ 1;
5551 q
= augmentation_data
;
5552 qend
= q
+ augmentation_data_len
;
5554 /* PR 17531: file: 015adfaa. */
5557 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len
);
5558 augmentation_data_len
= 0;
5561 while (p
< end
&& q
< augmentation_data
+ augmentation_data_len
)
5566 q
+= 1 + size_of_encoded_value (*q
);
5568 fc
->fde_encoding
= *q
++;
5575 /* Note - it is OK if this loop terminates with q < qend.
5576 Padding may have been inserted to align the end of the CIE. */
5581 *p_version
= version
;
5584 *p_aug_len
= augmentation_data_len
;
5585 *p_aug
= augmentation_data
;
5591 display_debug_frames (struct dwarf_section
*section
,
5592 void *file ATTRIBUTE_UNUSED
)
5594 unsigned char *start
= section
->start
;
5595 unsigned char *end
= start
+ section
->size
;
5596 unsigned char *section_start
= start
;
5597 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
5598 Frame_Chunk
*remembered_state
= 0;
5600 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5601 unsigned int length_return
;
5602 unsigned int max_regs
= 0;
5603 const char *bad_reg
= _("bad register: ");
5604 int saved_eh_addr_size
= eh_addr_size
;
5606 printf (_("Contents of the %s section:\n"), section
->name
);
5610 unsigned char *saved_start
;
5611 unsigned char *block_end
;
5616 int need_col_headers
= 1;
5617 unsigned char *augmentation_data
= NULL
;
5618 unsigned long augmentation_data_len
= 0;
5619 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5620 unsigned int offset_size
;
5621 unsigned int initial_length_size
;
5623 saved_start
= start
;
5625 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5629 printf ("\n%08lx ZERO terminator\n\n",
5630 (unsigned long)(saved_start
- section_start
));
5631 /* Skip any zero terminators that directly follow.
5632 A corrupt section size could have loaded a whole
5633 slew of zero filled memory bytes. eg
5634 PR 17512: file: 070-19381-0.004. */
5635 while (start
< end
&& * start
== 0)
5640 if (length
== 0xffffffff)
5642 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5644 initial_length_size
= 12;
5649 initial_length_size
= 4;
5652 block_end
= saved_start
+ length
+ initial_length_size
;
5653 if (block_end
> end
|| block_end
< start
)
5655 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5656 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5657 (unsigned long) (saved_start
- section_start
));
5661 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5663 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5664 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5669 start
= read_cie (start
, end
, &cie
, &version
,
5670 &augmentation_data_len
, &augmentation_data
);
5671 /* PR 17512: file: 027-135133-0.005. */
5678 fc
->chunk_start
= saved_start
;
5679 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5682 if (frame_need_space (fc
, mreg
) < 0)
5684 if (fc
->fde_encoding
)
5685 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5687 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5688 print_dwarf_vma (length
, fc
->ptr_size
);
5689 print_dwarf_vma (cie_id
, offset_size
);
5691 if (do_debug_frames_interp
)
5693 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5694 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5699 printf (" Version: %d\n", version
);
5700 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5703 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5704 printf (" Segment Size: %u\n", fc
->segment_size
);
5706 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5707 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5708 printf (" Return address column: %d\n", fc
->ra
);
5710 if (augmentation_data_len
)
5714 printf (" Augmentation data: ");
5715 for (i
= 0; i
< augmentation_data_len
; ++i
)
5716 /* FIXME: If do_wide is FALSE, then we should
5717 add carriage returns at 80 columns... */
5718 printf (" %02x", augmentation_data
[i
]);
5726 unsigned char *look_for
;
5727 static Frame_Chunk fde_fc
;
5728 unsigned long segment_selector
;
5732 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
5733 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
5736 look_for
= section_start
+ cie_id
;
5738 if (look_for
<= saved_start
)
5740 for (cie
= chunks
; cie
; cie
= cie
->next
)
5741 if (cie
->chunk_start
== look_for
)
5746 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
5747 if (cie
->chunk_start
== look_for
)
5751 unsigned int off_size
;
5752 unsigned char *cie_scan
;
5754 cie_scan
= look_for
;
5756 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
5757 if (length
== 0xffffffff)
5759 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
5766 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
5769 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
5770 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
5775 read_cie (cie_scan
, end
, &cie
, &version
,
5776 &augmentation_data_len
, &augmentation_data
);
5777 /* PR 17512: file: 3450-2098-0.004. */
5780 warn (_("Failed to read CIE information\n"));
5783 cie
->next
= forward_refs
;
5785 cie
->chunk_start
= look_for
;
5786 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5789 if (frame_need_space (cie
, mreg
) < 0)
5791 warn (_("Invalid max register\n"));
5794 if (cie
->fde_encoding
)
5796 = size_of_encoded_value (cie
->fde_encoding
);
5803 memset (fc
, 0, sizeof (Frame_Chunk
));
5807 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5808 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5809 (unsigned long) (saved_start
- section_start
));
5811 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5812 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5813 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
5815 warn (_("Invalid max register\n"));
5819 fc
->augmentation
= "";
5820 fc
->fde_encoding
= 0;
5821 fc
->ptr_size
= eh_addr_size
;
5822 fc
->segment_size
= 0;
5826 fc
->ncols
= cie
->ncols
;
5827 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5828 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5829 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5830 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5831 fc
->augmentation
= cie
->augmentation
;
5832 fc
->ptr_size
= cie
->ptr_size
;
5833 eh_addr_size
= cie
->ptr_size
;
5834 fc
->segment_size
= cie
->segment_size
;
5835 fc
->code_factor
= cie
->code_factor
;
5836 fc
->data_factor
= cie
->data_factor
;
5837 fc
->cfa_reg
= cie
->cfa_reg
;
5838 fc
->cfa_offset
= cie
->cfa_offset
;
5840 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
5842 warn (_("Invalid max register\n"));
5845 fc
->fde_encoding
= cie
->fde_encoding
;
5848 if (fc
->fde_encoding
)
5849 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5851 segment_selector
= 0;
5852 if (fc
->segment_size
)
5853 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5855 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
5857 /* FIXME: It appears that sometimes the final pc_range value is
5858 encoded in less than encoded_ptr_size bytes. See the x86_64
5859 run of the "objcopy on compressed debug sections" test for an
5861 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5863 if (cie
->augmentation
[0] == 'z')
5865 augmentation_data_len
= LEB ();
5866 augmentation_data
= start
;
5867 start
+= augmentation_data_len
;
5868 /* PR 17512: file: 722-8446-0.004. */
5869 if (start
>= end
|| ((signed long) augmentation_data_len
) < 0)
5871 warn (_("Corrupt augmentation data length: %lx\n"),
5872 augmentation_data_len
);
5874 augmentation_data
= NULL
;
5875 augmentation_data_len
= 0;
5879 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5880 (unsigned long)(saved_start
- section_start
),
5881 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
5882 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5883 (unsigned long)(cie
->chunk_start
- section_start
));
5885 if (fc
->segment_size
)
5886 printf ("%04lx:", segment_selector
);
5889 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
5890 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
5892 if (! do_debug_frames_interp
&& augmentation_data_len
)
5896 printf (" Augmentation data: ");
5897 for (i
= 0; i
< augmentation_data_len
; ++i
)
5898 printf (" %02x", augmentation_data
[i
]);
5904 /* At this point, fc is the current chunk, cie (if any) is set, and
5905 we're about to interpret instructions for the chunk. */
5906 /* ??? At present we need to do this always, since this sizes the
5907 fc->col_type and fc->col_offset arrays, which we write into always.
5908 We should probably split the interpreted and non-interpreted bits
5909 into two different routines, since there's so much that doesn't
5910 really overlap between them. */
5911 if (1 || do_debug_frames_interp
)
5913 /* Start by making a pass over the chunk, allocating storage
5914 and taking note of what registers are used. */
5915 unsigned char *tmp
= start
;
5917 while (start
< block_end
)
5919 unsigned int reg
, op
, opa
;
5927 /* Warning: if you add any more cases to this switch, be
5928 sure to add them to the corresponding switch below. */
5931 case DW_CFA_advance_loc
:
5935 if (frame_need_space (fc
, opa
) >= 0)
5936 fc
->col_type
[opa
] = DW_CFA_undefined
;
5938 case DW_CFA_restore
:
5939 if (frame_need_space (fc
, opa
) >= 0)
5940 fc
->col_type
[opa
] = DW_CFA_undefined
;
5942 case DW_CFA_set_loc
:
5943 start
+= encoded_ptr_size
;
5945 case DW_CFA_advance_loc1
:
5948 case DW_CFA_advance_loc2
:
5951 case DW_CFA_advance_loc4
:
5954 case DW_CFA_offset_extended
:
5955 case DW_CFA_val_offset
:
5956 reg
= LEB (); LEB ();
5957 if (frame_need_space (fc
, reg
) >= 0)
5958 fc
->col_type
[reg
] = DW_CFA_undefined
;
5960 case DW_CFA_restore_extended
:
5962 if (frame_need_space (fc
, reg
) >= 0)
5963 fc
->col_type
[reg
] = DW_CFA_undefined
;
5965 case DW_CFA_undefined
:
5967 if (frame_need_space (fc
, reg
) >= 0)
5968 fc
->col_type
[reg
] = DW_CFA_undefined
;
5970 case DW_CFA_same_value
:
5972 if (frame_need_space (fc
, reg
) >= 0)
5973 fc
->col_type
[reg
] = DW_CFA_undefined
;
5975 case DW_CFA_register
:
5976 reg
= LEB (); LEB ();
5977 if (frame_need_space (fc
, reg
) >= 0)
5978 fc
->col_type
[reg
] = DW_CFA_undefined
;
5980 case DW_CFA_def_cfa
:
5983 case DW_CFA_def_cfa_register
:
5986 case DW_CFA_def_cfa_offset
:
5989 case DW_CFA_def_cfa_expression
:
5991 if (start
+ temp
< start
)
5993 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
5999 case DW_CFA_expression
:
6000 case DW_CFA_val_expression
:
6003 if (start
+ temp
< start
)
6005 /* PR 17512: file:306-192417-0.005. */
6006 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
6011 if (frame_need_space (fc
, reg
) >= 0)
6012 fc
->col_type
[reg
] = DW_CFA_undefined
;
6014 case DW_CFA_offset_extended_sf
:
6015 case DW_CFA_val_offset_sf
:
6016 reg
= LEB (); SLEB ();
6017 if (frame_need_space (fc
, reg
) >= 0)
6018 fc
->col_type
[reg
] = DW_CFA_undefined
;
6020 case DW_CFA_def_cfa_sf
:
6023 case DW_CFA_def_cfa_offset_sf
:
6026 case DW_CFA_MIPS_advance_loc8
:
6029 case DW_CFA_GNU_args_size
:
6032 case DW_CFA_GNU_negative_offset_extended
:
6033 reg
= LEB (); LEB ();
6034 if (frame_need_space (fc
, reg
) >= 0)
6035 fc
->col_type
[reg
] = DW_CFA_undefined
;
6044 /* Now we know what registers are used, make a second pass over
6045 the chunk, this time actually printing out the info. */
6047 while (start
< block_end
)
6050 unsigned long ul
, reg
, roffs
;
6054 const char *reg_prefix
= "";
6061 /* Warning: if you add any more cases to this switch, be
6062 sure to add them to the corresponding switch above. */
6065 case DW_CFA_advance_loc
:
6066 if (do_debug_frames_interp
)
6067 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6069 printf (" DW_CFA_advance_loc: %d to %s\n",
6070 opa
* fc
->code_factor
,
6071 dwarf_vmatoa_1 (NULL
,
6072 fc
->pc_begin
+ opa
* fc
->code_factor
,
6074 fc
->pc_begin
+= opa
* fc
->code_factor
;
6079 if (opa
>= (unsigned int) fc
->ncols
)
6080 reg_prefix
= bad_reg
;
6081 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6082 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6083 reg_prefix
, regname (opa
, 0),
6084 roffs
* fc
->data_factor
);
6085 if (*reg_prefix
== '\0')
6087 fc
->col_type
[opa
] = DW_CFA_offset
;
6088 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
6092 case DW_CFA_restore
:
6093 if (opa
>= (unsigned int) cie
->ncols
6094 || opa
>= (unsigned int) fc
->ncols
)
6095 reg_prefix
= bad_reg
;
6096 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6097 printf (" DW_CFA_restore: %s%s\n",
6098 reg_prefix
, regname (opa
, 0));
6099 if (*reg_prefix
== '\0')
6101 fc
->col_type
[opa
] = cie
->col_type
[opa
];
6102 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
6103 if (do_debug_frames_interp
6104 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
6105 fc
->col_type
[opa
] = DW_CFA_undefined
;
6109 case DW_CFA_set_loc
:
6110 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
6111 if (do_debug_frames_interp
)
6112 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6114 printf (" DW_CFA_set_loc: %s\n",
6115 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
6119 case DW_CFA_advance_loc1
:
6120 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
6121 if (do_debug_frames_interp
)
6122 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6124 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6125 (unsigned long) (ofs
* fc
->code_factor
),
6126 dwarf_vmatoa_1 (NULL
,
6127 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6129 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6132 case DW_CFA_advance_loc2
:
6133 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
6134 if (do_debug_frames_interp
)
6135 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6137 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6138 (unsigned long) (ofs
* fc
->code_factor
),
6139 dwarf_vmatoa_1 (NULL
,
6140 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6142 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6145 case DW_CFA_advance_loc4
:
6146 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
6147 if (do_debug_frames_interp
)
6148 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6150 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6151 (unsigned long) (ofs
* fc
->code_factor
),
6152 dwarf_vmatoa_1 (NULL
,
6153 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6155 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6158 case DW_CFA_offset_extended
:
6161 if (reg
>= (unsigned int) fc
->ncols
)
6162 reg_prefix
= bad_reg
;
6163 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6164 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6165 reg_prefix
, regname (reg
, 0),
6166 roffs
* fc
->data_factor
);
6167 if (*reg_prefix
== '\0')
6169 fc
->col_type
[reg
] = DW_CFA_offset
;
6170 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6174 case DW_CFA_val_offset
:
6177 if (reg
>= (unsigned int) fc
->ncols
)
6178 reg_prefix
= bad_reg
;
6179 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6180 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6181 reg_prefix
, regname (reg
, 0),
6182 roffs
* fc
->data_factor
);
6183 if (*reg_prefix
== '\0')
6185 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6186 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6190 case DW_CFA_restore_extended
:
6192 if (reg
>= (unsigned int) cie
->ncols
6193 || reg
>= (unsigned int) fc
->ncols
)
6194 reg_prefix
= bad_reg
;
6195 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6196 printf (" DW_CFA_restore_extended: %s%s\n",
6197 reg_prefix
, regname (reg
, 0));
6198 if (*reg_prefix
== '\0')
6200 fc
->col_type
[reg
] = cie
->col_type
[reg
];
6201 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
6205 case DW_CFA_undefined
:
6207 if (reg
>= (unsigned int) fc
->ncols
)
6208 reg_prefix
= bad_reg
;
6209 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6210 printf (" DW_CFA_undefined: %s%s\n",
6211 reg_prefix
, regname (reg
, 0));
6212 if (*reg_prefix
== '\0')
6214 fc
->col_type
[reg
] = DW_CFA_undefined
;
6215 fc
->col_offset
[reg
] = 0;
6219 case DW_CFA_same_value
:
6221 if (reg
>= (unsigned int) fc
->ncols
)
6222 reg_prefix
= bad_reg
;
6223 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6224 printf (" DW_CFA_same_value: %s%s\n",
6225 reg_prefix
, regname (reg
, 0));
6226 if (*reg_prefix
== '\0')
6228 fc
->col_type
[reg
] = DW_CFA_same_value
;
6229 fc
->col_offset
[reg
] = 0;
6233 case DW_CFA_register
:
6236 if (reg
>= (unsigned int) fc
->ncols
)
6237 reg_prefix
= bad_reg
;
6238 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6240 printf (" DW_CFA_register: %s%s in ",
6241 reg_prefix
, regname (reg
, 0));
6242 puts (regname (roffs
, 0));
6244 if (*reg_prefix
== '\0')
6246 fc
->col_type
[reg
] = DW_CFA_register
;
6247 fc
->col_offset
[reg
] = roffs
;
6251 case DW_CFA_remember_state
:
6252 if (! do_debug_frames_interp
)
6253 printf (" DW_CFA_remember_state\n");
6254 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6255 rs
->cfa_offset
= fc
->cfa_offset
;
6256 rs
->cfa_reg
= fc
->cfa_reg
;
6258 rs
->cfa_exp
= fc
->cfa_exp
;
6259 rs
->ncols
= fc
->ncols
;
6260 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
6261 sizeof (* rs
->col_type
));
6262 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
6263 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
6264 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
6265 rs
->next
= remembered_state
;
6266 remembered_state
= rs
;
6269 case DW_CFA_restore_state
:
6270 if (! do_debug_frames_interp
)
6271 printf (" DW_CFA_restore_state\n");
6272 rs
= remembered_state
;
6275 remembered_state
= rs
->next
;
6276 fc
->cfa_offset
= rs
->cfa_offset
;
6277 fc
->cfa_reg
= rs
->cfa_reg
;
6279 fc
->cfa_exp
= rs
->cfa_exp
;
6280 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
6282 warn (_("Invalid column number in saved frame state"));
6286 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
6287 memcpy (fc
->col_offset
, rs
->col_offset
,
6288 rs
->ncols
* sizeof (* rs
->col_offset
));
6289 free (rs
->col_type
);
6290 free (rs
->col_offset
);
6293 else if (do_debug_frames_interp
)
6294 printf ("Mismatched DW_CFA_restore_state\n");
6297 case DW_CFA_def_cfa
:
6298 fc
->cfa_reg
= LEB ();
6299 fc
->cfa_offset
= LEB ();
6301 if (! do_debug_frames_interp
)
6302 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6303 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6306 case DW_CFA_def_cfa_register
:
6307 fc
->cfa_reg
= LEB ();
6309 if (! do_debug_frames_interp
)
6310 printf (" DW_CFA_def_cfa_register: %s\n",
6311 regname (fc
->cfa_reg
, 0));
6314 case DW_CFA_def_cfa_offset
:
6315 fc
->cfa_offset
= LEB ();
6316 if (! do_debug_frames_interp
)
6317 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
6321 if (! do_debug_frames_interp
)
6322 printf (" DW_CFA_nop\n");
6325 case DW_CFA_def_cfa_expression
:
6327 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6329 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
6332 if (! do_debug_frames_interp
)
6334 printf (" DW_CFA_def_cfa_expression (");
6335 decode_location_expression (start
, eh_addr_size
, 0, -1,
6343 case DW_CFA_expression
:
6346 if (reg
>= (unsigned int) fc
->ncols
)
6347 reg_prefix
= bad_reg
;
6348 /* PR 17512: file: 069-133014-0.006. */
6349 /* PR 17512: file: 98c02eb4. */
6350 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6352 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
6355 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6357 printf (" DW_CFA_expression: %s%s (",
6358 reg_prefix
, regname (reg
, 0));
6359 decode_location_expression (start
, eh_addr_size
, 0, -1,
6363 if (*reg_prefix
== '\0')
6364 fc
->col_type
[reg
] = DW_CFA_expression
;
6368 case DW_CFA_val_expression
:
6371 if (reg
>= (unsigned int) fc
->ncols
)
6372 reg_prefix
= bad_reg
;
6373 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6375 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
6378 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6380 printf (" DW_CFA_val_expression: %s%s (",
6381 reg_prefix
, regname (reg
, 0));
6382 decode_location_expression (start
, eh_addr_size
, 0, -1,
6386 if (*reg_prefix
== '\0')
6387 fc
->col_type
[reg
] = DW_CFA_val_expression
;
6391 case DW_CFA_offset_extended_sf
:
6394 if (frame_need_space (fc
, reg
) < 0)
6395 reg_prefix
= bad_reg
;
6396 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6397 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6398 reg_prefix
, regname (reg
, 0),
6399 l
* fc
->data_factor
);
6400 if (*reg_prefix
== '\0')
6402 fc
->col_type
[reg
] = DW_CFA_offset
;
6403 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6407 case DW_CFA_val_offset_sf
:
6410 if (frame_need_space (fc
, reg
) < 0)
6411 reg_prefix
= bad_reg
;
6412 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6413 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6414 reg_prefix
, regname (reg
, 0),
6415 l
* fc
->data_factor
);
6416 if (*reg_prefix
== '\0')
6418 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6419 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6423 case DW_CFA_def_cfa_sf
:
6424 fc
->cfa_reg
= LEB ();
6425 fc
->cfa_offset
= SLEB ();
6426 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6428 if (! do_debug_frames_interp
)
6429 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6430 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6433 case DW_CFA_def_cfa_offset_sf
:
6434 fc
->cfa_offset
= SLEB ();
6435 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6436 if (! do_debug_frames_interp
)
6437 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
6440 case DW_CFA_MIPS_advance_loc8
:
6441 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
6442 if (do_debug_frames_interp
)
6443 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6445 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6446 (unsigned long) (ofs
* fc
->code_factor
),
6447 dwarf_vmatoa_1 (NULL
,
6448 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6450 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6453 case DW_CFA_GNU_window_save
:
6454 if (! do_debug_frames_interp
)
6455 printf (" DW_CFA_GNU_window_save\n");
6458 case DW_CFA_GNU_args_size
:
6460 if (! do_debug_frames_interp
)
6461 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
6464 case DW_CFA_GNU_negative_offset_extended
:
6467 if (frame_need_space (fc
, reg
) < 0)
6468 reg_prefix
= bad_reg
;
6469 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6470 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6471 reg_prefix
, regname (reg
, 0),
6472 l
* fc
->data_factor
);
6473 if (*reg_prefix
== '\0')
6475 fc
->col_type
[reg
] = DW_CFA_offset
;
6476 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6481 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
6482 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
6484 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
6489 if (do_debug_frames_interp
)
6490 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6493 eh_addr_size
= saved_eh_addr_size
;
6506 display_gdb_index (struct dwarf_section
*section
,
6507 void *file ATTRIBUTE_UNUSED
)
6509 unsigned char *start
= section
->start
;
6511 uint32_t cu_list_offset
, tu_list_offset
;
6512 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6513 unsigned int cu_list_elements
, tu_list_elements
;
6514 unsigned int address_table_size
, symbol_table_slots
;
6515 unsigned char *cu_list
, *tu_list
;
6516 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6519 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6521 printf (_("Contents of the %s section:\n"), section
->name
);
6523 if (section
->size
< 6 * sizeof (uint32_t))
6525 warn (_("Truncated header in the %s section.\n"), section
->name
);
6529 version
= byte_get_little_endian (start
, 4);
6530 printf (_("Version %ld\n"), (long) version
);
6532 /* Prior versions are obsolete, and future versions may not be
6533 backwards compatible. */
6534 if (version
< 3 || version
> 8)
6536 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6540 warn (_("The address table data in version 3 may be wrong.\n"));
6542 warn (_("Version 4 does not support case insensitive lookups.\n"));
6544 warn (_("Version 5 does not include inlined functions.\n"));
6546 warn (_("Version 6 does not include symbol attributes.\n"));
6547 /* Version 7 indices generated by Gold have bad type unit references,
6548 PR binutils/15021. But we don't know if the index was generated by
6549 Gold or not, so to avoid worrying users with gdb-generated indices
6550 we say nothing for version 7 here. */
6552 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6553 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6554 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6555 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6556 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6558 if (cu_list_offset
> section
->size
6559 || tu_list_offset
> section
->size
6560 || address_table_offset
> section
->size
6561 || symbol_table_offset
> section
->size
6562 || constant_pool_offset
> section
->size
)
6564 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6568 /* PR 17531: file: 418d0a8a. */
6569 if (tu_list_offset
< cu_list_offset
)
6571 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6572 tu_list_offset
, cu_list_offset
);
6576 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6578 if (address_table_offset
< tu_list_offset
)
6580 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6581 address_table_offset
, tu_list_offset
);
6585 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6587 /* PR 17531: file: 18a47d3d. */
6588 if (symbol_table_offset
< address_table_offset
)
6590 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6591 symbol_table_offset
, address_table_offset
);
6595 address_table_size
= symbol_table_offset
- address_table_offset
;
6597 if (constant_pool_offset
< symbol_table_offset
)
6599 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6600 constant_pool_offset
, symbol_table_offset
);
6604 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6606 cu_list
= start
+ cu_list_offset
;
6607 tu_list
= start
+ tu_list_offset
;
6608 address_table
= start
+ address_table_offset
;
6609 symbol_table
= start
+ symbol_table_offset
;
6610 constant_pool
= start
+ constant_pool_offset
;
6612 if (address_table
+ address_table_size
* (2 + 8 + 4) > section
->start
+ section
->size
)
6614 warn (_("Address table extends beyond end of section. %x"), address_table_size
);
6618 printf (_("\nCU table:\n"));
6619 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6621 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6622 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6624 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6625 (unsigned long) cu_offset
,
6626 (unsigned long) (cu_offset
+ cu_length
- 1));
6629 printf (_("\nTU table:\n"));
6630 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6632 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6633 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6634 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6636 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6637 (unsigned long) tu_offset
,
6638 (unsigned long) type_offset
);
6639 print_dwarf_vma (signature
, 8);
6643 printf (_("\nAddress table:\n"));
6644 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
6647 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6648 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6649 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6651 print_dwarf_vma (low
, 8);
6652 print_dwarf_vma (high
, 8);
6653 printf (_("%lu\n"), (unsigned long) cu_index
);
6656 printf (_("\nSymbol table:\n"));
6657 for (i
= 0; i
< symbol_table_slots
; ++i
)
6659 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6660 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6661 uint32_t num_cus
, cu
;
6663 if (name_offset
!= 0
6664 || cu_vector_offset
!= 0)
6668 /* PR 17531: file: 5b7b07ad. */
6669 if (constant_pool
+ name_offset
< constant_pool
6670 || constant_pool
+ name_offset
>= section
->start
+ section
->size
)
6672 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
6673 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6677 printf ("[%3u] %.*s:", i
,
6678 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
6679 constant_pool
+ name_offset
);
6681 if (constant_pool
+ cu_vector_offset
< constant_pool
6682 || constant_pool
+ cu_vector_offset
>= section
->start
+ section
->size
)
6684 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
6685 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6686 cu_vector_offset
, i
);
6690 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
6692 if (num_cus
* 4 < num_cus
6693 || constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4 >=
6694 section
->start
+ section
->size
)
6696 printf ("<invalid number of CUs: %d>\n", num_cus
);
6697 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6704 for (j
= 0; j
< num_cus
; ++j
)
6707 gdb_index_symbol_kind kind
;
6709 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6710 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6711 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6712 cu
= GDB_INDEX_CU_VALUE (cu
);
6713 /* Convert to TU number if it's for a type unit. */
6714 if (cu
>= cu_list_elements
/ 2)
6715 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6716 (unsigned long) (cu
- cu_list_elements
/ 2));
6718 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6720 printf (" [%s, %s]",
6721 is_static
? _("static") : _("global"),
6722 get_gdb_index_symbol_kind_name (kind
));
6734 /* Pre-allocate enough space for the CU/TU sets needed. */
6737 prealloc_cu_tu_list (unsigned int nshndx
)
6739 if (shndx_pool
== NULL
)
6741 shndx_pool_size
= nshndx
;
6742 shndx_pool_used
= 0;
6743 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6744 sizeof (unsigned int));
6748 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6749 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6750 sizeof (unsigned int));
6755 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6757 if (shndx_pool_used
>= shndx_pool_size
)
6759 error (_("Internal error: out of space in the shndx pool.\n"));
6762 shndx_pool
[shndx_pool_used
++] = shndx
;
6766 end_cu_tu_entry (void)
6768 if (shndx_pool_used
>= shndx_pool_size
)
6770 error (_("Internal error: out of space in the shndx pool.\n"));
6773 shndx_pool
[shndx_pool_used
++] = 0;
6776 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6779 get_DW_SECT_short_name (unsigned int dw_sect
)
6781 static char buf
[16];
6789 case DW_SECT_ABBREV
:
6795 case DW_SECT_STR_OFFSETS
:
6797 case DW_SECT_MACINFO
:
6805 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6809 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6810 These sections are extensions for Fission.
6811 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6814 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6816 unsigned char *phdr
= section
->start
;
6817 unsigned char *limit
= phdr
+ section
->size
;
6818 unsigned char *phash
;
6819 unsigned char *pindex
;
6820 unsigned char *ppool
;
6821 unsigned int version
;
6822 unsigned int ncols
= 0;
6824 unsigned int nslots
;
6827 dwarf_vma signature_high
;
6828 dwarf_vma signature_low
;
6831 /* PR 17512: file: 002-168123-0.004. */
6834 warn (_("Section %s is empty\n"), section
->name
);
6837 /* PR 17512: file: 002-376-0.004. */
6838 if (section
->size
< 24)
6840 warn (_("Section %s is too small to contain a CU/TU header\n"),
6845 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
6847 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
6848 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
6849 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
6852 pindex
= phash
+ nslots
* 8;
6853 ppool
= pindex
+ nslots
* 4;
6857 printf (_("Contents of the %s section:\n\n"), section
->name
);
6858 printf (_(" Version: %d\n"), version
);
6860 printf (_(" Number of columns: %d\n"), ncols
);
6861 printf (_(" Number of used entries: %d\n"), nused
);
6862 printf (_(" Number of slots: %d\n\n"), nslots
);
6867 warn (_("Section %s too small for %d hash table entries\n"),
6868 section
->name
, nslots
);
6875 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6876 for (i
= 0; i
< nslots
; i
++)
6878 unsigned char *shndx_list
;
6881 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
6882 if (signature_high
!= 0 || signature_low
!= 0)
6884 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
6885 shndx_list
= ppool
+ j
* 4;
6887 printf (_(" [%3d] Signature: 0x%s Sections: "),
6888 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6889 buf
, sizeof (buf
)));
6892 if (shndx_list
>= limit
)
6894 warn (_("Section %s too small for shndx pool\n"),
6898 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
6902 printf (" %d", shndx
);
6904 add_shndx_to_cu_tu_entry (shndx
);
6916 else if (version
== 2)
6919 unsigned int dw_sect
;
6920 unsigned char *ph
= phash
;
6921 unsigned char *pi
= pindex
;
6922 unsigned char *poffsets
= ppool
+ ncols
* 4;
6923 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
6924 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
6925 bfd_boolean is_tu_index
;
6926 struct cu_tu_set
*this_set
= NULL
;
6928 unsigned char *prow
;
6930 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
6934 warn (_("Section %s too small for offset and size tables\n"),
6941 printf (_(" Offset table\n"));
6942 printf (" slot %-16s ",
6943 is_tu_index
? _("signature") : _("dwo_id"));
6950 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
6956 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
6963 for (j
= 0; j
< ncols
; j
++)
6965 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6966 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
6971 for (i
= 0; i
< nslots
; i
++)
6973 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
6975 SAFE_BYTE_GET (row
, pi
, 4, limit
);
6978 /* PR 17531: file: a05f6ab3. */
6981 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
6987 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
6989 prow
= poffsets
+ (row
- 1) * ncols
* 4;
6992 printf (_(" [%3d] 0x%s"),
6993 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6994 buf
, sizeof (buf
)));
6995 for (j
= 0; j
< ncols
; j
++)
6997 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
6999 printf (" %8d", val
);
7002 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7004 /* PR 17531: file: 10796eb3. */
7005 if (dw_sect
>= DW_SECT_MAX
)
7006 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7008 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
7024 printf (_(" Size table\n"));
7025 printf (" slot %-16s ",
7026 is_tu_index
? _("signature") : _("dwo_id"));
7029 for (j
= 0; j
< ncols
; j
++)
7031 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
7033 printf (" %8s", get_DW_SECT_short_name (val
));
7039 for (i
= 0; i
< nslots
; i
++)
7041 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
7043 SAFE_BYTE_GET (row
, pi
, 4, limit
);
7046 prow
= psizes
+ (row
- 1) * ncols
* 4;
7049 printf (_(" [%3d] 0x%s"),
7050 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7051 buf
, sizeof (buf
)));
7053 for (j
= 0; j
< ncols
; j
++)
7055 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
7057 printf (" %8d", val
);
7060 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7061 if (dw_sect
>= DW_SECT_MAX
)
7062 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7064 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
7076 else if (do_display
)
7077 printf (_(" Unsupported version (%d)\n"), version
);
7085 /* Load the CU and TU indexes if present. This will build a list of
7086 section sets that we can use to associate a .debug_info.dwo section
7087 with its associated .debug_abbrev.dwo section in a .dwp file. */
7090 load_cu_tu_indexes (void *file
)
7092 /* If we have already loaded (or tried to load) the CU and TU indexes
7093 then do not bother to repeat the task. */
7094 if (cu_tu_indexes_read
)
7097 if (load_debug_section (dwp_cu_index
, file
))
7098 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
7100 if (load_debug_section (dwp_tu_index
, file
))
7101 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
7103 cu_tu_indexes_read
= 1;
7106 /* Find the set of sections that includes section SHNDX. */
7109 find_cu_tu_set (void *file
, unsigned int shndx
)
7113 load_cu_tu_indexes (file
);
7115 /* Find SHNDX in the shndx pool. */
7116 for (i
= 0; i
< shndx_pool_used
; i
++)
7117 if (shndx_pool
[i
] == shndx
)
7120 if (i
>= shndx_pool_used
)
7123 /* Now backup to find the first entry in the set. */
7124 while (i
> 0 && shndx_pool
[i
- 1] != 0)
7127 return shndx_pool
+ i
;
7130 /* Display a .debug_cu_index or .debug_tu_index section. */
7133 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
7135 return process_cu_tu_index (section
, 1);
7139 display_debug_not_supported (struct dwarf_section
*section
,
7140 void *file ATTRIBUTE_UNUSED
)
7142 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7148 /* Like malloc, but takes two parameters.
7149 Note: does *not* initialise the allocated memory to zero. */
7151 cmalloc (size_t nmemb
, size_t size
)
7153 /* Check for overflow. */
7154 if (nmemb
>= ~(size_t) 0 / size
)
7157 return xmalloc (nmemb
* size
);
7160 /* Like xcalloc, but verifies that the first paramer is not too large. */
7162 xcalloc2 (size_t nmemb
, size_t size
)
7164 /* Check for overflow. */
7165 if (nmemb
>= ~(size_t) 0 / size
)
7168 return xcalloc (nmemb
, size
);
7171 /* Like xmalloc, but takes two parameters.
7172 Note: does *not* initialise the allocated memory to zero. */
7174 xcmalloc (size_t nmemb
, size_t size
)
7176 /* Check for overflow. */
7177 if (nmemb
>= ~(size_t) 0 / size
)
7180 return xmalloc (nmemb
* size
);
7183 /* Like xrealloc, but takes three parameters.
7184 Note: does *not* initialise any new memory to zero. */
7186 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
7188 /* Check for overflow. */
7189 if (nmemb
>= ~(size_t) 0 / size
)
7192 return xrealloc (ptr
, nmemb
* size
);
7196 free_debug_memory (void)
7202 for (i
= 0; i
< max
; i
++)
7203 free_debug_section ((enum dwarf_section_display_enum
) i
);
7205 if (debug_information
!= NULL
)
7207 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
7209 for (i
= 0; i
< num_debug_info_entries
; i
++)
7211 if (!debug_information
[i
].max_loc_offsets
)
7213 free (debug_information
[i
].loc_offsets
);
7214 free (debug_information
[i
].have_frame_base
);
7216 if (!debug_information
[i
].max_range_lists
)
7217 free (debug_information
[i
].range_lists
);
7220 free (debug_information
);
7221 debug_information
= NULL
;
7222 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
7227 dwarf_select_sections_by_names (const char *names
)
7231 const char * option
;
7235 debug_dump_long_opts
;
7237 static const debug_dump_long_opts opts_table
[] =
7239 /* Please keep this table alpha- sorted. */
7240 { "Ranges", & do_debug_ranges
, 1 },
7241 { "abbrev", & do_debug_abbrevs
, 1 },
7242 { "addr", & do_debug_addr
, 1 },
7243 { "aranges", & do_debug_aranges
, 1 },
7244 { "cu_index", & do_debug_cu_index
, 1 },
7245 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
7246 { "frames", & do_debug_frames
, 1 },
7247 { "frames-interp", & do_debug_frames_interp
, 1 },
7248 /* The special .gdb_index section. */
7249 { "gdb_index", & do_gdb_index
, 1 },
7250 { "info", & do_debug_info
, 1 },
7251 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
7252 { "loc", & do_debug_loc
, 1 },
7253 { "macro", & do_debug_macinfo
, 1 },
7254 { "pubnames", & do_debug_pubnames
, 1 },
7255 { "pubtypes", & do_debug_pubtypes
, 1 },
7256 /* This entry is for compatability
7257 with earlier versions of readelf. */
7258 { "ranges", & do_debug_aranges
, 1 },
7259 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
7260 { "str", & do_debug_str
, 1 },
7261 /* These trace_* sections are used by Itanium VMS. */
7262 { "trace_abbrev", & do_trace_abbrevs
, 1 },
7263 { "trace_aranges", & do_trace_aranges
, 1 },
7264 { "trace_info", & do_trace_info
, 1 },
7273 const debug_dump_long_opts
* entry
;
7275 for (entry
= opts_table
; entry
->option
; entry
++)
7277 size_t len
= strlen (entry
->option
);
7279 if (strncmp (p
, entry
->option
, len
) == 0
7280 && (p
[len
] == ',' || p
[len
] == '\0'))
7282 * entry
->variable
|= entry
->val
;
7284 /* The --debug-dump=frames-interp option also
7285 enables the --debug-dump=frames option. */
7286 if (do_debug_frames_interp
)
7287 do_debug_frames
= 1;
7294 if (entry
->option
== NULL
)
7296 warn (_("Unrecognized debug option '%s'\n"), p
);
7297 p
= strchr (p
, ',');
7308 dwarf_select_sections_by_letters (const char *letters
)
7310 unsigned int lindex
= 0;
7312 while (letters
[lindex
])
7313 switch (letters
[lindex
++])
7320 do_debug_abbrevs
= 1;
7324 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
7328 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
7332 do_debug_pubnames
= 1;
7336 do_debug_pubtypes
= 1;
7340 do_debug_aranges
= 1;
7344 do_debug_ranges
= 1;
7348 do_debug_frames_interp
= 1;
7350 do_debug_frames
= 1;
7354 do_debug_macinfo
= 1;
7366 warn (_("Unrecognized debug option '%s'\n"), optarg
);
7372 dwarf_select_sections_all (void)
7375 do_debug_abbrevs
= 1;
7376 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
7377 do_debug_pubnames
= 1;
7378 do_debug_pubtypes
= 1;
7379 do_debug_aranges
= 1;
7380 do_debug_ranges
= 1;
7381 do_debug_frames
= 1;
7382 do_debug_macinfo
= 1;
7387 do_trace_abbrevs
= 1;
7388 do_trace_aranges
= 1;
7390 do_debug_cu_index
= 1;
7393 struct dwarf_section_display debug_displays
[] =
7395 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0, NULL
},
7396 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7397 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0, NULL
},
7398 display_debug_aranges
, &do_debug_aranges
, 1 },
7399 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0, NULL
},
7400 display_debug_frames
, &do_debug_frames
, 1 },
7401 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
, NULL
},
7402 display_debug_info
, &do_debug_info
, 1 },
7403 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0, NULL
},
7404 display_debug_lines
, &do_debug_lines
, 1 },
7405 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0, NULL
},
7406 display_debug_pubnames
, &do_debug_pubnames
, 0 },
7407 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0, NULL
},
7408 display_debug_gnu_pubnames
, &do_debug_pubnames
, 0 },
7409 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0, NULL
},
7410 display_debug_frames
, &do_debug_frames
, 1 },
7411 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0, NULL
},
7412 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7413 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0, NULL
},
7414 display_debug_macro
, &do_debug_macinfo
, 1 },
7415 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0, NULL
},
7416 display_debug_str
, &do_debug_str
, 0 },
7417 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0, NULL
},
7418 display_debug_loc
, &do_debug_loc
, 1 },
7419 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
},
7420 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
7421 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
},
7422 display_debug_gnu_pubnames
, &do_debug_pubtypes
, 0 },
7423 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0, NULL
},
7424 display_debug_ranges
, &do_debug_ranges
, 1 },
7425 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0, NULL
},
7426 display_debug_not_supported
, NULL
, 0 },
7427 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0, NULL
},
7428 display_debug_not_supported
, NULL
, 0 },
7429 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
, NULL
},
7430 display_debug_types
, &do_debug_info
, 1 },
7431 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0, NULL
},
7432 display_debug_not_supported
, NULL
, 0 },
7433 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7434 display_gdb_index
, &do_gdb_index
, 0 },
7435 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
, NULL
},
7436 display_trace_info
, &do_trace_info
, 1 },
7437 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0, NULL
},
7438 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
7439 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0, NULL
},
7440 display_debug_aranges
, &do_trace_aranges
, 0 },
7441 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
},
7442 display_debug_info
, &do_debug_info
, 1 },
7443 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7444 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7445 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
},
7446 display_debug_types
, &do_debug_info
, 1 },
7447 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7448 display_debug_lines
, &do_debug_lines
, 1 },
7449 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7450 display_debug_loc
, &do_debug_loc
, 1 },
7451 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7452 display_debug_macro
, &do_debug_macinfo
, 1 },
7453 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7454 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7455 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7456 display_debug_str
, &do_debug_str
, 1 },
7457 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0, NULL
},
7458 display_debug_str_offsets
, NULL
, 0 },
7459 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7460 display_debug_str_offsets
, NULL
, 0 },
7461 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0, NULL
},
7462 display_debug_addr
, &do_debug_addr
, 1 },
7463 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7464 display_cu_index
, &do_debug_cu_index
, 0 },
7465 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7466 display_cu_index
, &do_debug_cu_index
, 0 },