1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2014 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 debug_info
*debug_information
= NULL
;
42 /* Special value for num_debug_info_entries to indicate
43 that the .debug_info section could not be loaded/parsed. */
44 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
51 int do_debug_pubnames
;
52 int do_debug_pubtypes
;
56 int do_debug_frames_interp
;
65 int do_debug_cu_index
;
68 int dwarf_cutoff_level
= -1;
69 unsigned long dwarf_start_die
;
73 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
74 sections. For version 1 package files, each set is stored in SHNDX_POOL
75 as a zero-terminated list of section indexes comprising one set of debug
76 sections from a .dwo file. */
78 static int cu_tu_indexes_read
= 0;
79 static unsigned int *shndx_pool
= NULL
;
80 static unsigned int shndx_pool_size
= 0;
81 static unsigned int shndx_pool_used
= 0;
83 /* For version 2 package files, each set contains an array of section offsets
84 and an array of section sizes, giving the offset and size of the
85 contribution from a CU or TU within one of the debug sections.
86 When displaying debug info from a package file, we need to use these
87 tables to locate the corresponding contributions to each section. */
92 dwarf_vma section_offsets
[DW_SECT_MAX
];
93 size_t section_sizes
[DW_SECT_MAX
];
96 static int cu_count
= 0;
97 static int tu_count
= 0;
98 static struct cu_tu_set
*cu_sets
= NULL
;
99 static struct cu_tu_set
*tu_sets
= NULL
;
101 static void load_cu_tu_indexes (void *file
);
103 /* Values for do_debug_lines. */
104 #define FLAG_DEBUG_LINES_RAW 1
105 #define FLAG_DEBUG_LINES_DECODED 2
108 size_of_encoded_value (int encoding
)
110 switch (encoding
& 0x7)
113 case 0: return eh_addr_size
;
121 get_encoded_value (unsigned char **pdata
,
123 struct dwarf_section
*section
,
126 unsigned char * data
= * pdata
;
127 unsigned int size
= size_of_encoded_value (encoding
);
130 if (data
+ size
>= end
)
132 warn (_("Encoded value extends past end of section\n"));
137 /* PR 17512: file: 002-829853-0.004. */
140 warn (_("Encoded size of %d is too large to read\n"), size
);
145 /* PR 17512: file: 1085-5603-0.004. */
148 warn (_("Encoded size of 0 is too small to read\n"));
153 if (encoding
& DW_EH_PE_signed
)
154 val
= byte_get_signed (data
, size
);
156 val
= byte_get (data
, size
);
158 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
159 val
+= section
->address
+ (data
- section
->start
);
161 * pdata
= data
+ size
;
165 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
167 # define DWARF_VMA_FMT "ll"
168 # define DWARF_VMA_FMT_LONG "%16.16llx"
170 # define DWARF_VMA_FMT "I64"
171 # define DWARF_VMA_FMT_LONG "%016I64x"
174 # define DWARF_VMA_FMT "l"
175 # define DWARF_VMA_FMT_LONG "%16.16lx"
178 /* Convert a dwarf vma value into a string. Returns a pointer to a static
179 buffer containing the converted VALUE. The value is converted according
180 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
181 it specifies the maximum number of bytes to be displayed in the converted
182 value and FMTCH is ignored - hex is always used. */
185 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
187 /* As dwarf_vmatoa is used more then once in a printf call
188 for output, we are cycling through an fixed array of pointers
189 for return address. */
190 static int buf_pos
= 0;
191 static struct dwarf_vmatoa_buf
197 ret
= buf
[buf_pos
++].place
;
198 buf_pos
%= ARRAY_SIZE (buf
);
202 /* Printf does not have a way of specifiying a maximum field width for an
203 integer value, so we print the full value into a buffer and then select
204 the precision we need. */
205 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
208 return ret
+ (16 - 2 * num_bytes
);
214 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
215 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
220 static inline const char *
221 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
223 return dwarf_vmatoa_1 (fmtch
, value
, 0);
226 /* Print a dwarf_vma value (typically an address, offset or length) in
227 hexadecimal format, followed by a space. The length of the VALUE (and
228 hence the precision displayed) is determined by the NUM_BYTES parameter. */
231 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
233 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
236 /* Format a 64-bit value, given as two 32-bit values, in hex.
237 For reentrancy, this uses a buffer provided by the caller. */
240 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
241 unsigned int buf_len
)
246 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
249 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
250 snprintf (buf
+ len
, buf_len
- len
,
251 "%08" DWARF_VMA_FMT
"x", lvalue
);
257 /* Read in a LEB128 encoded value starting at address DATA.
258 If SIGN is true, return a signed LEB128 value.
259 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
260 No bytes will be read at address END or beyond. */
263 read_leb128 (unsigned char *data
,
264 unsigned int *length_return
,
266 const unsigned char * const end
)
268 dwarf_vma result
= 0;
269 unsigned int num_read
= 0;
270 unsigned int shift
= 0;
271 unsigned char byte
= 0;
278 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
281 if ((byte
& 0x80) == 0)
285 if (length_return
!= NULL
)
286 *length_return
= num_read
;
288 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
289 result
|= (dwarf_vma
) -1 << shift
;
294 /* Create a signed version to avoid painful typecasts. */
295 static inline dwarf_signed_vma
296 read_sleb128 (unsigned char * data
,
297 unsigned int * length_return
,
298 const unsigned char * const end
)
300 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
303 static inline dwarf_vma
304 read_uleb128 (unsigned char * data
,
305 unsigned int * length_return
,
306 const unsigned char * const end
)
308 return read_leb128 (data
, length_return
, FALSE
, end
);
311 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
314 int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
315 unsigned int amount = (AMOUNT); \
316 if (((PTR) + amount) >= (END)) \
319 amount = (END) - (PTR); \
323 if (amount == 0 || amount > 8) \
326 VAL = byte_get ((PTR), amount); \
330 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
333 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
338 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
341 unsigned int amount = (AMOUNT); \
342 if (((PTR) + amount) >= (END)) \
345 amount = (END) - (PTR); \
350 VAL = byte_get_signed ((PTR), amount); \
356 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
359 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
364 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
367 if (((PTR) + 8) <= (END)) \
369 byte_get_64 ((PTR), (HIGH), (LOW)); \
373 * (LOW) = * (HIGH) = 0; \
378 typedef struct State_Machine_Registers
386 unsigned char op_index
;
387 unsigned char end_sequence
;
388 /* This variable hold the number of the last entry seen
389 in the File Table. */
390 unsigned int last_file_entry
;
393 static SMR state_machine_regs
;
396 reset_state_machine (int is_stmt
)
398 state_machine_regs
.address
= 0;
399 state_machine_regs
.op_index
= 0;
400 state_machine_regs
.file
= 1;
401 state_machine_regs
.line
= 1;
402 state_machine_regs
.column
= 0;
403 state_machine_regs
.is_stmt
= is_stmt
;
404 state_machine_regs
.basic_block
= 0;
405 state_machine_regs
.end_sequence
= 0;
406 state_machine_regs
.last_file_entry
= 0;
409 /* Handled an extend line op.
410 Returns the number of bytes read. */
413 process_extended_line_op (unsigned char * data
,
417 unsigned char op_code
;
418 unsigned int bytes_read
;
421 unsigned char *orig_data
= data
;
424 len
= read_uleb128 (data
, & bytes_read
, end
);
427 if (len
== 0 || data
== end
|| len
> (uintptr_t) (end
- data
))
429 warn (_("Badly formed extended line op encountered!\n"));
436 printf (_(" Extended opcode %d: "), op_code
);
440 case DW_LNE_end_sequence
:
441 printf (_("End of Sequence\n\n"));
442 reset_state_machine (is_stmt
);
445 case DW_LNE_set_address
:
446 /* PR 17512: file: 002-100480-0.004. */
447 if (len
- bytes_read
- 1 > 8)
448 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
449 len
- bytes_read
- 1);
450 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
451 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
452 state_machine_regs
.address
= adr
;
453 state_machine_regs
.op_index
= 0;
456 case DW_LNE_define_file
:
457 printf (_("define new File Table entry\n"));
458 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
459 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
462 data
+= strnlen ((char *) data
, end
- data
) + 1;
463 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
465 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
467 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
469 printf ("%s\n\n", name
);
471 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
472 warn (_("DW_LNE_define_file: Bad opcode length\n"));
475 case DW_LNE_set_discriminator
:
476 printf (_("set Discriminator to %s\n"),
477 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
481 case DW_LNE_HP_negate_is_UV_update
:
482 printf ("DW_LNE_HP_negate_is_UV_update\n");
484 case DW_LNE_HP_push_context
:
485 printf ("DW_LNE_HP_push_context\n");
487 case DW_LNE_HP_pop_context
:
488 printf ("DW_LNE_HP_pop_context\n");
490 case DW_LNE_HP_set_file_line_column
:
491 printf ("DW_LNE_HP_set_file_line_column\n");
493 case DW_LNE_HP_set_routine_name
:
494 printf ("DW_LNE_HP_set_routine_name\n");
496 case DW_LNE_HP_set_sequence
:
497 printf ("DW_LNE_HP_set_sequence\n");
499 case DW_LNE_HP_negate_post_semantics
:
500 printf ("DW_LNE_HP_negate_post_semantics\n");
502 case DW_LNE_HP_negate_function_exit
:
503 printf ("DW_LNE_HP_negate_function_exit\n");
505 case DW_LNE_HP_negate_front_end_logical
:
506 printf ("DW_LNE_HP_negate_front_end_logical\n");
508 case DW_LNE_HP_define_proc
:
509 printf ("DW_LNE_HP_define_proc\n");
511 case DW_LNE_HP_source_file_correlation
:
513 unsigned char *edata
= data
+ len
- bytes_read
- 1;
515 printf ("DW_LNE_HP_source_file_correlation\n");
521 opc
= read_uleb128 (data
, & bytes_read
, edata
);
526 case DW_LNE_HP_SFC_formfeed
:
527 printf (" DW_LNE_HP_SFC_formfeed\n");
529 case DW_LNE_HP_SFC_set_listing_line
:
530 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
532 read_uleb128 (data
, & bytes_read
, edata
)));
535 case DW_LNE_HP_SFC_associate
:
536 printf (" DW_LNE_HP_SFC_associate ");
539 read_uleb128 (data
, & bytes_read
, edata
)));
543 read_uleb128 (data
, & bytes_read
, edata
)));
547 read_uleb128 (data
, & bytes_read
, edata
)));
551 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
561 unsigned int rlen
= len
- bytes_read
- 1;
563 if (op_code
>= DW_LNE_lo_user
564 /* The test against DW_LNW_hi_user is redundant due to
565 the limited range of the unsigned char data type used
567 /*&& op_code <= DW_LNE_hi_user*/)
568 printf (_("user defined: "));
570 printf (_("UNKNOWN: "));
571 printf (_("length %d ["), rlen
);
573 printf (" %02x", *data
++);
582 static const unsigned char *
583 fetch_indirect_string (dwarf_vma offset
)
585 struct dwarf_section
*section
= &debug_displays
[str
].section
;
587 if (section
->start
== NULL
)
588 return (const unsigned char *) _("<no .debug_str section>");
590 if (offset
> section
->size
)
592 warn (_("DW_FORM_strp offset too big: %s\n"),
593 dwarf_vmatoa ("x", offset
));
594 return (const unsigned char *) _("<offset is too big>");
597 return (const unsigned char *) section
->start
+ offset
;
601 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
602 dwarf_vma offset_size
, int dwo
)
604 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
605 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
606 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
607 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
608 dwarf_vma index_offset
= idx
* offset_size
;
609 dwarf_vma str_offset
;
611 if (index_section
->start
== NULL
)
612 return (dwo
? _("<no .debug_str_offsets.dwo section>")
613 : _("<no .debug_str_offsets section>"));
615 if (this_set
!= NULL
)
616 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
617 if (index_offset
> index_section
->size
)
619 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
620 dwarf_vmatoa ("x", index_offset
));
621 return _("<index offset is too big>");
624 if (str_section
->start
== NULL
)
625 return (dwo
? _("<no .debug_str.dwo section>")
626 : _("<no .debug_str section>"));
628 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
629 str_offset
-= str_section
->address
;
630 if (str_offset
> str_section
->size
)
632 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
633 dwarf_vmatoa ("x", str_offset
));
634 return _("<indirect index offset is too big>");
637 return (const char *) str_section
->start
+ str_offset
;
641 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
643 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
645 if (section
->start
== NULL
)
646 return (_("<no .debug_addr section>"));
648 if (offset
+ bytes
> section
->size
)
650 warn (_("Offset into section %s too big: %s\n"),
651 section
->name
, dwarf_vmatoa ("x", offset
));
652 return "<offset too big>";
655 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
659 /* FIXME: There are better and more efficient ways to handle
660 these structures. For now though, I just want something that
661 is simple to implement. */
662 typedef struct abbrev_attr
664 unsigned long attribute
;
666 struct abbrev_attr
*next
;
670 typedef struct abbrev_entry
675 struct abbrev_attr
*first_attr
;
676 struct abbrev_attr
*last_attr
;
677 struct abbrev_entry
*next
;
681 static abbrev_entry
*first_abbrev
= NULL
;
682 static abbrev_entry
*last_abbrev
= NULL
;
689 for (abbrv
= first_abbrev
; abbrv
;)
691 abbrev_entry
*next_abbrev
= abbrv
->next
;
694 for (attr
= abbrv
->first_attr
; attr
;)
696 abbrev_attr
*next_attr
= attr
->next
;
706 last_abbrev
= first_abbrev
= NULL
;
710 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
714 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
719 entry
->entry
= number
;
721 entry
->children
= children
;
722 entry
->first_attr
= NULL
;
723 entry
->last_attr
= NULL
;
726 if (first_abbrev
== NULL
)
727 first_abbrev
= entry
;
729 last_abbrev
->next
= entry
;
735 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
739 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
744 attr
->attribute
= attribute
;
748 if (last_abbrev
->first_attr
== NULL
)
749 last_abbrev
->first_attr
= attr
;
751 last_abbrev
->last_attr
->next
= attr
;
753 last_abbrev
->last_attr
= attr
;
756 /* Processes the (partial) contents of a .debug_abbrev section.
757 Returns NULL if the end of the section was encountered.
758 Returns the address after the last byte read if the end of
759 an abbreviation set was found. */
761 static unsigned char *
762 process_abbrev_section (unsigned char *start
, unsigned char *end
)
764 if (first_abbrev
!= NULL
)
769 unsigned int bytes_read
;
772 unsigned long attribute
;
775 entry
= read_uleb128 (start
, & bytes_read
, end
);
778 /* A single zero is supposed to end the section according
779 to the standard. If there's more, then signal that to
786 tag
= read_uleb128 (start
, & bytes_read
, end
);
793 add_abbrev (entry
, tag
, children
);
799 attribute
= read_uleb128 (start
, & bytes_read
, end
);
804 form
= read_uleb128 (start
, & bytes_read
, end
);
809 add_abbrev_attr (attribute
, form
);
811 while (attribute
!= 0);
814 /* Report the missing single zero which ends the section. */
815 error (_(".debug_abbrev section not zero terminated\n"));
821 get_TAG_name (unsigned long tag
)
823 const char *name
= get_DW_TAG_name ((unsigned int)tag
);
827 static char buffer
[100];
829 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
837 get_FORM_name (unsigned long form
)
842 return "DW_FORM value: 0";
844 name
= get_DW_FORM_name (form
);
847 static char buffer
[100];
849 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
856 static unsigned char *
857 display_block (unsigned char *data
,
859 const unsigned char * const end
)
863 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length
));
865 return (unsigned char *) end
;
867 maxlen
= (dwarf_vma
) (end
- data
);
868 length
= length
> maxlen
? maxlen
: length
;
871 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
877 decode_location_expression (unsigned char * data
,
878 unsigned int pointer_size
,
879 unsigned int offset_size
,
883 struct dwarf_section
* section
)
886 unsigned int bytes_read
;
888 dwarf_signed_vma svalue
;
889 unsigned char *end
= data
+ length
;
890 int need_frame_base
= 0;
899 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
900 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
903 printf ("DW_OP_deref");
906 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
907 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
910 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
911 printf ("DW_OP_const1s: %ld", (long) svalue
);
914 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
915 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
918 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
919 printf ("DW_OP_const2s: %ld", (long) svalue
);
922 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
923 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
926 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
927 printf ("DW_OP_const4s: %ld", (long) svalue
);
930 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
931 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
932 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
933 printf ("%lu", (unsigned long) uvalue
);
936 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
937 printf ("DW_OP_const8s: %ld ", (long) svalue
);
938 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
939 printf ("%ld", (long) svalue
);
942 printf ("DW_OP_constu: %s",
943 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
947 printf ("DW_OP_consts: %s",
948 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
952 printf ("DW_OP_dup");
955 printf ("DW_OP_drop");
958 printf ("DW_OP_over");
961 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
962 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
965 printf ("DW_OP_swap");
968 printf ("DW_OP_rot");
971 printf ("DW_OP_xderef");
974 printf ("DW_OP_abs");
977 printf ("DW_OP_and");
980 printf ("DW_OP_div");
983 printf ("DW_OP_minus");
986 printf ("DW_OP_mod");
989 printf ("DW_OP_mul");
992 printf ("DW_OP_neg");
995 printf ("DW_OP_not");
1001 printf ("DW_OP_plus");
1003 case DW_OP_plus_uconst
:
1004 printf ("DW_OP_plus_uconst: %s",
1005 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1009 printf ("DW_OP_shl");
1012 printf ("DW_OP_shr");
1015 printf ("DW_OP_shra");
1018 printf ("DW_OP_xor");
1021 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1022 printf ("DW_OP_bra: %ld", (long) svalue
);
1025 printf ("DW_OP_eq");
1028 printf ("DW_OP_ge");
1031 printf ("DW_OP_gt");
1034 printf ("DW_OP_le");
1037 printf ("DW_OP_lt");
1040 printf ("DW_OP_ne");
1043 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1044 printf ("DW_OP_skip: %ld", (long) svalue
);
1079 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1114 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1115 regname (op
- DW_OP_reg0
, 1));
1150 printf ("DW_OP_breg%d (%s): %s",
1152 regname (op
- DW_OP_breg0
, 1),
1153 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1158 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1160 printf ("DW_OP_regx: %s (%s)",
1161 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1164 need_frame_base
= 1;
1165 printf ("DW_OP_fbreg: %s",
1166 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1170 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1172 printf ("DW_OP_bregx: %s (%s) %s",
1173 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1174 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1178 printf ("DW_OP_piece: %s",
1179 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1182 case DW_OP_deref_size
:
1183 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1184 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1186 case DW_OP_xderef_size
:
1187 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1188 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1191 printf ("DW_OP_nop");
1194 /* DWARF 3 extensions. */
1195 case DW_OP_push_object_address
:
1196 printf ("DW_OP_push_object_address");
1199 /* XXX: Strictly speaking for 64-bit DWARF3 files
1200 this ought to be an 8-byte wide computation. */
1201 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1202 printf ("DW_OP_call2: <0x%s>",
1203 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1206 /* XXX: Strictly speaking for 64-bit DWARF3 files
1207 this ought to be an 8-byte wide computation. */
1208 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1209 printf ("DW_OP_call4: <0x%s>",
1210 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1212 case DW_OP_call_ref
:
1213 /* XXX: Strictly speaking for 64-bit DWARF3 files
1214 this ought to be an 8-byte wide computation. */
1215 if (dwarf_version
== -1)
1217 printf (_("(DW_OP_call_ref in frame info)"));
1218 /* No way to tell where the next op is, so just bail. */
1219 return need_frame_base
;
1221 if (dwarf_version
== 2)
1223 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1227 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1229 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1231 case DW_OP_form_tls_address
:
1232 printf ("DW_OP_form_tls_address");
1234 case DW_OP_call_frame_cfa
:
1235 printf ("DW_OP_call_frame_cfa");
1237 case DW_OP_bit_piece
:
1238 printf ("DW_OP_bit_piece: ");
1239 printf (_("size: %s "),
1240 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1242 printf (_("offset: %s "),
1243 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1247 /* DWARF 4 extensions. */
1248 case DW_OP_stack_value
:
1249 printf ("DW_OP_stack_value");
1252 case DW_OP_implicit_value
:
1253 printf ("DW_OP_implicit_value");
1254 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1256 data
= display_block (data
, uvalue
, end
);
1259 /* GNU extensions. */
1260 case DW_OP_GNU_push_tls_address
:
1261 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1263 case DW_OP_GNU_uninit
:
1264 printf ("DW_OP_GNU_uninit");
1265 /* FIXME: Is there data associated with this OP ? */
1267 case DW_OP_GNU_encoded_addr
:
1274 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1276 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1277 print_dwarf_vma (addr
, pointer_size
);
1280 case DW_OP_GNU_implicit_pointer
:
1281 /* XXX: Strictly speaking for 64-bit DWARF3 files
1282 this ought to be an 8-byte wide computation. */
1283 if (dwarf_version
== -1)
1285 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1286 /* No way to tell where the next op is, so just bail. */
1287 return need_frame_base
;
1289 if (dwarf_version
== 2)
1291 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1295 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1297 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1298 dwarf_vmatoa ("x", uvalue
),
1299 dwarf_vmatoa ("d", read_sleb128 (data
,
1300 &bytes_read
, end
)));
1303 case DW_OP_GNU_entry_value
:
1304 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1306 printf ("DW_OP_GNU_entry_value: (");
1307 if (decode_location_expression (data
, pointer_size
, offset_size
,
1308 dwarf_version
, uvalue
,
1309 cu_offset
, section
))
1310 need_frame_base
= 1;
1316 case DW_OP_GNU_const_type
:
1317 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1319 printf ("DW_OP_GNU_const_type: <0x%s> ",
1320 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1321 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1322 data
= display_block (data
, uvalue
, end
);
1324 case DW_OP_GNU_regval_type
:
1325 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1327 printf ("DW_OP_GNU_regval_type: %s (%s)",
1328 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1329 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1331 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1333 case DW_OP_GNU_deref_type
:
1334 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1335 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue
);
1336 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1338 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1340 case DW_OP_GNU_convert
:
1341 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1343 printf ("DW_OP_GNU_convert <0x%s>",
1344 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1346 case DW_OP_GNU_reinterpret
:
1347 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1349 printf ("DW_OP_GNU_reinterpret <0x%s>",
1350 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1352 case DW_OP_GNU_parameter_ref
:
1353 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1354 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1355 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1357 case DW_OP_GNU_addr_index
:
1358 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1360 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1362 case DW_OP_GNU_const_index
:
1363 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1365 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1368 /* HP extensions. */
1369 case DW_OP_HP_is_value
:
1370 printf ("DW_OP_HP_is_value");
1371 /* FIXME: Is there data associated with this OP ? */
1373 case DW_OP_HP_fltconst4
:
1374 printf ("DW_OP_HP_fltconst4");
1375 /* FIXME: Is there data associated with this OP ? */
1377 case DW_OP_HP_fltconst8
:
1378 printf ("DW_OP_HP_fltconst8");
1379 /* FIXME: Is there data associated with this OP ? */
1381 case DW_OP_HP_mod_range
:
1382 printf ("DW_OP_HP_mod_range");
1383 /* FIXME: Is there data associated with this OP ? */
1385 case DW_OP_HP_unmod_range
:
1386 printf ("DW_OP_HP_unmod_range");
1387 /* FIXME: Is there data associated with this OP ? */
1390 printf ("DW_OP_HP_tls");
1391 /* FIXME: Is there data associated with this OP ? */
1394 /* PGI (STMicroelectronics) extensions. */
1395 case DW_OP_PGI_omp_thread_num
:
1396 /* Pushes the thread number for the current thread as it would be
1397 returned by the standard OpenMP library function:
1398 omp_get_thread_num(). The "current thread" is the thread for
1399 which the expression is being evaluated. */
1400 printf ("DW_OP_PGI_omp_thread_num");
1404 if (op
>= DW_OP_lo_user
1405 && op
<= DW_OP_hi_user
)
1406 printf (_("(User defined location op)"));
1408 printf (_("(Unknown location op)"));
1409 /* No way to tell where the next op is, so just bail. */
1410 return need_frame_base
;
1413 /* Separate the ops. */
1418 return need_frame_base
;
1421 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1422 This is used for DWARF package files. */
1424 static struct cu_tu_set
*
1425 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1427 struct cu_tu_set
*p
;
1429 unsigned int dw_sect
;
1435 dw_sect
= DW_SECT_TYPES
;
1441 dw_sect
= DW_SECT_INFO
;
1445 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1453 /* Add INC to HIGH_BITS:LOW_BITS. */
1455 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1457 dwarf_vma tmp
= * low_bits
;
1461 /* FIXME: There is probably a better way of handling this:
1463 We need to cope with dwarf_vma being a 32-bit or 64-bit
1464 type. Plus regardless of its size LOW_BITS is meant to
1465 only hold 32-bits, so if there is overflow or wrap around
1466 we must propagate into HIGH_BITS. */
1467 if (tmp
< * low_bits
)
1471 else if (sizeof (tmp
) > 8
1481 static unsigned char *
1482 read_and_display_attr_value (unsigned long attribute
,
1484 unsigned char * data
,
1485 unsigned char * end
,
1486 dwarf_vma cu_offset
,
1487 dwarf_vma pointer_size
,
1488 dwarf_vma offset_size
,
1490 debug_info
* debug_info_p
,
1492 struct dwarf_section
* section
,
1493 struct cu_tu_set
* this_set
)
1495 dwarf_vma uvalue
= 0;
1496 unsigned char *block_start
= NULL
;
1497 unsigned char * orig_data
= data
;
1498 unsigned int bytes_read
;
1500 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
1502 warn (_("Corrupt attribute\n"));
1511 case DW_FORM_ref_addr
:
1512 if (dwarf_version
== 2)
1513 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1514 else if (dwarf_version
== 3 || dwarf_version
== 4)
1515 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1517 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1522 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1526 case DW_FORM_sec_offset
:
1527 case DW_FORM_GNU_ref_alt
:
1528 case DW_FORM_GNU_strp_alt
:
1529 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1532 case DW_FORM_flag_present
:
1539 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1544 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1549 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1553 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1557 case DW_FORM_GNU_str_index
:
1558 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1562 case DW_FORM_ref_udata
:
1564 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1568 case DW_FORM_indirect
:
1569 form
= read_uleb128 (data
, & bytes_read
, end
);
1572 printf (" %s", get_FORM_name (form
));
1573 return read_and_display_attr_value (attribute
, form
, data
, end
,
1574 cu_offset
, pointer_size
,
1575 offset_size
, dwarf_version
,
1576 debug_info_p
, do_loc
,
1578 case DW_FORM_GNU_addr_index
:
1579 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1586 case DW_FORM_ref_addr
:
1588 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue
));
1591 case DW_FORM_GNU_ref_alt
:
1593 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue
));
1599 case DW_FORM_ref_udata
:
1601 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1606 case DW_FORM_sec_offset
:
1608 printf (" 0x%s", dwarf_vmatoa ("x", uvalue
));
1611 case DW_FORM_flag_present
:
1618 printf (" %s", dwarf_vmatoa ("d", uvalue
));
1625 dwarf_vma high_bits
;
1629 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1631 if (form
== DW_FORM_ref8
)
1632 add64 (& high_bits
, & utmp
, cu_offset
);
1634 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1637 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1638 && num_debug_info_entries
== 0)
1640 if (sizeof (uvalue
) == 8)
1641 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1643 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1649 case DW_FORM_string
:
1651 printf (" %.*s", (int) (end
- data
), data
);
1652 data
+= strnlen ((char *) data
, end
- data
) + 1;
1656 case DW_FORM_exprloc
:
1657 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1658 block_start
= data
+ bytes_read
;
1659 if (block_start
>= end
)
1661 warn (_("Block ends prematurely\n"));
1665 /* PR 17512: file: 008-103549-0.001:0.1. */
1666 if (block_start
+ uvalue
> end
)
1668 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1669 uvalue
= end
- block_start
;
1672 data
= block_start
+ uvalue
;
1674 data
= display_block (block_start
, uvalue
, end
);
1677 case DW_FORM_block1
:
1678 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1679 block_start
= data
+ 1;
1680 if (block_start
>= end
)
1682 warn (_("Block ends prematurely\n"));
1686 if (block_start
+ uvalue
> end
)
1688 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1689 uvalue
= end
- block_start
;
1692 data
= block_start
+ uvalue
;
1694 data
= display_block (block_start
, uvalue
, end
);
1697 case DW_FORM_block2
:
1698 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1699 block_start
= data
+ 2;
1700 if (block_start
>= end
)
1702 warn (_("Block ends prematurely\n"));
1706 if (block_start
+ uvalue
> end
)
1708 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1709 uvalue
= end
- block_start
;
1712 data
= block_start
+ uvalue
;
1714 data
= display_block (block_start
, uvalue
, end
);
1717 case DW_FORM_block4
:
1718 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1719 block_start
= data
+ 4;
1720 /* PR 17512: file: 3371-3907-0.004. */
1721 if (block_start
>= end
)
1723 warn (_("Block ends prematurely\n"));
1727 if (block_start
+ uvalue
> end
)
1729 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1730 uvalue
= end
- block_start
;
1733 data
= block_start
+ uvalue
;
1735 data
= display_block (block_start
, uvalue
, end
);
1740 printf (_(" (indirect string, offset: 0x%s): %s"),
1741 dwarf_vmatoa ("x", uvalue
),
1742 fetch_indirect_string (uvalue
));
1745 case DW_FORM_GNU_str_index
:
1748 const char *suffix
= strrchr (section
->name
, '.');
1749 int dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? 1 : 0;
1751 printf (_(" (indexed string: 0x%s): %s"),
1752 dwarf_vmatoa ("x", uvalue
),
1753 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
1757 case DW_FORM_GNU_strp_alt
:
1759 printf (_(" (alt indirect string, offset: 0x%s)"),
1760 dwarf_vmatoa ("x", uvalue
));
1763 case DW_FORM_indirect
:
1764 /* Handled above. */
1767 case DW_FORM_ref_sig8
:
1770 dwarf_vma high_bits
;
1773 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1774 printf (" signature: 0x%s",
1775 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
1780 case DW_FORM_GNU_addr_index
:
1782 printf (_(" (addr_index: 0x%s): %s"),
1783 dwarf_vmatoa ("x", uvalue
),
1784 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
1788 warn (_("Unrecognized form: %lu\n"), form
);
1792 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1793 && num_debug_info_entries
== 0
1794 && debug_info_p
!= NULL
)
1798 case DW_AT_frame_base
:
1799 have_frame_base
= 1;
1800 case DW_AT_location
:
1801 case DW_AT_string_length
:
1802 case DW_AT_return_addr
:
1803 case DW_AT_data_member_location
:
1804 case DW_AT_vtable_elem_location
:
1806 case DW_AT_static_link
:
1807 case DW_AT_use_location
:
1808 case DW_AT_GNU_call_site_value
:
1809 case DW_AT_GNU_call_site_data_value
:
1810 case DW_AT_GNU_call_site_target
:
1811 case DW_AT_GNU_call_site_target_clobbered
:
1812 if ((dwarf_version
< 4
1813 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1814 || form
== DW_FORM_sec_offset
)
1816 /* Process location list. */
1817 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1818 unsigned int num
= debug_info_p
->num_loc_offsets
;
1820 if (lmax
== 0 || num
>= lmax
)
1823 debug_info_p
->loc_offsets
= (dwarf_vma
*)
1824 xcrealloc (debug_info_p
->loc_offsets
,
1825 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1826 debug_info_p
->have_frame_base
= (int *)
1827 xcrealloc (debug_info_p
->have_frame_base
,
1828 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1829 debug_info_p
->max_loc_offsets
= lmax
;
1831 if (this_set
!= NULL
)
1832 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
1833 debug_info_p
->loc_offsets
[num
] = uvalue
;
1834 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1835 debug_info_p
->num_loc_offsets
++;
1840 if (need_base_address
)
1841 debug_info_p
->base_address
= uvalue
;
1844 case DW_AT_GNU_addr_base
:
1845 debug_info_p
->addr_base
= uvalue
;
1848 case DW_AT_GNU_ranges_base
:
1849 debug_info_p
->ranges_base
= uvalue
;
1853 if ((dwarf_version
< 4
1854 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1855 || form
== DW_FORM_sec_offset
)
1857 /* Process range list. */
1858 unsigned int lmax
= debug_info_p
->max_range_lists
;
1859 unsigned int num
= debug_info_p
->num_range_lists
;
1861 if (lmax
== 0 || num
>= lmax
)
1864 debug_info_p
->range_lists
= (dwarf_vma
*)
1865 xcrealloc (debug_info_p
->range_lists
,
1866 lmax
, sizeof (*debug_info_p
->range_lists
));
1867 debug_info_p
->max_range_lists
= lmax
;
1869 debug_info_p
->range_lists
[num
] = uvalue
;
1870 debug_info_p
->num_range_lists
++;
1879 if (do_loc
|| attribute
== 0)
1882 /* For some attributes we can display further information. */
1889 case DW_INL_not_inlined
:
1890 printf (_("(not inlined)"));
1892 case DW_INL_inlined
:
1893 printf (_("(inlined)"));
1895 case DW_INL_declared_not_inlined
:
1896 printf (_("(declared as inline but ignored)"));
1898 case DW_INL_declared_inlined
:
1899 printf (_("(declared as inline and inlined)"));
1902 printf (_(" (Unknown inline attribute value: %s)"),
1903 dwarf_vmatoa ("x", uvalue
));
1908 case DW_AT_language
:
1912 /* Ordered by the numeric value of these constants. */
1913 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1914 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1915 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1916 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1917 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1918 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1919 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1920 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1921 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1922 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1923 /* DWARF 2.1 values. */
1924 case DW_LANG_Java
: printf ("(Java)"); break;
1925 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1926 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1927 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1928 /* DWARF 3 values. */
1929 case DW_LANG_PLI
: printf ("(PLI)"); break;
1930 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1931 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1932 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1933 case DW_LANG_D
: printf ("(D)"); break;
1934 /* DWARF 4 values. */
1935 case DW_LANG_Python
: printf ("(Python)"); break;
1936 /* DWARF 5 values. */
1937 case DW_LANG_Go
: printf ("(Go)"); break;
1938 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
1939 case DW_LANG_C11
: printf ("(C11)"); break;
1940 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
1941 /* MIPS extension. */
1942 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1943 /* UPC extension. */
1944 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1946 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1947 printf (_("(implementation defined: %s)"),
1948 dwarf_vmatoa ("x", uvalue
));
1950 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
1955 case DW_AT_encoding
:
1959 case DW_ATE_void
: printf ("(void)"); break;
1960 case DW_ATE_address
: printf ("(machine address)"); break;
1961 case DW_ATE_boolean
: printf ("(boolean)"); break;
1962 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1963 case DW_ATE_float
: printf ("(float)"); break;
1964 case DW_ATE_signed
: printf ("(signed)"); break;
1965 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1966 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1967 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1968 /* DWARF 2.1 values: */
1969 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1970 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1971 /* DWARF 3 values: */
1972 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1973 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1974 case DW_ATE_edited
: printf ("(edited)"); break;
1975 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1976 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1977 /* HP extensions: */
1978 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1979 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1980 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1981 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1982 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1983 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1984 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1987 if (uvalue
>= DW_ATE_lo_user
1988 && uvalue
<= DW_ATE_hi_user
)
1989 printf (_("(user defined type)"));
1991 printf (_("(unknown type)"));
1996 case DW_AT_accessibility
:
2000 case DW_ACCESS_public
: printf ("(public)"); break;
2001 case DW_ACCESS_protected
: printf ("(protected)"); break;
2002 case DW_ACCESS_private
: printf ("(private)"); break;
2004 printf (_("(unknown accessibility)"));
2009 case DW_AT_visibility
:
2013 case DW_VIS_local
: printf ("(local)"); break;
2014 case DW_VIS_exported
: printf ("(exported)"); break;
2015 case DW_VIS_qualified
: printf ("(qualified)"); break;
2016 default: printf (_("(unknown visibility)")); break;
2020 case DW_AT_virtuality
:
2024 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2025 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2026 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2027 default: printf (_("(unknown virtuality)")); break;
2031 case DW_AT_identifier_case
:
2035 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2036 case DW_ID_up_case
: printf ("(up_case)"); break;
2037 case DW_ID_down_case
: printf ("(down_case)"); break;
2038 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2039 default: printf (_("(unknown case)")); break;
2043 case DW_AT_calling_convention
:
2047 case DW_CC_normal
: printf ("(normal)"); break;
2048 case DW_CC_program
: printf ("(program)"); break;
2049 case DW_CC_nocall
: printf ("(nocall)"); break;
2051 if (uvalue
>= DW_CC_lo_user
2052 && uvalue
<= DW_CC_hi_user
)
2053 printf (_("(user defined)"));
2055 printf (_("(unknown convention)"));
2059 case DW_AT_ordering
:
2063 case -1: printf (_("(undefined)")); break;
2064 case 0: printf ("(row major)"); break;
2065 case 1: printf ("(column major)"); break;
2069 case DW_AT_frame_base
:
2070 have_frame_base
= 1;
2071 case DW_AT_location
:
2072 case DW_AT_string_length
:
2073 case DW_AT_return_addr
:
2074 case DW_AT_data_member_location
:
2075 case DW_AT_vtable_elem_location
:
2077 case DW_AT_static_link
:
2078 case DW_AT_use_location
:
2079 case DW_AT_GNU_call_site_value
:
2080 case DW_AT_GNU_call_site_data_value
:
2081 case DW_AT_GNU_call_site_target
:
2082 case DW_AT_GNU_call_site_target_clobbered
:
2083 if ((dwarf_version
< 4
2084 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2085 || form
== DW_FORM_sec_offset
)
2086 printf (_(" (location list)"));
2088 case DW_AT_allocated
:
2089 case DW_AT_associated
:
2090 case DW_AT_data_location
:
2092 case DW_AT_upper_bound
:
2093 case DW_AT_lower_bound
:
2096 int need_frame_base
;
2099 need_frame_base
= decode_location_expression (block_start
,
2104 cu_offset
, section
);
2106 if (need_frame_base
&& !have_frame_base
)
2107 printf (_(" [without DW_AT_frame_base]"));
2113 if (form
== DW_FORM_ref_sig8
2114 || form
== DW_FORM_GNU_ref_alt
)
2117 if (form
== DW_FORM_ref1
2118 || form
== DW_FORM_ref2
2119 || form
== DW_FORM_ref4
2120 || form
== DW_FORM_ref_udata
)
2121 uvalue
+= cu_offset
;
2123 if (uvalue
>= section
->size
)
2124 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2125 dwarf_vmatoa ("x", uvalue
),
2126 (unsigned long) (orig_data
- section
->start
));
2129 unsigned long abbrev_number
;
2130 abbrev_entry
* entry
;
2132 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2134 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2135 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2136 use different abbrev table, and we don't track .debug_info chunks
2138 if (form
!= DW_FORM_ref_addr
)
2140 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2141 if (entry
->entry
== abbrev_number
)
2144 printf (" (%s)", get_TAG_name (entry
->tag
));
2159 get_AT_name (unsigned long attribute
)
2164 return "DW_AT value: 0";
2166 /* One value is shared by the MIPS and HP extensions: */
2167 if (attribute
== DW_AT_MIPS_fde
)
2168 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2170 name
= get_DW_AT_name (attribute
);
2174 static char buffer
[100];
2176 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2184 static unsigned char *
2185 read_and_display_attr (unsigned long attribute
,
2187 unsigned char * data
,
2188 unsigned char * end
,
2189 dwarf_vma cu_offset
,
2190 dwarf_vma pointer_size
,
2191 dwarf_vma offset_size
,
2193 debug_info
* debug_info_p
,
2195 struct dwarf_section
* section
,
2196 struct cu_tu_set
* this_set
)
2199 printf (" %-18s:", get_AT_name (attribute
));
2200 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2201 cu_offset
, pointer_size
, offset_size
,
2202 dwarf_version
, debug_info_p
,
2203 do_loc
, section
, this_set
);
2209 /* Process the contents of a .debug_info section. If do_loc is non-zero
2210 then we are scanning for location lists and we do not want to display
2211 anything to the user. If do_types is non-zero, we are processing
2212 a .debug_types section instead of a .debug_info section. */
2215 process_debug_info (struct dwarf_section
*section
,
2217 enum dwarf_section_display_enum abbrev_sec
,
2221 unsigned char *start
= section
->start
;
2222 unsigned char *end
= start
+ section
->size
;
2223 unsigned char *section_begin
;
2225 unsigned int num_units
= 0;
2227 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2228 && num_debug_info_entries
== 0
2233 /* First scan the section to get the number of comp units. */
2234 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2237 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2238 will be the length. For a 64-bit DWARF section, it'll be
2239 the escape code 0xffffffff followed by an 8 byte length. */
2240 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2242 if (length
== 0xffffffff)
2244 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2245 section_begin
+= length
+ 12;
2247 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2249 warn (_("Reserved length value (0x%s) found in section %s\n"),
2250 dwarf_vmatoa ("x", length
), section
->name
);
2254 section_begin
+= length
+ 4;
2256 /* Negative values are illegal, they may even cause infinite
2257 looping. This can happen if we can't accurately apply
2258 relocations to an object file. */
2259 if ((signed long) length
<= 0)
2261 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2262 dwarf_vmatoa ("x", length
), section
->name
);
2269 error (_("No comp units in %s section ?\n"), section
->name
);
2273 /* Then allocate an array to hold the information. */
2274 debug_information
= (debug_info
*) cmalloc (num_units
,
2275 sizeof (* debug_information
));
2276 if (debug_information
== NULL
)
2278 error (_("Not enough memory for a debug info array of %u entries\n"),
2286 if (dwarf_start_die
== 0)
2287 printf (_("Contents of the %s section:\n\n"), section
->name
);
2289 load_debug_section (str
, file
);
2290 load_debug_section (str_dwo
, file
);
2291 load_debug_section (str_index
, file
);
2292 load_debug_section (str_index_dwo
, file
);
2293 load_debug_section (debug_addr
, file
);
2296 load_debug_section (abbrev_sec
, file
);
2297 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2299 warn (_("Unable to locate %s section!\n"),
2300 debug_displays
[abbrev_sec
].section
.name
);
2304 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2306 DWARF2_Internal_CompUnit compunit
;
2307 unsigned char *hdrptr
;
2308 unsigned char *tags
;
2309 int level
, last_level
, saved_level
;
2310 dwarf_vma cu_offset
;
2311 unsigned int offset_size
;
2312 int initial_length_size
;
2313 dwarf_vma signature_high
= 0;
2314 dwarf_vma signature_low
= 0;
2315 dwarf_vma type_offset
= 0;
2316 struct cu_tu_set
*this_set
;
2317 dwarf_vma abbrev_base
;
2322 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2324 if (compunit
.cu_length
== 0xffffffff)
2326 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2328 initial_length_size
= 12;
2333 initial_length_size
= 4;
2336 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2338 cu_offset
= start
- section_begin
;
2340 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2342 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2344 if (this_set
== NULL
)
2347 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2351 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2352 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2355 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2356 /* PR 17512: file: 001-108546-0.001:0.1. */
2357 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2359 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2360 compunit
.cu_pointer_size
, offset_size
);
2361 compunit
.cu_pointer_size
= offset_size
;
2366 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2368 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2371 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2372 && num_debug_info_entries
== 0
2375 debug_information
[unit
].cu_offset
= cu_offset
;
2376 debug_information
[unit
].pointer_size
2377 = compunit
.cu_pointer_size
;
2378 debug_information
[unit
].offset_size
= offset_size
;
2379 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2380 debug_information
[unit
].base_address
= 0;
2381 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2382 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2383 debug_information
[unit
].loc_offsets
= NULL
;
2384 debug_information
[unit
].have_frame_base
= NULL
;
2385 debug_information
[unit
].max_loc_offsets
= 0;
2386 debug_information
[unit
].num_loc_offsets
= 0;
2387 debug_information
[unit
].range_lists
= NULL
;
2388 debug_information
[unit
].max_range_lists
= 0;
2389 debug_information
[unit
].num_range_lists
= 0;
2392 if (!do_loc
&& dwarf_start_die
== 0)
2394 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2395 dwarf_vmatoa ("x", cu_offset
));
2396 printf (_(" Length: 0x%s (%s)\n"),
2397 dwarf_vmatoa ("x", compunit
.cu_length
),
2398 offset_size
== 8 ? "64-bit" : "32-bit");
2399 printf (_(" Version: %d\n"), compunit
.cu_version
);
2400 printf (_(" Abbrev Offset: 0x%s\n"),
2401 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2402 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2407 printf (_(" Signature: 0x%s\n"),
2408 dwarf_vmatoa64 (signature_high
, signature_low
,
2409 buf
, sizeof (buf
)));
2410 printf (_(" Type Offset: 0x%s\n"),
2411 dwarf_vmatoa ("x", type_offset
));
2413 if (this_set
!= NULL
)
2415 dwarf_vma
*offsets
= this_set
->section_offsets
;
2416 size_t *sizes
= this_set
->section_sizes
;
2418 printf (_(" Section contributions:\n"));
2419 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2420 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2421 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2422 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2423 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2424 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2425 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2426 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2427 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2428 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2429 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2430 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2434 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2437 warn (_("Debug info is corrupted, length of CU at %s"
2438 " extends beyond end of section (length = %s)\n"),
2439 dwarf_vmatoa ("x", cu_offset
),
2440 dwarf_vmatoa ("x", compunit
.cu_length
));
2444 start
+= compunit
.cu_length
+ initial_length_size
;
2446 if (compunit
.cu_version
!= 2
2447 && compunit
.cu_version
!= 3
2448 && compunit
.cu_version
!= 4)
2450 warn (_("CU at offset %s contains corrupt or "
2451 "unsupported version number: %d.\n"),
2452 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2458 /* Process the abbrevs used by this compilation unit. */
2459 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2460 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2461 (unsigned long) compunit
.cu_abbrev_offset
,
2462 (unsigned long) abbrev_size
);
2464 process_abbrev_section
2465 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2466 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2467 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2468 + abbrev_base
+ abbrev_size
));
2473 while (tags
< start
)
2475 unsigned int bytes_read
;
2476 unsigned long abbrev_number
;
2477 unsigned long die_offset
;
2478 abbrev_entry
*entry
;
2480 int do_printing
= 1;
2482 die_offset
= tags
- section_begin
;
2484 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2487 /* A null DIE marks the end of a list of siblings or it may also be
2488 a section padding. */
2489 if (abbrev_number
== 0)
2491 /* Check if it can be a section padding for the last CU. */
2492 if (level
== 0 && start
== end
)
2496 for (chk
= tags
; chk
< start
; chk
++)
2503 if (!do_loc
&& die_offset
>= dwarf_start_die
2504 && (dwarf_cutoff_level
== -1
2505 || level
< dwarf_cutoff_level
))
2506 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2512 static unsigned num_bogus_warns
= 0;
2514 if (num_bogus_warns
< 3)
2516 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2517 die_offset
, section
->name
);
2519 if (num_bogus_warns
== 3)
2520 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2523 if (dwarf_start_die
!= 0 && level
< saved_level
)
2530 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2534 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2535 saved_level
= level
;
2536 do_printing
= (dwarf_cutoff_level
== -1
2537 || level
< dwarf_cutoff_level
);
2539 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2540 level
, die_offset
, abbrev_number
);
2541 else if (dwarf_cutoff_level
== -1
2542 || last_level
< dwarf_cutoff_level
)
2543 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2548 /* Scan through the abbreviation list until we reach the
2550 for (entry
= first_abbrev
;
2551 entry
&& entry
->entry
!= abbrev_number
;
2552 entry
= entry
->next
)
2557 if (!do_loc
&& do_printing
)
2562 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2563 die_offset
, abbrev_number
);
2567 if (!do_loc
&& do_printing
)
2568 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2573 need_base_address
= 0;
2575 case DW_TAG_compile_unit
:
2576 need_base_address
= 1;
2578 case DW_TAG_entry_point
:
2579 case DW_TAG_subprogram
:
2580 need_base_address
= 0;
2581 /* Assuming that there is no DW_AT_frame_base. */
2582 have_frame_base
= 0;
2586 for (attr
= entry
->first_attr
;
2587 attr
&& attr
->attribute
;
2592 if (! do_loc
&& do_printing
)
2593 /* Show the offset from where the tag was extracted. */
2594 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2596 arg
= debug_information
;
2597 if (debug_information
)
2600 tags
= read_and_display_attr (attr
->attribute
,
2605 compunit
.cu_pointer_size
,
2607 compunit
.cu_version
,
2609 do_loc
|| ! do_printing
,
2614 if (entry
->children
)
2619 /* Set num_debug_info_entries here so that it can be used to check if
2620 we need to process .debug_loc and .debug_ranges sections. */
2621 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2622 && num_debug_info_entries
== 0
2624 num_debug_info_entries
= num_units
;
2632 /* Locate and scan the .debug_info section in the file and record the pointer
2633 sizes and offsets for the compilation units in it. Usually an executable
2634 will have just one pointer size, but this is not guaranteed, and so we try
2635 not to make any assumptions. Returns zero upon failure, or the number of
2636 compilation units upon success. */
2639 load_debug_info (void * file
)
2641 /* Reset the last pointer size so that we can issue correct error
2642 messages if we are displaying the contents of more than one section. */
2643 last_pointer_size
= 0;
2644 warned_about_missing_comp_units
= FALSE
;
2646 /* If we have already tried and failed to load the .debug_info
2647 section then do not bother to repeat the task. */
2648 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2651 /* If we already have the information there is nothing else to do. */
2652 if (num_debug_info_entries
> 0)
2653 return num_debug_info_entries
;
2655 /* If this is a DWARF package file, load the CU and TU indexes. */
2656 load_cu_tu_indexes (file
);
2658 if (load_debug_section (info
, file
)
2659 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2660 return num_debug_info_entries
;
2661 else if (load_debug_section (info_dwo
, file
)
2662 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2664 return num_debug_info_entries
;
2666 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2670 /* Read a DWARF .debug_line section header starting at DATA.
2671 Upon success returns an updated DATA pointer and the LINFO
2672 structure and the END_OF_SEQUENCE pointer will be filled in.
2673 Otherwise returns NULL. */
2675 static unsigned char *
2676 read_debug_line_header (struct dwarf_section
* section
,
2677 unsigned char * data
,
2678 unsigned char * end
,
2679 DWARF2_Internal_LineInfo
* linfo
,
2680 unsigned char ** end_of_sequence
)
2682 unsigned char *hdrptr
;
2683 unsigned int offset_size
;
2684 unsigned int initial_length_size
;
2686 /* Extract information from the Line Number Program Header.
2687 (section 6.2.4 in the Dwarf3 doc). */
2690 /* Get and check the length of the block. */
2691 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2693 if (linfo
->li_length
== 0xffffffff)
2695 /* This section is 64-bit DWARF 3. */
2696 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2698 initial_length_size
= 12;
2703 initial_length_size
= 4;
2706 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2708 /* If the length is just a bias against the initial_length_size then
2709 this means that the field has a relocation against it which has not
2710 been applied. (Ie we are dealing with an object file, not a linked
2711 binary). Do not complain but instead assume that the rest of the
2712 section applies to this particular header. */
2713 if (linfo
->li_length
== - initial_length_size
)
2715 linfo
->li_length
= section
->size
- initial_length_size
;
2719 warn (_("The line info appears to be corrupt - the section is too small\n"));
2724 /* Get and check the version number. */
2725 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2727 if (linfo
->li_version
!= 2
2728 && linfo
->li_version
!= 3
2729 && linfo
->li_version
!= 4)
2731 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2735 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2736 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2738 if (linfo
->li_version
>= 4)
2740 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2742 if (linfo
->li_max_ops_per_insn
== 0)
2744 warn (_("Invalid maximum operations per insn.\n"));
2749 linfo
->li_max_ops_per_insn
= 1;
2751 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2752 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2753 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2754 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2756 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2757 /* PR 17512: file:002-117414-0.004. */
2758 if (* end_of_sequence
> end
)
2760 warn (_("Line length %s extends beyond end of section\n"),
2761 dwarf_vmatoa ("u", linfo
->li_length
));
2762 * end_of_sequence
= end
;
2770 display_debug_lines_raw (struct dwarf_section
*section
,
2771 unsigned char *data
,
2774 unsigned char *start
= section
->start
;
2776 printf (_("Raw dump of debug contents of section %s:\n\n"),
2781 static DWARF2_Internal_LineInfo saved_linfo
;
2782 DWARF2_Internal_LineInfo linfo
;
2783 unsigned char *standard_opcodes
;
2784 unsigned char *end_of_sequence
;
2785 unsigned int last_dir_entry
= 0;
2788 if (const_strneq (section
->name
, ".debug_line.")
2789 /* Note: the following does not apply to .debug_line.dwo sections.
2790 These are full debug_line sections. */
2791 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2793 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2794 section containing just the Line Number Statements. They are
2795 created by the assembler and intended to be used alongside gcc's
2796 -ffunction-sections command line option. When the linker's
2797 garbage collection decides to discard a .text.<foo> section it
2798 can then also discard the line number information in .debug_line.<foo>.
2800 Since the section is a fragment it does not have the details
2801 needed to fill out a LineInfo structure, so instead we use the
2802 details from the last full debug_line section that we processed. */
2803 end_of_sequence
= end
;
2804 standard_opcodes
= NULL
;
2805 linfo
= saved_linfo
;
2806 reset_state_machine (linfo
.li_default_is_stmt
);
2810 unsigned char * hdrptr
;
2812 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2813 & end_of_sequence
)) == NULL
)
2816 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2817 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2818 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2819 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2820 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2821 if (linfo
.li_version
>= 4)
2822 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2823 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2824 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2825 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2826 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2828 /* PR 17512: file: 1665-6428-0.004. */
2829 if (linfo
.li_line_range
== 0)
2831 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2832 linfo
.li_line_range
= 1;
2835 reset_state_machine (linfo
.li_default_is_stmt
);
2837 /* Display the contents of the Opcodes table. */
2838 standard_opcodes
= hdrptr
;
2840 /* PR 17512: file: 002-417945-0.004. */
2841 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
2843 warn (_("Line Base extends beyond end of section\n"));
2847 printf (_("\n Opcodes:\n"));
2849 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2850 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2852 /* Display the contents of the Directory table. */
2853 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2856 printf (_("\n The Directory Table is empty.\n"));
2859 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2860 (long)(data
- start
));
2862 while (data
< end
&& *data
!= 0)
2864 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
2866 data
+= strnlen ((char *) data
, end
- data
) + 1;
2869 /* PR 17512: file: 002-132094-0.004. */
2870 if (data
>= end
- 1)
2874 /* Skip the NUL at the end of the table. */
2877 /* Display the contents of the File Name table. */
2879 printf (_("\n The File Name Table is empty.\n"));
2882 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2883 (long)(data
- start
));
2884 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2886 while (data
< end
&& *data
!= 0)
2888 unsigned char *name
;
2889 unsigned int bytes_read
;
2891 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2893 data
+= strnlen ((char *) data
, end
- data
) + 1;
2896 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2899 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2902 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2904 printf ("%.*s\n", (int)(end
- name
), name
);
2908 warn (_("Corrupt file name table entry\n"));
2914 /* Skip the NUL at the end of the table. */
2917 saved_linfo
= linfo
;
2920 /* Now display the statements. */
2921 if (data
>= end_of_sequence
)
2922 printf (_(" No Line Number Statements.\n"));
2925 printf (_(" Line Number Statements:\n"));
2927 while (data
< end_of_sequence
)
2929 unsigned char op_code
;
2930 dwarf_signed_vma adv
;
2932 unsigned int bytes_read
;
2934 printf (" [0x%08lx]", (long)(data
- start
));
2938 if (op_code
>= linfo
.li_opcode_base
)
2940 op_code
-= linfo
.li_opcode_base
;
2941 uladv
= (op_code
/ linfo
.li_line_range
);
2942 if (linfo
.li_max_ops_per_insn
== 1)
2944 uladv
*= linfo
.li_min_insn_length
;
2945 state_machine_regs
.address
+= uladv
;
2946 printf (_(" Special opcode %d: "
2947 "advance Address by %s to 0x%s"),
2948 op_code
, dwarf_vmatoa ("u", uladv
),
2949 dwarf_vmatoa ("x", state_machine_regs
.address
));
2953 state_machine_regs
.address
2954 += ((state_machine_regs
.op_index
+ uladv
)
2955 / linfo
.li_max_ops_per_insn
)
2956 * linfo
.li_min_insn_length
;
2957 state_machine_regs
.op_index
2958 = (state_machine_regs
.op_index
+ uladv
)
2959 % linfo
.li_max_ops_per_insn
;
2960 printf (_(" Special opcode %d: "
2961 "advance Address by %s to 0x%s[%d]"),
2962 op_code
, dwarf_vmatoa ("u", uladv
),
2963 dwarf_vmatoa ("x", state_machine_regs
.address
),
2964 state_machine_regs
.op_index
);
2966 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2967 state_machine_regs
.line
+= adv
;
2968 printf (_(" and Line by %s to %d\n"),
2969 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
2971 else switch (op_code
)
2973 case DW_LNS_extended_op
:
2974 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
2978 printf (_(" Copy\n"));
2981 case DW_LNS_advance_pc
:
2982 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2984 if (linfo
.li_max_ops_per_insn
== 1)
2986 uladv
*= linfo
.li_min_insn_length
;
2987 state_machine_regs
.address
+= uladv
;
2988 printf (_(" Advance PC by %s to 0x%s\n"),
2989 dwarf_vmatoa ("u", uladv
),
2990 dwarf_vmatoa ("x", state_machine_regs
.address
));
2994 state_machine_regs
.address
2995 += ((state_machine_regs
.op_index
+ uladv
)
2996 / linfo
.li_max_ops_per_insn
)
2997 * linfo
.li_min_insn_length
;
2998 state_machine_regs
.op_index
2999 = (state_machine_regs
.op_index
+ uladv
)
3000 % linfo
.li_max_ops_per_insn
;
3001 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3002 dwarf_vmatoa ("u", uladv
),
3003 dwarf_vmatoa ("x", state_machine_regs
.address
),
3004 state_machine_regs
.op_index
);
3008 case DW_LNS_advance_line
:
3009 adv
= read_sleb128 (data
, & bytes_read
, end
);
3011 state_machine_regs
.line
+= adv
;
3012 printf (_(" Advance Line by %s to %d\n"),
3013 dwarf_vmatoa ("d", adv
),
3014 state_machine_regs
.line
);
3017 case DW_LNS_set_file
:
3018 adv
= read_uleb128 (data
, & bytes_read
, end
);
3020 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3021 dwarf_vmatoa ("d", adv
));
3022 state_machine_regs
.file
= adv
;
3025 case DW_LNS_set_column
:
3026 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3028 printf (_(" Set column to %s\n"),
3029 dwarf_vmatoa ("u", uladv
));
3030 state_machine_regs
.column
= uladv
;
3033 case DW_LNS_negate_stmt
:
3034 adv
= state_machine_regs
.is_stmt
;
3036 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3037 state_machine_regs
.is_stmt
= adv
;
3040 case DW_LNS_set_basic_block
:
3041 printf (_(" Set basic block\n"));
3042 state_machine_regs
.basic_block
= 1;
3045 case DW_LNS_const_add_pc
:
3046 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3047 if (linfo
.li_max_ops_per_insn
)
3049 uladv
*= linfo
.li_min_insn_length
;
3050 state_machine_regs
.address
+= uladv
;
3051 printf (_(" Advance PC by constant %s to 0x%s\n"),
3052 dwarf_vmatoa ("u", uladv
),
3053 dwarf_vmatoa ("x", state_machine_regs
.address
));
3057 state_machine_regs
.address
3058 += ((state_machine_regs
.op_index
+ uladv
)
3059 / linfo
.li_max_ops_per_insn
)
3060 * linfo
.li_min_insn_length
;
3061 state_machine_regs
.op_index
3062 = (state_machine_regs
.op_index
+ uladv
)
3063 % linfo
.li_max_ops_per_insn
;
3064 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3065 dwarf_vmatoa ("u", uladv
),
3066 dwarf_vmatoa ("x", state_machine_regs
.address
),
3067 state_machine_regs
.op_index
);
3071 case DW_LNS_fixed_advance_pc
:
3072 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3073 state_machine_regs
.address
+= uladv
;
3074 state_machine_regs
.op_index
= 0;
3075 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3076 dwarf_vmatoa ("u", uladv
),
3077 dwarf_vmatoa ("x", state_machine_regs
.address
));
3080 case DW_LNS_set_prologue_end
:
3081 printf (_(" Set prologue_end to true\n"));
3084 case DW_LNS_set_epilogue_begin
:
3085 printf (_(" Set epilogue_begin to true\n"));
3088 case DW_LNS_set_isa
:
3089 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3091 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3095 printf (_(" Unknown opcode %d with operands: "), op_code
);
3097 if (standard_opcodes
!= NULL
)
3098 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3100 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3102 i
== 1 ? "" : ", ");
3118 unsigned char *name
;
3119 unsigned int directory_index
;
3120 unsigned int modification_date
;
3121 unsigned int length
;
3124 /* Output a decoded representation of the .debug_line section. */
3127 display_debug_lines_decoded (struct dwarf_section
*section
,
3128 unsigned char *data
,
3131 static DWARF2_Internal_LineInfo saved_linfo
;
3133 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3138 /* This loop amounts to one iteration per compilation unit. */
3139 DWARF2_Internal_LineInfo linfo
;
3140 unsigned char *standard_opcodes
;
3141 unsigned char *end_of_sequence
;
3143 File_Entry
*file_table
= NULL
;
3144 unsigned int n_files
= 0;
3145 unsigned char **directory_table
= NULL
;
3146 unsigned int n_directories
= 0;
3148 if (const_strneq (section
->name
, ".debug_line.")
3149 /* Note: the following does not apply to .debug_line.dwo sections.
3150 These are full debug_line sections. */
3151 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3153 /* See comment in display_debug_lines_raw(). */
3154 end_of_sequence
= end
;
3155 standard_opcodes
= NULL
;
3156 linfo
= saved_linfo
;
3157 reset_state_machine (linfo
.li_default_is_stmt
);
3161 unsigned char *hdrptr
;
3163 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3164 & end_of_sequence
)) == NULL
)
3167 reset_state_machine (linfo
.li_default_is_stmt
);
3169 /* Save a pointer to the contents of the Opcodes table. */
3170 standard_opcodes
= hdrptr
;
3172 /* Traverse the Directory table just to count entries. */
3173 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3176 unsigned char *ptr_directory_table
= data
;
3180 data
+= strnlen ((char *) data
, end
- data
) + 1;
3184 /* Go through the directory table again to save the directories. */
3185 directory_table
= (unsigned char **)
3186 xmalloc (n_directories
* sizeof (unsigned char *));
3189 while (*ptr_directory_table
!= 0)
3191 directory_table
[i
] = ptr_directory_table
;
3192 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3193 ptr_directory_table
- end
) + 1;
3197 /* Skip the NUL at the end of the table. */
3200 /* Traverse the File Name table just to count the entries. */
3203 unsigned char *ptr_file_name_table
= data
;
3207 unsigned int bytes_read
;
3209 /* Skip Name, directory index, last modification time and length
3211 data
+= strnlen ((char *) data
, end
- data
) + 1;
3212 read_uleb128 (data
, & bytes_read
, end
);
3214 read_uleb128 (data
, & bytes_read
, end
);
3216 read_uleb128 (data
, & bytes_read
, end
);
3222 /* Go through the file table again to save the strings. */
3223 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3226 while (*ptr_file_name_table
!= 0)
3228 unsigned int bytes_read
;
3230 file_table
[i
].name
= ptr_file_name_table
;
3231 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3232 end
- ptr_file_name_table
) + 1;
3234 /* We are not interested in directory, time or size. */
3235 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3237 ptr_file_name_table
+= bytes_read
;
3238 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3240 ptr_file_name_table
+= bytes_read
;
3241 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3242 ptr_file_name_table
+= bytes_read
;
3247 /* Print the Compilation Unit's name and a header. */
3248 if (directory_table
== NULL
)
3250 printf (_("CU: %s:\n"), file_table
[0].name
);
3251 printf (_("File name Line number Starting address\n"));
3255 unsigned int ix
= file_table
[0].directory_index
;
3256 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3258 if (do_wide
|| strlen (directory
) < 76)
3259 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3261 printf ("%s:\n", file_table
[0].name
);
3263 printf (_("File name Line number Starting address\n"));
3267 /* Skip the NUL at the end of the table. */
3270 saved_linfo
= linfo
;
3273 /* This loop iterates through the Dwarf Line Number Program. */
3274 while (data
< end_of_sequence
)
3276 unsigned char op_code
;
3278 unsigned long int uladv
;
3279 unsigned int bytes_read
;
3280 int is_special_opcode
= 0;
3284 if (op_code
>= linfo
.li_opcode_base
)
3286 op_code
-= linfo
.li_opcode_base
;
3287 uladv
= (op_code
/ linfo
.li_line_range
);
3288 if (linfo
.li_max_ops_per_insn
== 1)
3290 uladv
*= linfo
.li_min_insn_length
;
3291 state_machine_regs
.address
+= uladv
;
3295 state_machine_regs
.address
3296 += ((state_machine_regs
.op_index
+ uladv
)
3297 / linfo
.li_max_ops_per_insn
)
3298 * linfo
.li_min_insn_length
;
3299 state_machine_regs
.op_index
3300 = (state_machine_regs
.op_index
+ uladv
)
3301 % linfo
.li_max_ops_per_insn
;
3304 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3305 state_machine_regs
.line
+= adv
;
3306 is_special_opcode
= 1;
3308 else switch (op_code
)
3310 case DW_LNS_extended_op
:
3312 unsigned int ext_op_code_len
;
3313 unsigned char ext_op_code
;
3314 unsigned char *op_code_data
= data
;
3316 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3318 op_code_data
+= bytes_read
;
3320 if (ext_op_code_len
== 0)
3322 warn (_("Badly formed extended line op encountered!\n"));
3325 ext_op_code_len
+= bytes_read
;
3326 ext_op_code
= *op_code_data
++;
3328 switch (ext_op_code
)
3330 case DW_LNE_end_sequence
:
3331 reset_state_machine (linfo
.li_default_is_stmt
);
3333 case DW_LNE_set_address
:
3334 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3336 ext_op_code_len
- bytes_read
- 1,
3338 state_machine_regs
.op_index
= 0;
3340 case DW_LNE_define_file
:
3342 file_table
= (File_Entry
*) xrealloc
3343 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3345 ++state_machine_regs
.last_file_entry
;
3346 /* Source file name. */
3347 file_table
[n_files
].name
= op_code_data
;
3348 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3349 /* Directory index. */
3350 file_table
[n_files
].directory_index
=
3351 read_uleb128 (op_code_data
, & bytes_read
,
3353 op_code_data
+= bytes_read
;
3354 /* Last modification time. */
3355 file_table
[n_files
].modification_date
=
3356 read_uleb128 (op_code_data
, & bytes_read
,
3358 op_code_data
+= bytes_read
;
3360 file_table
[n_files
].length
=
3361 read_uleb128 (op_code_data
, & bytes_read
,
3367 case DW_LNE_set_discriminator
:
3368 case DW_LNE_HP_set_sequence
:
3369 /* Simply ignored. */
3373 printf (_("UNKNOWN (%u): length %d\n"),
3374 ext_op_code
, ext_op_code_len
- bytes_read
);
3377 data
+= ext_op_code_len
;
3383 case DW_LNS_advance_pc
:
3384 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3386 if (linfo
.li_max_ops_per_insn
== 1)
3388 uladv
*= linfo
.li_min_insn_length
;
3389 state_machine_regs
.address
+= uladv
;
3393 state_machine_regs
.address
3394 += ((state_machine_regs
.op_index
+ uladv
)
3395 / linfo
.li_max_ops_per_insn
)
3396 * linfo
.li_min_insn_length
;
3397 state_machine_regs
.op_index
3398 = (state_machine_regs
.op_index
+ uladv
)
3399 % linfo
.li_max_ops_per_insn
;
3403 case DW_LNS_advance_line
:
3404 adv
= read_sleb128 (data
, & bytes_read
, end
);
3406 state_machine_regs
.line
+= adv
;
3409 case DW_LNS_set_file
:
3410 adv
= read_uleb128 (data
, & bytes_read
, end
);
3412 state_machine_regs
.file
= adv
;
3414 if (file_table
== NULL
)
3415 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3416 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3417 /* If directory index is 0, that means current directory. */
3418 printf ("\n./%s:[++]\n",
3419 file_table
[state_machine_regs
.file
- 1].name
);
3420 else if (directory_table
== NULL
)
3421 printf (_("\n [Use directory table entry %d]\n"),
3422 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3424 /* The directory index starts counting at 1. */
3425 printf ("\n%s/%s:\n",
3426 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3427 file_table
[state_machine_regs
.file
- 1].name
);
3430 case DW_LNS_set_column
:
3431 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3433 state_machine_regs
.column
= uladv
;
3436 case DW_LNS_negate_stmt
:
3437 adv
= state_machine_regs
.is_stmt
;
3439 state_machine_regs
.is_stmt
= adv
;
3442 case DW_LNS_set_basic_block
:
3443 state_machine_regs
.basic_block
= 1;
3446 case DW_LNS_const_add_pc
:
3447 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3448 if (linfo
.li_max_ops_per_insn
== 1)
3450 uladv
*= linfo
.li_min_insn_length
;
3451 state_machine_regs
.address
+= uladv
;
3455 state_machine_regs
.address
3456 += ((state_machine_regs
.op_index
+ uladv
)
3457 / linfo
.li_max_ops_per_insn
)
3458 * linfo
.li_min_insn_length
;
3459 state_machine_regs
.op_index
3460 = (state_machine_regs
.op_index
+ uladv
)
3461 % linfo
.li_max_ops_per_insn
;
3465 case DW_LNS_fixed_advance_pc
:
3466 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3467 state_machine_regs
.address
+= uladv
;
3468 state_machine_regs
.op_index
= 0;
3471 case DW_LNS_set_prologue_end
:
3474 case DW_LNS_set_epilogue_begin
:
3477 case DW_LNS_set_isa
:
3478 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3480 printf (_(" Set ISA to %lu\n"), uladv
);
3484 printf (_(" Unknown opcode %d with operands: "), op_code
);
3486 if (standard_opcodes
!= NULL
)
3487 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3489 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3491 i
== 1 ? "" : ", ");
3498 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3499 to the DWARF address/line matrix. */
3500 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3501 || (op_code
== DW_LNS_copy
))
3503 const unsigned int MAX_FILENAME_LENGTH
= 35;
3505 char *newFileName
= NULL
;
3506 size_t fileNameLength
;
3509 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3511 fileName
= "<unknown>";
3513 fileNameLength
= strlen (fileName
);
3515 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3517 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3518 /* Truncate file name */
3519 strncpy (newFileName
,
3520 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3521 MAX_FILENAME_LENGTH
+ 1);
3525 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3526 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3529 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3531 if (linfo
.li_max_ops_per_insn
== 1)
3532 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3533 newFileName
, state_machine_regs
.line
,
3534 state_machine_regs
.address
);
3536 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3537 newFileName
, state_machine_regs
.line
,
3538 state_machine_regs
.address
,
3539 state_machine_regs
.op_index
);
3543 if (linfo
.li_max_ops_per_insn
== 1)
3544 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3545 newFileName
, state_machine_regs
.line
,
3546 state_machine_regs
.address
);
3548 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3549 newFileName
, state_machine_regs
.line
,
3550 state_machine_regs
.address
,
3551 state_machine_regs
.op_index
);
3554 if (op_code
== DW_LNE_end_sequence
)
3568 if (directory_table
)
3570 free (directory_table
);
3571 directory_table
= NULL
;
3582 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3584 unsigned char *data
= section
->start
;
3585 unsigned char *end
= data
+ section
->size
;
3587 int retValDecoded
= 1;
3589 if (do_debug_lines
== 0)
3590 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3592 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3593 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3595 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3596 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3598 if (!retValRaw
|| !retValDecoded
)
3605 find_debug_info_for_offset (unsigned long offset
)
3609 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3612 for (i
= 0; i
< num_debug_info_entries
; i
++)
3613 if (debug_information
[i
].cu_offset
== offset
)
3614 return debug_information
+ i
;
3620 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
3622 /* See gdb/gdb-index.h. */
3623 static const char * const kinds
[] =
3635 return _ (kinds
[kind
]);
3639 display_debug_pubnames_worker (struct dwarf_section
*section
,
3640 void *file ATTRIBUTE_UNUSED
,
3643 DWARF2_Internal_PubNames names
;
3644 unsigned char *start
= section
->start
;
3645 unsigned char *end
= start
+ section
->size
;
3647 /* It does not matter if this load fails,
3648 we test for that later on. */
3649 load_debug_info (file
);
3651 printf (_("Contents of the %s section:\n\n"), section
->name
);
3655 unsigned char *data
;
3656 unsigned long offset
;
3657 unsigned int offset_size
, initial_length_size
;
3661 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3662 if (names
.pn_length
== 0xffffffff)
3664 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3666 initial_length_size
= 12;
3671 initial_length_size
= 4;
3674 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3675 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3677 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3678 && num_debug_info_entries
> 0
3679 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3680 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3681 (unsigned long) names
.pn_offset
, section
->name
);
3683 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3685 start
+= names
.pn_length
+ initial_length_size
;
3687 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3689 static int warned
= 0;
3693 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3700 printf (_(" Length: %ld\n"),
3701 (long) names
.pn_length
);
3702 printf (_(" Version: %d\n"),
3704 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3705 (unsigned long) names
.pn_offset
);
3706 printf (_(" Size of area in .debug_info section: %ld\n"),
3707 (long) names
.pn_size
);
3710 printf (_("\n Offset Kind Name\n"));
3712 printf (_("\n Offset\tName\n"));
3716 bfd_size_type maxprint
;
3718 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3722 data
+= offset_size
;
3725 maxprint
= (end
- data
) - 1;
3729 unsigned int kind_data
;
3730 gdb_index_symbol_kind kind
;
3731 const char *kind_name
;
3734 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
3737 /* GCC computes the kind as the upper byte in the CU index
3738 word, and then right shifts it by the CU index size.
3739 Left shift KIND to where the gdb-index.h accessor macros
3741 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
3742 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
3743 kind_name
= get_gdb_index_symbol_kind_name (kind
);
3744 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
3745 printf (" %-6lx %s,%-10s %.*s\n",
3746 offset
, is_static
? _("s") : _("g"),
3747 kind_name
, (int) maxprint
, data
);
3750 printf (" %-6lx\t%.*s\n", offset
, (int) maxprint
, data
);
3752 data
+= strnlen ((char *) data
, maxprint
) + 1;
3757 while (offset
!= 0);
3765 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
3767 return display_debug_pubnames_worker (section
, file
, 0);
3771 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
3773 return display_debug_pubnames_worker (section
, file
, 1);
3777 display_debug_macinfo (struct dwarf_section
*section
,
3778 void *file ATTRIBUTE_UNUSED
)
3780 unsigned char *start
= section
->start
;
3781 unsigned char *end
= start
+ section
->size
;
3782 unsigned char *curr
= start
;
3783 unsigned int bytes_read
;
3784 enum dwarf_macinfo_record_type op
;
3786 printf (_("Contents of the %s section:\n\n"), section
->name
);
3790 unsigned int lineno
;
3791 const unsigned char *string
;
3793 op
= (enum dwarf_macinfo_record_type
) *curr
;
3798 case DW_MACINFO_start_file
:
3800 unsigned int filenum
;
3802 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3804 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3807 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3812 case DW_MACINFO_end_file
:
3813 printf (_(" DW_MACINFO_end_file\n"));
3816 case DW_MACINFO_define
:
3817 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3820 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3821 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3825 case DW_MACINFO_undef
:
3826 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3829 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3830 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3834 case DW_MACINFO_vendor_ext
:
3836 unsigned int constant
;
3838 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3841 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3842 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3852 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3853 filename and dirname corresponding to file name table entry with index
3854 FILEIDX. Return NULL on failure. */
3856 static unsigned char *
3857 get_line_filename_and_dirname (dwarf_vma line_offset
,
3859 unsigned char **dir_name
)
3861 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3862 unsigned char *hdrptr
, *dirtable
, *file_name
;
3863 unsigned int offset_size
, initial_length_size
;
3864 unsigned int version
, opcode_base
, bytes_read
;
3865 dwarf_vma length
, diridx
;
3866 const unsigned char * end
;
3869 if (section
->start
== NULL
3870 || line_offset
>= section
->size
3874 hdrptr
= section
->start
+ line_offset
;
3875 end
= section
->start
+ section
->size
;
3877 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3878 if (length
== 0xffffffff)
3880 /* This section is 64-bit DWARF 3. */
3881 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3883 initial_length_size
= 12;
3888 initial_length_size
= 4;
3890 if (length
+ initial_length_size
> section
->size
)
3893 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3894 if (version
!= 2 && version
!= 3 && version
!= 4)
3896 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3898 hdrptr
++; /* Skip max_ops_per_insn. */
3899 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3901 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3902 if (opcode_base
== 0)
3905 hdrptr
+= opcode_base
- 1;
3907 /* Skip over dirname table. */
3908 while (*hdrptr
!= '\0')
3909 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3910 hdrptr
++; /* Skip the NUL at the end of the table. */
3911 /* Now skip over preceding filename table entries. */
3912 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3914 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3915 read_uleb128 (hdrptr
, &bytes_read
, end
);
3916 hdrptr
+= bytes_read
;
3917 read_uleb128 (hdrptr
, &bytes_read
, end
);
3918 hdrptr
+= bytes_read
;
3919 read_uleb128 (hdrptr
, &bytes_read
, end
);
3920 hdrptr
+= bytes_read
;
3922 if (hdrptr
== end
|| *hdrptr
== '\0')
3925 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3926 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
3929 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
3930 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
3931 if (*dirtable
== '\0')
3933 *dir_name
= dirtable
;
3938 display_debug_macro (struct dwarf_section
*section
,
3941 unsigned char *start
= section
->start
;
3942 unsigned char *end
= start
+ section
->size
;
3943 unsigned char *curr
= start
;
3944 unsigned char *extended_op_buf
[256];
3945 unsigned int bytes_read
;
3947 load_debug_section (str
, file
);
3948 load_debug_section (line
, file
);
3950 printf (_("Contents of the %s section:\n\n"), section
->name
);
3954 unsigned int lineno
, version
, flags
;
3955 unsigned int offset_size
= 4;
3956 const unsigned char *string
;
3957 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
3958 unsigned char **extended_ops
= NULL
;
3960 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
3963 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3968 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
3971 printf (_(" Offset: 0x%lx\n"),
3972 (unsigned long) sec_offset
);
3973 printf (_(" Version: %d\n"), version
);
3974 printf (_(" Offset size: %d\n"), offset_size
);
3977 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
3978 printf (_(" Offset into .debug_line: 0x%lx\n"),
3979 (unsigned long) line_offset
);
3983 unsigned int i
, count
, op
;
3986 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
3988 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
3989 extended_ops
= extended_op_buf
;
3992 printf (_(" Extension opcode arguments:\n"));
3993 for (i
= 0; i
< count
; i
++)
3995 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3996 extended_ops
[op
] = curr
;
3997 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
4000 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
4003 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
4004 for (n
= 0; n
< nargs
; n
++)
4008 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
4009 printf ("%s%s", get_FORM_name (form
),
4010 n
== nargs
- 1 ? "\n" : ", ");
4020 case DW_FORM_block1
:
4021 case DW_FORM_block2
:
4022 case DW_FORM_block4
:
4024 case DW_FORM_string
:
4026 case DW_FORM_sec_offset
:
4029 error (_("Invalid extension opcode form %s\n"),
4030 get_FORM_name (form
));
4046 error (_(".debug_macro section not zero terminated\n"));
4050 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4056 case DW_MACRO_GNU_start_file
:
4058 unsigned int filenum
;
4059 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4061 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4063 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4066 if ((flags
& 2) == 0)
4067 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4070 = get_line_filename_and_dirname (line_offset
, filenum
,
4072 if (file_name
== NULL
)
4073 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4076 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4078 dir_name
!= NULL
? (const char *) dir_name
: "",
4079 dir_name
!= NULL
? "/" : "", file_name
);
4083 case DW_MACRO_GNU_end_file
:
4084 printf (_(" DW_MACRO_GNU_end_file\n"));
4087 case DW_MACRO_GNU_define
:
4088 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4091 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4092 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4096 case DW_MACRO_GNU_undef
:
4097 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4100 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4101 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4105 case DW_MACRO_GNU_define_indirect
:
4106 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4108 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4109 string
= fetch_indirect_string (offset
);
4110 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4114 case DW_MACRO_GNU_undef_indirect
:
4115 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4117 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4118 string
= fetch_indirect_string (offset
);
4119 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4123 case DW_MACRO_GNU_transparent_include
:
4124 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4125 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4126 (unsigned long) offset
);
4129 case DW_MACRO_GNU_define_indirect_alt
:
4130 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4132 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4133 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4134 lineno
, (unsigned long) offset
);
4137 case DW_MACRO_GNU_undef_indirect_alt
:
4138 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4140 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4141 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4142 lineno
, (unsigned long) offset
);
4145 case DW_MACRO_GNU_transparent_include_alt
:
4146 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4147 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4148 (unsigned long) offset
);
4152 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
4154 error (_(" Unknown macro opcode %02x seen\n"), op
);
4159 /* Skip over unhandled opcodes. */
4161 unsigned char *desc
= extended_ops
[op
];
4162 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
4166 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
4169 printf (_(" DW_MACRO_GNU_%02x -"), op
);
4170 for (n
= 0; n
< nargs
; n
++)
4174 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
4176 = read_and_display_attr_value (0, val
,
4177 curr
, end
, 0, 0, offset_size
,
4178 version
, NULL
, 0, NULL
,
4196 display_debug_abbrev (struct dwarf_section
*section
,
4197 void *file ATTRIBUTE_UNUSED
)
4199 abbrev_entry
*entry
;
4200 unsigned char *start
= section
->start
;
4201 unsigned char *end
= start
+ section
->size
;
4203 printf (_("Contents of the %s section:\n\n"), section
->name
);
4207 unsigned char *last
;
4212 start
= process_abbrev_section (start
, end
);
4214 if (first_abbrev
== NULL
)
4217 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4219 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4223 printf (" %ld %s [%s]\n",
4225 get_TAG_name (entry
->tag
),
4226 entry
->children
? _("has children") : _("no children"));
4228 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4229 printf (" %-18s %s\n",
4230 get_AT_name (attr
->attribute
),
4231 get_FORM_name (attr
->form
));
4241 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4244 display_loc_list (struct dwarf_section
*section
,
4245 unsigned char **start_ptr
,
4246 int debug_info_entry
,
4247 unsigned long offset
,
4248 unsigned long base_address
,
4251 unsigned char *start
= *start_ptr
;
4252 unsigned char *section_end
= section
->start
+ section
->size
;
4253 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4254 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4255 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4256 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4260 unsigned short length
;
4261 int need_frame_base
;
4263 if (pointer_size
< 2 || pointer_size
> 8)
4265 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4266 pointer_size
, debug_info_entry
);
4272 if (start
+ 2 * pointer_size
> section_end
)
4274 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4279 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4281 /* Note: we use sign extension here in order to be sure that we can detect
4282 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4283 address will not affect the values that we display since we always show
4284 hex values, and always the bottom 32-bits. */
4285 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4286 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4288 if (begin
== 0 && end
== 0)
4290 printf (_("<End of list>\n"));
4294 /* Check base address specifiers. */
4295 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4298 print_dwarf_vma (begin
, pointer_size
);
4299 print_dwarf_vma (end
, pointer_size
);
4300 printf (_("(base address)\n"));
4304 if (start
+ 2 > section_end
)
4306 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4311 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4313 if (start
+ length
> section_end
)
4315 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4320 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4321 print_dwarf_vma (end
+ base_address
, pointer_size
);
4324 need_frame_base
= decode_location_expression (start
,
4329 cu_offset
, section
);
4332 if (need_frame_base
&& !has_frame_base
)
4333 printf (_(" [without DW_AT_frame_base]"));
4336 fputs (_(" (start == end)"), stdout
);
4337 else if (begin
> end
)
4338 fputs (_(" (start > end)"), stdout
);
4348 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4349 right-adjusted in a field of length LEN, and followed by a space. */
4352 print_addr_index (unsigned int idx
, unsigned int len
)
4354 static char buf
[15];
4355 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4356 printf ("%*s ", len
, buf
);
4359 /* Display a location list from a .dwo section. It uses address indexes rather
4360 than embedded addresses. This code closely follows display_loc_list, but the
4361 two are sufficiently different that combining things is very ugly. */
4364 display_loc_list_dwo (struct dwarf_section
*section
,
4365 unsigned char **start_ptr
,
4366 int debug_info_entry
,
4367 unsigned long offset
,
4370 unsigned char *start
= *start_ptr
;
4371 unsigned char *section_end
= section
->start
+ section
->size
;
4372 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4373 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4374 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4375 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4377 unsigned short length
;
4378 int need_frame_base
;
4380 unsigned int bytes_read
;
4382 if (pointer_size
< 2 || pointer_size
> 8)
4384 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4385 pointer_size
, debug_info_entry
);
4391 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4393 if (start
>= section_end
)
4395 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4400 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4403 case 0: /* A terminating entry. */
4405 printf (_("<End of list>\n"));
4407 case 1: /* A base-address entry. */
4408 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4409 start
+= bytes_read
;
4410 print_addr_index (idx
, 8);
4412 printf (_("(base address selection entry)\n"));
4414 case 2: /* A start/end entry. */
4415 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4416 start
+= bytes_read
;
4417 print_addr_index (idx
, 8);
4418 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4419 start
+= bytes_read
;
4420 print_addr_index (idx
, 8);
4422 case 3: /* A start/length entry. */
4423 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4424 start
+= bytes_read
;
4425 print_addr_index (idx
, 8);
4426 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4427 printf ("%08x ", idx
);
4429 case 4: /* An offset pair entry. */
4430 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4431 printf ("%08x ", idx
);
4432 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4433 printf ("%08x ", idx
);
4436 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4441 if (start
+ 2 > section_end
)
4443 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4448 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4449 if (start
+ length
> section_end
)
4451 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4457 need_frame_base
= decode_location_expression (start
,
4462 cu_offset
, section
);
4465 if (need_frame_base
&& !has_frame_base
)
4466 printf (_(" [without DW_AT_frame_base]"));
4476 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4478 static dwarf_vma
*loc_offsets
;
4481 loc_offsets_compar (const void *ap
, const void *bp
)
4483 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4484 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4486 return (a
> b
) - (b
> a
);
4490 display_debug_loc (struct dwarf_section
*section
, void *file
)
4492 unsigned char *start
= section
->start
;
4493 unsigned long bytes
;
4494 unsigned char *section_begin
= start
;
4495 unsigned int num_loc_list
= 0;
4496 unsigned long last_offset
= 0;
4497 unsigned int first
= 0;
4501 int seen_first_offset
= 0;
4502 int locs_sorted
= 1;
4503 unsigned char *next
;
4504 unsigned int *array
= NULL
;
4505 const char *suffix
= strrchr (section
->name
, '.');
4508 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4511 bytes
= section
->size
;
4515 printf (_("\nThe %s section is empty.\n"), section
->name
);
4519 if (load_debug_info (file
) == 0)
4521 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4526 /* Check the order of location list in .debug_info section. If
4527 offsets of location lists are in the ascending order, we can
4528 use `debug_information' directly. */
4529 for (i
= 0; i
< num_debug_info_entries
; i
++)
4533 num
= debug_information
[i
].num_loc_offsets
;
4534 if (num
> num_loc_list
)
4537 /* Check if we can use `debug_information' directly. */
4538 if (locs_sorted
&& num
!= 0)
4540 if (!seen_first_offset
)
4542 /* This is the first location list. */
4543 last_offset
= debug_information
[i
].loc_offsets
[0];
4545 seen_first_offset
= 1;
4551 for (; j
< num
; j
++)
4554 debug_information
[i
].loc_offsets
[j
])
4559 last_offset
= debug_information
[i
].loc_offsets
[j
];
4564 if (!seen_first_offset
)
4565 error (_("No location lists in .debug_info section!\n"));
4567 if (debug_information
[first
].num_loc_offsets
> 0
4568 && debug_information
[first
].loc_offsets
[0] != 0)
4569 warn (_("Location lists in %s section start at 0x%s\n"),
4571 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4574 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4575 printf (_("Contents of the %s section:\n\n"), section
->name
);
4576 printf (_(" Offset Begin End Expression\n"));
4578 seen_first_offset
= 0;
4579 for (i
= first
; i
< num_debug_info_entries
; i
++)
4581 unsigned long offset
;
4582 unsigned long base_address
;
4587 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4589 loc_offsets
= debug_information
[i
].loc_offsets
;
4590 qsort (array
, debug_information
[i
].num_loc_offsets
,
4591 sizeof (*array
), loc_offsets_compar
);
4594 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4596 j
= locs_sorted
? k
: array
[k
];
4598 && debug_information
[i
].loc_offsets
[locs_sorted
4599 ? k
- 1 : array
[k
- 1]]
4600 == debug_information
[i
].loc_offsets
[j
])
4602 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4603 offset
= debug_information
[i
].loc_offsets
[j
];
4604 next
= section_begin
+ offset
;
4605 base_address
= debug_information
[i
].base_address
;
4607 if (!seen_first_offset
)
4608 seen_first_offset
= 1;
4612 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4613 (unsigned long) (start
- section_begin
),
4614 (unsigned long) (next
- section_begin
));
4615 else if (start
> next
)
4616 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4617 (unsigned long) (start
- section_begin
),
4618 (unsigned long) (next
- section_begin
));
4622 if (offset
>= bytes
)
4624 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4630 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4632 display_loc_list (section
, &start
, i
, offset
, base_address
,
4637 if (start
< section
->start
+ section
->size
)
4638 warn (_("There are %ld unused bytes at the end of section %s\n"),
4639 (long) (section
->start
+ section
->size
- start
), section
->name
);
4646 display_debug_str (struct dwarf_section
*section
,
4647 void *file ATTRIBUTE_UNUSED
)
4649 unsigned char *start
= section
->start
;
4650 unsigned long bytes
= section
->size
;
4651 dwarf_vma addr
= section
->address
;
4655 printf (_("\nThe %s section is empty.\n"), section
->name
);
4659 printf (_("Contents of the %s section:\n\n"), section
->name
);
4667 lbytes
= (bytes
> 16 ? 16 : bytes
);
4669 printf (" 0x%8.8lx ", (unsigned long) addr
);
4671 for (j
= 0; j
< 16; j
++)
4674 printf ("%2.2x", start
[j
]);
4682 for (j
= 0; j
< lbytes
; j
++)
4685 if (k
>= ' ' && k
< 0x80)
4704 display_debug_info (struct dwarf_section
*section
, void *file
)
4706 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4710 display_debug_types (struct dwarf_section
*section
, void *file
)
4712 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4716 display_trace_info (struct dwarf_section
*section
, void *file
)
4718 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4722 display_debug_aranges (struct dwarf_section
*section
,
4723 void *file ATTRIBUTE_UNUSED
)
4725 unsigned char *start
= section
->start
;
4726 unsigned char *end
= start
+ section
->size
;
4728 printf (_("Contents of the %s section:\n\n"), section
->name
);
4730 /* It does not matter if this load fails,
4731 we test for that later on. */
4732 load_debug_info (file
);
4736 unsigned char *hdrptr
;
4737 DWARF2_Internal_ARange arange
;
4738 unsigned char *addr_ranges
;
4741 unsigned char address_size
;
4743 unsigned int offset_size
;
4744 unsigned int initial_length_size
;
4748 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4749 if (arange
.ar_length
== 0xffffffff)
4751 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4753 initial_length_size
= 12;
4758 initial_length_size
= 4;
4761 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4762 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4764 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4765 && num_debug_info_entries
> 0
4766 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4767 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4768 (unsigned long) arange
.ar_info_offset
, section
->name
);
4770 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4771 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4773 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4775 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4779 printf (_(" Length: %ld\n"),
4780 (long) arange
.ar_length
);
4781 printf (_(" Version: %d\n"), arange
.ar_version
);
4782 printf (_(" Offset into .debug_info: 0x%lx\n"),
4783 (unsigned long) arange
.ar_info_offset
);
4784 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4785 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4787 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4789 /* PR 17512: file: 001-108546-0.001:0.1. */
4790 if (address_size
== 0 || address_size
> 8)
4792 error (_("Invalid address size in %s section!\n"),
4797 /* The DWARF spec does not require that the address size be a power
4798 of two, but we do. This will have to change if we ever encounter
4799 an uneven architecture. */
4800 if ((address_size
& (address_size
- 1)) != 0)
4802 warn (_("Pointer size + Segment size is not a power of two.\n"));
4806 if (address_size
> 4)
4807 printf (_("\n Address Length\n"));
4809 printf (_("\n Address Length\n"));
4811 addr_ranges
= hdrptr
;
4813 /* Must pad to an alignment boundary that is twice the address size. */
4814 excess
= (hdrptr
- start
) % (2 * address_size
);
4816 addr_ranges
+= (2 * address_size
) - excess
;
4818 start
+= arange
.ar_length
+ initial_length_size
;
4820 while (addr_ranges
+ 2 * address_size
<= start
)
4822 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4823 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4826 print_dwarf_vma (address
, address_size
);
4827 print_dwarf_vma (length
, address_size
);
4837 /* Comparison function for qsort. */
4839 comp_addr_base (const void * v0
, const void * v1
)
4841 debug_info
* info0
= (debug_info
*) v0
;
4842 debug_info
* info1
= (debug_info
*) v1
;
4843 return info0
->addr_base
- info1
->addr_base
;
4846 /* Display the debug_addr section. */
4848 display_debug_addr (struct dwarf_section
*section
,
4851 debug_info
**debug_addr_info
;
4852 unsigned char *entry
;
4857 if (section
->size
== 0)
4859 printf (_("\nThe %s section is empty.\n"), section
->name
);
4863 if (load_debug_info (file
) == 0)
4865 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4870 printf (_("Contents of the %s section:\n\n"), section
->name
);
4872 debug_addr_info
= (debug_info
**) xmalloc ((num_debug_info_entries
+ 1)
4873 * sizeof (debug_info
*));
4876 for (i
= 0; i
< num_debug_info_entries
; i
++)
4878 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4879 debug_addr_info
[count
++] = &debug_information
[i
];
4882 /* Add a sentinel to make iteration convenient. */
4883 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
4884 debug_addr_info
[count
]->addr_base
= section
->size
;
4886 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
4887 for (i
= 0; i
< count
; i
++)
4890 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
4892 printf (_(" For compilation unit at offset 0x%s:\n"),
4893 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
4895 printf (_("\tIndex\tAddress\n"));
4896 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
4897 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
4901 dwarf_vma base
= byte_get (entry
, address_size
);
4902 printf (_("\t%d:\t"), idx
);
4903 print_dwarf_vma (base
, address_size
);
4905 entry
+= address_size
;
4911 free (debug_addr_info
);
4915 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4917 display_debug_str_offsets (struct dwarf_section
*section
,
4918 void *file ATTRIBUTE_UNUSED
)
4920 if (section
->size
== 0)
4922 printf (_("\nThe %s section is empty.\n"), section
->name
);
4925 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
4926 what the offset size is for this section. */
4930 /* Each debug_information[x].range_lists[y] gets this representation for
4931 sorting purposes. */
4935 /* The debug_information[x].range_lists[y] value. */
4936 unsigned long ranges_offset
;
4938 /* Original debug_information to find parameters of the data. */
4939 debug_info
*debug_info_p
;
4942 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4945 range_entry_compar (const void *ap
, const void *bp
)
4947 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
4948 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
4949 const unsigned long a
= a_re
->ranges_offset
;
4950 const unsigned long b
= b_re
->ranges_offset
;
4952 return (a
> b
) - (b
> a
);
4956 display_debug_ranges (struct dwarf_section
*section
,
4957 void *file ATTRIBUTE_UNUSED
)
4959 unsigned char *start
= section
->start
;
4960 unsigned char *last_start
= start
;
4961 unsigned long bytes
= section
->size
;
4962 unsigned char *section_begin
= start
;
4963 unsigned char *finish
= start
+ bytes
;
4964 unsigned int num_range_list
, i
;
4965 struct range_entry
*range_entries
, *range_entry_fill
;
4969 printf (_("\nThe %s section is empty.\n"), section
->name
);
4973 if (load_debug_info (file
) == 0)
4975 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4981 for (i
= 0; i
< num_debug_info_entries
; i
++)
4982 num_range_list
+= debug_information
[i
].num_range_lists
;
4984 if (num_range_list
== 0)
4986 /* This can happen when the file was compiled with -gsplit-debug
4987 which removes references to range lists from the primary .o file. */
4988 printf (_("No range lists in .debug_info section.\n"));
4992 range_entries
= (struct range_entry
*)
4993 xmalloc (sizeof (*range_entries
) * num_range_list
);
4994 range_entry_fill
= range_entries
;
4996 for (i
= 0; i
< num_debug_info_entries
; i
++)
4998 debug_info
*debug_info_p
= &debug_information
[i
];
5001 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
5003 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
5004 range_entry_fill
->debug_info_p
= debug_info_p
;
5009 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
5010 range_entry_compar
);
5012 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
5013 warn (_("Range lists in %s section start at 0x%lx\n"),
5014 section
->name
, range_entries
[0].ranges_offset
);
5016 printf (_("Contents of the %s section:\n\n"), section
->name
);
5017 printf (_(" Offset Begin End\n"));
5019 for (i
= 0; i
< num_range_list
; i
++)
5021 struct range_entry
*range_entry
= &range_entries
[i
];
5022 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
5023 unsigned int pointer_size
;
5024 unsigned long offset
;
5025 unsigned char *next
;
5026 unsigned long base_address
;
5028 pointer_size
= debug_info_p
->pointer_size
;
5029 offset
= range_entry
->ranges_offset
;
5030 next
= section_begin
+ offset
;
5031 base_address
= debug_info_p
->base_address
;
5033 /* PR 17512: file: 001-101485-0.001:0.1. */
5034 if (pointer_size
< 2 || pointer_size
> 8)
5036 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5037 pointer_size
, offset
);
5041 if (dwarf_check
!= 0 && i
> 0)
5044 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5045 (unsigned long) (start
- section_begin
),
5046 (unsigned long) (next
- section_begin
), section
->name
);
5047 else if (start
> next
)
5049 if (next
== last_start
)
5051 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5052 (unsigned long) (start
- section_begin
),
5053 (unsigned long) (next
- section_begin
), section
->name
);
5059 while (start
< finish
)
5064 /* Note: we use sign extension here in order to be sure that
5065 we can detect the -1 escape value. Sign extension into the
5066 top 32 bits of a 32-bit address will not affect the values
5067 that we display since we always show hex values, and always
5068 the bottom 32-bits. */
5069 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
5070 if (start
>= finish
)
5072 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
5074 printf (" %8.8lx ", offset
);
5076 if (begin
== 0 && end
== 0)
5078 printf (_("<End of list>\n"));
5082 /* Check base address specifiers. */
5083 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
5086 print_dwarf_vma (begin
, pointer_size
);
5087 print_dwarf_vma (end
, pointer_size
);
5088 printf ("(base address)\n");
5092 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5093 print_dwarf_vma (end
+ base_address
, pointer_size
);
5096 fputs (_("(start == end)"), stdout
);
5097 else if (begin
> end
)
5098 fputs (_("(start > end)"), stdout
);
5105 free (range_entries
);
5110 typedef struct Frame_Chunk
5112 struct Frame_Chunk
*next
;
5113 unsigned char *chunk_start
;
5115 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5116 short int *col_type
;
5119 unsigned int code_factor
;
5126 unsigned char fde_encoding
;
5127 unsigned char cfa_exp
;
5128 unsigned char ptr_size
;
5129 unsigned char segment_size
;
5133 static const char *const *dwarf_regnames
;
5134 static unsigned int dwarf_regnames_count
;
5136 /* A marker for a col_type that means this column was never referenced
5137 in the frame info. */
5138 #define DW_CFA_unreferenced (-1)
5140 /* Return 0 if no more space is needed, 1 if more space is needed,
5141 -1 for invalid reg. */
5144 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
5146 unsigned int prev
= fc
->ncols
;
5148 if (reg
< (unsigned int) fc
->ncols
)
5151 if (dwarf_regnames_count
5152 && reg
> dwarf_regnames_count
)
5155 fc
->ncols
= reg
+ 1;
5156 /* PR 17512: file: 10450-2643-0.004.
5157 If reg == -1 then this can happen... */
5161 /* PR 17512: file: 2844a11d. */
5162 if (fc
->ncols
> 1024)
5164 error (_("Unfeasibly large register number: %u\n"), reg
);
5166 /* FIXME: 1024 is an arbitrary limit. Increase it if
5167 we ever encounter a valid binary that exceeds it. */
5171 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
5172 sizeof (short int));
5173 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
5174 /* PR 17512: file:002-10025-0.005. */
5175 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
5177 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5183 while (prev
< fc
->ncols
)
5185 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
5186 fc
->col_offset
[prev
] = 0;
5192 static const char *const dwarf_regnames_i386
[] =
5194 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5195 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5196 "eip", "eflags", NULL
, /* 8 - 10 */
5197 "st0", "st1", "st2", "st3", /* 11 - 14 */
5198 "st4", "st5", "st6", "st7", /* 15 - 18 */
5199 NULL
, NULL
, /* 19 - 20 */
5200 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5201 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5202 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5203 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5204 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5205 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5206 "tr", "ldtr", /* 48 - 49 */
5207 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5208 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5209 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5210 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5211 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5212 NULL
, NULL
, NULL
, /* 90 - 92 */
5213 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5217 init_dwarf_regnames_i386 (void)
5219 dwarf_regnames
= dwarf_regnames_i386
;
5220 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5223 static const char *const dwarf_regnames_x86_64
[] =
5225 "rax", "rdx", "rcx", "rbx",
5226 "rsi", "rdi", "rbp", "rsp",
5227 "r8", "r9", "r10", "r11",
5228 "r12", "r13", "r14", "r15",
5230 "xmm0", "xmm1", "xmm2", "xmm3",
5231 "xmm4", "xmm5", "xmm6", "xmm7",
5232 "xmm8", "xmm9", "xmm10", "xmm11",
5233 "xmm12", "xmm13", "xmm14", "xmm15",
5234 "st0", "st1", "st2", "st3",
5235 "st4", "st5", "st6", "st7",
5236 "mm0", "mm1", "mm2", "mm3",
5237 "mm4", "mm5", "mm6", "mm7",
5239 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5240 "fs.base", "gs.base", NULL
, NULL
,
5242 "mxcsr", "fcw", "fsw",
5243 "xmm16", "xmm17", "xmm18", "xmm19",
5244 "xmm20", "xmm21", "xmm22", "xmm23",
5245 "xmm24", "xmm25", "xmm26", "xmm27",
5246 "xmm28", "xmm29", "xmm30", "xmm31",
5247 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5248 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5249 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5250 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5251 NULL
, NULL
, NULL
, /* 115 - 117 */
5252 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5256 init_dwarf_regnames_x86_64 (void)
5258 dwarf_regnames
= dwarf_regnames_x86_64
;
5259 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5262 static const char *const dwarf_regnames_aarch64
[] =
5264 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5265 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5266 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5267 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5268 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5269 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5270 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5271 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5272 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5273 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5274 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5275 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5279 init_dwarf_regnames_aarch64 (void)
5281 dwarf_regnames
= dwarf_regnames_aarch64
;
5282 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
5286 init_dwarf_regnames (unsigned int e_machine
)
5292 init_dwarf_regnames_i386 ();
5298 init_dwarf_regnames_x86_64 ();
5302 init_dwarf_regnames_aarch64 ();
5311 regname (unsigned int regno
, int row
)
5313 static char reg
[64];
5315 && regno
< dwarf_regnames_count
5316 && dwarf_regnames
[regno
] != NULL
)
5319 return dwarf_regnames
[regno
];
5320 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5321 dwarf_regnames
[regno
]);
5324 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5329 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
5334 if (*max_regs
< fc
->ncols
)
5335 *max_regs
= fc
->ncols
;
5337 if (*need_col_headers
)
5339 static const char *sloc
= " LOC";
5341 *need_col_headers
= 0;
5343 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5345 for (r
= 0; r
< *max_regs
; r
++)
5346 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5351 printf ("%-5s ", regname (r
, 1));
5357 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5359 strcpy (tmp
, "exp");
5361 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5362 printf ("%-8s ", tmp
);
5364 for (r
= 0; r
< fc
->ncols
; r
++)
5366 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5368 switch (fc
->col_type
[r
])
5370 case DW_CFA_undefined
:
5373 case DW_CFA_same_value
:
5377 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5379 case DW_CFA_val_offset
:
5380 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5382 case DW_CFA_register
:
5383 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5385 case DW_CFA_expression
:
5386 strcpy (tmp
, "exp");
5388 case DW_CFA_val_expression
:
5389 strcpy (tmp
, "vexp");
5392 strcpy (tmp
, "n/a");
5395 printf ("%-5s ", tmp
);
5401 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5402 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5403 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5405 static unsigned char *
5406 read_cie (unsigned char *start
, unsigned char *end
,
5407 Frame_Chunk
**p_cie
, int *p_version
,
5408 unsigned long *p_aug_len
, unsigned char **p_aug
)
5412 unsigned int length_return
;
5413 unsigned char *augmentation_data
= NULL
;
5414 unsigned long augmentation_data_len
= 0;
5417 /* PR 17512: file: 001-228113-0.004. */
5421 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5422 memset (fc
, 0, sizeof (Frame_Chunk
));
5424 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5425 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5429 fc
->augmentation
= (char *) start
;
5430 /* PR 17512: file: 001-228113-0.004.
5431 Skip past augmentation name, but avoid running off the end of the data. */
5433 if (* start
++ == '\0')
5437 warn (_("No terminator for augmentation name\n"));
5441 if (strcmp (fc
->augmentation
, "eh") == 0)
5442 start
+= eh_addr_size
;
5446 GET (fc
->ptr_size
, 1);
5447 GET (fc
->segment_size
, 1);
5448 eh_addr_size
= fc
->ptr_size
;
5452 fc
->ptr_size
= eh_addr_size
;
5453 fc
->segment_size
= 0;
5455 fc
->code_factor
= LEB ();
5456 fc
->data_factor
= SLEB ();
5466 if (fc
->augmentation
[0] == 'z')
5468 augmentation_data_len
= LEB ();
5469 augmentation_data
= start
;
5470 start
+= augmentation_data_len
;
5471 /* PR 17512: file: 11042-2589-0.004. */
5474 warn (_("Augmentation data too long: 0x%lx"), augmentation_data_len
);
5479 if (augmentation_data_len
)
5481 unsigned char *p
, *q
;
5482 p
= (unsigned char *) fc
->augmentation
+ 1;
5483 q
= augmentation_data
;
5485 while (p
< end
&& q
< augmentation_data
+ augmentation_data_len
)
5490 q
+= 1 + size_of_encoded_value (*q
);
5492 fc
->fde_encoding
= *q
++;
5503 *p_version
= version
;
5506 *p_aug_len
= augmentation_data_len
;
5507 *p_aug
= augmentation_data
;
5513 display_debug_frames (struct dwarf_section
*section
,
5514 void *file ATTRIBUTE_UNUSED
)
5516 unsigned char *start
= section
->start
;
5517 unsigned char *end
= start
+ section
->size
;
5518 unsigned char *section_start
= start
;
5519 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
5520 Frame_Chunk
*remembered_state
= 0;
5522 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5523 unsigned int length_return
;
5524 unsigned int max_regs
= 0;
5525 const char *bad_reg
= _("bad register: ");
5526 int saved_eh_addr_size
= eh_addr_size
;
5528 printf (_("Contents of the %s section:\n"), section
->name
);
5532 unsigned char *saved_start
;
5533 unsigned char *block_end
;
5538 int need_col_headers
= 1;
5539 unsigned char *augmentation_data
= NULL
;
5540 unsigned long augmentation_data_len
= 0;
5541 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5542 unsigned int offset_size
;
5543 unsigned int initial_length_size
;
5545 saved_start
= start
;
5547 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5551 printf ("\n%08lx ZERO terminator\n\n",
5552 (unsigned long)(saved_start
- section_start
));
5553 /* Skip any zero terminators that directly follow.
5554 A corrupt section size could have loaded a whole
5555 slew of zero filled memory bytes. eg
5556 PR 17512: file: 070-19381-0.004. */
5557 while (start
< end
&& * start
== 0)
5562 if (length
== 0xffffffff)
5564 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5566 initial_length_size
= 12;
5571 initial_length_size
= 4;
5574 block_end
= saved_start
+ length
+ initial_length_size
;
5575 if (block_end
> end
|| block_end
< start
)
5577 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5578 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5579 (unsigned long) (saved_start
- section_start
));
5583 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5585 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5586 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5591 start
= read_cie (start
, end
, &cie
, &version
,
5592 &augmentation_data_len
, &augmentation_data
);
5593 /* PR 17512: file: 027-135133-0.005. */
5600 fc
->chunk_start
= saved_start
;
5601 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5604 if (frame_need_space (fc
, mreg
) < 0)
5606 if (fc
->fde_encoding
)
5607 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5609 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5610 print_dwarf_vma (length
, fc
->ptr_size
);
5611 print_dwarf_vma (cie_id
, offset_size
);
5613 if (do_debug_frames_interp
)
5615 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5616 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5621 printf (" Version: %d\n", version
);
5622 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5625 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5626 printf (" Segment Size: %u\n", fc
->segment_size
);
5628 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5629 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5630 printf (" Return address column: %d\n", fc
->ra
);
5632 if (augmentation_data_len
)
5636 printf (" Augmentation data: ");
5637 for (i
= 0; i
< augmentation_data_len
; ++i
)
5638 /* FIXME: If do_wide is FALSE, then we should
5639 add carriage returns at 80 columns... */
5640 printf (" %02x", augmentation_data
[i
]);
5648 unsigned char *look_for
;
5649 static Frame_Chunk fde_fc
;
5650 unsigned long segment_selector
;
5654 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
5655 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
5658 look_for
= section_start
+ cie_id
;
5660 if (look_for
<= saved_start
)
5662 for (cie
= chunks
; cie
; cie
= cie
->next
)
5663 if (cie
->chunk_start
== look_for
)
5668 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
5669 if (cie
->chunk_start
== look_for
)
5673 unsigned int off_size
;
5674 unsigned char *cie_scan
;
5676 cie_scan
= look_for
;
5678 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
5679 if (length
== 0xffffffff)
5681 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
5688 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
5691 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
5692 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
5697 read_cie (cie_scan
, end
, &cie
, &version
,
5698 &augmentation_data_len
, &augmentation_data
);
5699 /* PR 17512: file: 3450-2098-0.004. */
5702 warn (_("Failed to read CIE information\n"));
5705 cie
->next
= forward_refs
;
5707 cie
->chunk_start
= look_for
;
5708 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5711 if (frame_need_space (cie
, mreg
) < 0)
5713 warn (_("Invalid max register\n"));
5716 if (cie
->fde_encoding
)
5718 = size_of_encoded_value (cie
->fde_encoding
);
5725 memset (fc
, 0, sizeof (Frame_Chunk
));
5729 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5730 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5731 (unsigned long) (saved_start
- section_start
));
5733 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5734 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5735 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
5737 warn (_("Invalid max register\n"));
5741 fc
->augmentation
= "";
5742 fc
->fde_encoding
= 0;
5743 fc
->ptr_size
= eh_addr_size
;
5744 fc
->segment_size
= 0;
5748 fc
->ncols
= cie
->ncols
;
5749 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5750 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5751 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5752 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5753 fc
->augmentation
= cie
->augmentation
;
5754 fc
->ptr_size
= cie
->ptr_size
;
5755 eh_addr_size
= cie
->ptr_size
;
5756 fc
->segment_size
= cie
->segment_size
;
5757 fc
->code_factor
= cie
->code_factor
;
5758 fc
->data_factor
= cie
->data_factor
;
5759 fc
->cfa_reg
= cie
->cfa_reg
;
5760 fc
->cfa_offset
= cie
->cfa_offset
;
5762 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
5764 warn (_("Invalid max register\n"));
5767 fc
->fde_encoding
= cie
->fde_encoding
;
5770 if (fc
->fde_encoding
)
5771 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5773 segment_selector
= 0;
5774 if (fc
->segment_size
)
5775 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5777 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
5779 /* FIXME: It appears that sometimes the final pc_range value is
5780 encoded in less than encoded_ptr_size bytes. See the x86_64
5781 run of the "objcopy on compressed debug sections" test for an
5783 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5785 if (cie
->augmentation
[0] == 'z')
5787 augmentation_data_len
= LEB ();
5788 augmentation_data
= start
;
5789 start
+= augmentation_data_len
;
5790 /* PR 17512: file: 722-8446-0.004. */
5791 if (start
>= end
|| ((signed long) augmentation_data_len
) < 0)
5793 warn (_("Corrupt augmentation data length: %lx\n"),
5794 augmentation_data_len
);
5796 augmentation_data
= NULL
;
5797 augmentation_data_len
= 0;
5801 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5802 (unsigned long)(saved_start
- section_start
),
5803 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
5804 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5805 (unsigned long)(cie
->chunk_start
- section_start
));
5807 if (fc
->segment_size
)
5808 printf ("%04lx:", segment_selector
);
5811 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
5812 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
5814 if (! do_debug_frames_interp
&& augmentation_data_len
)
5818 printf (" Augmentation data: ");
5819 for (i
= 0; i
< augmentation_data_len
; ++i
)
5820 printf (" %02x", augmentation_data
[i
]);
5826 /* At this point, fc is the current chunk, cie (if any) is set, and
5827 we're about to interpret instructions for the chunk. */
5828 /* ??? At present we need to do this always, since this sizes the
5829 fc->col_type and fc->col_offset arrays, which we write into always.
5830 We should probably split the interpreted and non-interpreted bits
5831 into two different routines, since there's so much that doesn't
5832 really overlap between them. */
5833 if (1 || do_debug_frames_interp
)
5835 /* Start by making a pass over the chunk, allocating storage
5836 and taking note of what registers are used. */
5837 unsigned char *tmp
= start
;
5839 while (start
< block_end
)
5841 unsigned int reg
, op
, opa
;
5849 /* Warning: if you add any more cases to this switch, be
5850 sure to add them to the corresponding switch below. */
5853 case DW_CFA_advance_loc
:
5857 if (frame_need_space (fc
, opa
) >= 0)
5858 fc
->col_type
[opa
] = DW_CFA_undefined
;
5860 case DW_CFA_restore
:
5861 if (frame_need_space (fc
, opa
) >= 0)
5862 fc
->col_type
[opa
] = DW_CFA_undefined
;
5864 case DW_CFA_set_loc
:
5865 start
+= encoded_ptr_size
;
5867 case DW_CFA_advance_loc1
:
5870 case DW_CFA_advance_loc2
:
5873 case DW_CFA_advance_loc4
:
5876 case DW_CFA_offset_extended
:
5877 case DW_CFA_val_offset
:
5878 reg
= LEB (); LEB ();
5879 if (frame_need_space (fc
, reg
) >= 0)
5880 fc
->col_type
[reg
] = DW_CFA_undefined
;
5882 case DW_CFA_restore_extended
:
5884 if (frame_need_space (fc
, reg
) >= 0)
5885 fc
->col_type
[reg
] = DW_CFA_undefined
;
5887 case DW_CFA_undefined
:
5889 if (frame_need_space (fc
, reg
) >= 0)
5890 fc
->col_type
[reg
] = DW_CFA_undefined
;
5892 case DW_CFA_same_value
:
5894 if (frame_need_space (fc
, reg
) >= 0)
5895 fc
->col_type
[reg
] = DW_CFA_undefined
;
5897 case DW_CFA_register
:
5898 reg
= LEB (); LEB ();
5899 if (frame_need_space (fc
, reg
) >= 0)
5900 fc
->col_type
[reg
] = DW_CFA_undefined
;
5902 case DW_CFA_def_cfa
:
5905 case DW_CFA_def_cfa_register
:
5908 case DW_CFA_def_cfa_offset
:
5911 case DW_CFA_def_cfa_expression
:
5913 if (start
+ temp
< start
)
5915 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
5921 case DW_CFA_expression
:
5922 case DW_CFA_val_expression
:
5925 if (start
+ temp
< start
)
5927 /* PR 17512: file:306-192417-0.005. */
5928 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
5933 if (frame_need_space (fc
, reg
) >= 0)
5934 fc
->col_type
[reg
] = DW_CFA_undefined
;
5936 case DW_CFA_offset_extended_sf
:
5937 case DW_CFA_val_offset_sf
:
5938 reg
= LEB (); SLEB ();
5939 if (frame_need_space (fc
, reg
) >= 0)
5940 fc
->col_type
[reg
] = DW_CFA_undefined
;
5942 case DW_CFA_def_cfa_sf
:
5945 case DW_CFA_def_cfa_offset_sf
:
5948 case DW_CFA_MIPS_advance_loc8
:
5951 case DW_CFA_GNU_args_size
:
5954 case DW_CFA_GNU_negative_offset_extended
:
5955 reg
= LEB (); LEB ();
5956 if (frame_need_space (fc
, reg
) >= 0)
5957 fc
->col_type
[reg
] = DW_CFA_undefined
;
5966 /* Now we know what registers are used, make a second pass over
5967 the chunk, this time actually printing out the info. */
5969 while (start
< block_end
)
5972 unsigned long ul
, reg
, roffs
;
5976 const char *reg_prefix
= "";
5983 /* Warning: if you add any more cases to this switch, be
5984 sure to add them to the corresponding switch above. */
5987 case DW_CFA_advance_loc
:
5988 if (do_debug_frames_interp
)
5989 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5991 printf (" DW_CFA_advance_loc: %d to %s\n",
5992 opa
* fc
->code_factor
,
5993 dwarf_vmatoa_1 (NULL
,
5994 fc
->pc_begin
+ opa
* fc
->code_factor
,
5996 fc
->pc_begin
+= opa
* fc
->code_factor
;
6001 if (opa
>= (unsigned int) fc
->ncols
)
6002 reg_prefix
= bad_reg
;
6003 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6004 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6005 reg_prefix
, regname (opa
, 0),
6006 roffs
* fc
->data_factor
);
6007 if (*reg_prefix
== '\0')
6009 fc
->col_type
[opa
] = DW_CFA_offset
;
6010 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
6014 case DW_CFA_restore
:
6015 if (opa
>= (unsigned int) cie
->ncols
6016 || opa
>= (unsigned int) fc
->ncols
)
6017 reg_prefix
= bad_reg
;
6018 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6019 printf (" DW_CFA_restore: %s%s\n",
6020 reg_prefix
, regname (opa
, 0));
6021 if (*reg_prefix
== '\0')
6023 fc
->col_type
[opa
] = cie
->col_type
[opa
];
6024 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
6025 if (do_debug_frames_interp
6026 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
6027 fc
->col_type
[opa
] = DW_CFA_undefined
;
6031 case DW_CFA_set_loc
:
6032 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
6033 if (do_debug_frames_interp
)
6034 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6036 printf (" DW_CFA_set_loc: %s\n",
6037 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
6041 case DW_CFA_advance_loc1
:
6042 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
6043 if (do_debug_frames_interp
)
6044 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6046 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6047 (unsigned long) (ofs
* fc
->code_factor
),
6048 dwarf_vmatoa_1 (NULL
,
6049 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6051 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6054 case DW_CFA_advance_loc2
:
6055 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
6056 if (do_debug_frames_interp
)
6057 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6059 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6060 (unsigned long) (ofs
* fc
->code_factor
),
6061 dwarf_vmatoa_1 (NULL
,
6062 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6064 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6067 case DW_CFA_advance_loc4
:
6068 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
6069 if (do_debug_frames_interp
)
6070 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6072 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6073 (unsigned long) (ofs
* fc
->code_factor
),
6074 dwarf_vmatoa_1 (NULL
,
6075 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6077 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6080 case DW_CFA_offset_extended
:
6083 if (reg
>= (unsigned int) fc
->ncols
)
6084 reg_prefix
= bad_reg
;
6085 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6086 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6087 reg_prefix
, regname (reg
, 0),
6088 roffs
* fc
->data_factor
);
6089 if (*reg_prefix
== '\0')
6091 fc
->col_type
[reg
] = DW_CFA_offset
;
6092 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6096 case DW_CFA_val_offset
:
6099 if (reg
>= (unsigned int) fc
->ncols
)
6100 reg_prefix
= bad_reg
;
6101 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6102 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6103 reg_prefix
, regname (reg
, 0),
6104 roffs
* fc
->data_factor
);
6105 if (*reg_prefix
== '\0')
6107 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6108 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6112 case DW_CFA_restore_extended
:
6114 if (reg
>= (unsigned int) cie
->ncols
6115 || reg
>= (unsigned int) fc
->ncols
)
6116 reg_prefix
= bad_reg
;
6117 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6118 printf (" DW_CFA_restore_extended: %s%s\n",
6119 reg_prefix
, regname (reg
, 0));
6120 if (*reg_prefix
== '\0')
6122 fc
->col_type
[reg
] = cie
->col_type
[reg
];
6123 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
6127 case DW_CFA_undefined
:
6129 if (reg
>= (unsigned int) fc
->ncols
)
6130 reg_prefix
= bad_reg
;
6131 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6132 printf (" DW_CFA_undefined: %s%s\n",
6133 reg_prefix
, regname (reg
, 0));
6134 if (*reg_prefix
== '\0')
6136 fc
->col_type
[reg
] = DW_CFA_undefined
;
6137 fc
->col_offset
[reg
] = 0;
6141 case DW_CFA_same_value
:
6143 if (reg
>= (unsigned int) fc
->ncols
)
6144 reg_prefix
= bad_reg
;
6145 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6146 printf (" DW_CFA_same_value: %s%s\n",
6147 reg_prefix
, regname (reg
, 0));
6148 if (*reg_prefix
== '\0')
6150 fc
->col_type
[reg
] = DW_CFA_same_value
;
6151 fc
->col_offset
[reg
] = 0;
6155 case DW_CFA_register
:
6158 if (reg
>= (unsigned int) fc
->ncols
)
6159 reg_prefix
= bad_reg
;
6160 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6162 printf (" DW_CFA_register: %s%s in ",
6163 reg_prefix
, regname (reg
, 0));
6164 puts (regname (roffs
, 0));
6166 if (*reg_prefix
== '\0')
6168 fc
->col_type
[reg
] = DW_CFA_register
;
6169 fc
->col_offset
[reg
] = roffs
;
6173 case DW_CFA_remember_state
:
6174 if (! do_debug_frames_interp
)
6175 printf (" DW_CFA_remember_state\n");
6176 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6177 rs
->cfa_offset
= fc
->cfa_offset
;
6178 rs
->cfa_reg
= fc
->cfa_reg
;
6180 rs
->cfa_exp
= fc
->cfa_exp
;
6181 rs
->ncols
= fc
->ncols
;
6182 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
6183 sizeof (* rs
->col_type
));
6184 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
6185 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
6186 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
6187 rs
->next
= remembered_state
;
6188 remembered_state
= rs
;
6191 case DW_CFA_restore_state
:
6192 if (! do_debug_frames_interp
)
6193 printf (" DW_CFA_restore_state\n");
6194 rs
= remembered_state
;
6197 remembered_state
= rs
->next
;
6198 fc
->cfa_offset
= rs
->cfa_offset
;
6199 fc
->cfa_reg
= rs
->cfa_reg
;
6201 fc
->cfa_exp
= rs
->cfa_exp
;
6202 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
6204 warn (_("Invalid column number in saved frame state"));
6208 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
6209 memcpy (fc
->col_offset
, rs
->col_offset
,
6210 rs
->ncols
* sizeof (* rs
->col_offset
));
6211 free (rs
->col_type
);
6212 free (rs
->col_offset
);
6215 else if (do_debug_frames_interp
)
6216 printf ("Mismatched DW_CFA_restore_state\n");
6219 case DW_CFA_def_cfa
:
6220 fc
->cfa_reg
= LEB ();
6221 fc
->cfa_offset
= LEB ();
6223 if (! do_debug_frames_interp
)
6224 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6225 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6228 case DW_CFA_def_cfa_register
:
6229 fc
->cfa_reg
= LEB ();
6231 if (! do_debug_frames_interp
)
6232 printf (" DW_CFA_def_cfa_register: %s\n",
6233 regname (fc
->cfa_reg
, 0));
6236 case DW_CFA_def_cfa_offset
:
6237 fc
->cfa_offset
= LEB ();
6238 if (! do_debug_frames_interp
)
6239 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
6243 if (! do_debug_frames_interp
)
6244 printf (" DW_CFA_nop\n");
6247 case DW_CFA_def_cfa_expression
:
6249 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6251 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
6254 if (! do_debug_frames_interp
)
6256 printf (" DW_CFA_def_cfa_expression (");
6257 decode_location_expression (start
, eh_addr_size
, 0, -1,
6265 case DW_CFA_expression
:
6268 if (reg
>= (unsigned int) fc
->ncols
)
6269 reg_prefix
= bad_reg
;
6270 /* PR 17512: file: 069-133014-0.006. */
6271 /* PR 17512: file: 98c02eb4. */
6272 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6274 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
6277 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6279 printf (" DW_CFA_expression: %s%s (",
6280 reg_prefix
, regname (reg
, 0));
6281 decode_location_expression (start
, eh_addr_size
, 0, -1,
6285 if (*reg_prefix
== '\0')
6286 fc
->col_type
[reg
] = DW_CFA_expression
;
6290 case DW_CFA_val_expression
:
6293 if (reg
>= (unsigned int) fc
->ncols
)
6294 reg_prefix
= bad_reg
;
6295 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6297 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
6300 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6302 printf (" DW_CFA_val_expression: %s%s (",
6303 reg_prefix
, regname (reg
, 0));
6304 decode_location_expression (start
, eh_addr_size
, 0, -1,
6308 if (*reg_prefix
== '\0')
6309 fc
->col_type
[reg
] = DW_CFA_val_expression
;
6313 case DW_CFA_offset_extended_sf
:
6316 if (frame_need_space (fc
, reg
) < 0)
6317 reg_prefix
= bad_reg
;
6318 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6319 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6320 reg_prefix
, regname (reg
, 0),
6321 l
* fc
->data_factor
);
6322 if (*reg_prefix
== '\0')
6324 fc
->col_type
[reg
] = DW_CFA_offset
;
6325 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6329 case DW_CFA_val_offset_sf
:
6332 if (frame_need_space (fc
, reg
) < 0)
6333 reg_prefix
= bad_reg
;
6334 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6335 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6336 reg_prefix
, regname (reg
, 0),
6337 l
* fc
->data_factor
);
6338 if (*reg_prefix
== '\0')
6340 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6341 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6345 case DW_CFA_def_cfa_sf
:
6346 fc
->cfa_reg
= LEB ();
6347 fc
->cfa_offset
= SLEB ();
6348 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6350 if (! do_debug_frames_interp
)
6351 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6352 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6355 case DW_CFA_def_cfa_offset_sf
:
6356 fc
->cfa_offset
= SLEB ();
6357 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6358 if (! do_debug_frames_interp
)
6359 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
6362 case DW_CFA_MIPS_advance_loc8
:
6363 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
6364 if (do_debug_frames_interp
)
6365 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6367 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6368 (unsigned long) (ofs
* fc
->code_factor
),
6369 dwarf_vmatoa_1 (NULL
,
6370 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6372 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6375 case DW_CFA_GNU_window_save
:
6376 if (! do_debug_frames_interp
)
6377 printf (" DW_CFA_GNU_window_save\n");
6380 case DW_CFA_GNU_args_size
:
6382 if (! do_debug_frames_interp
)
6383 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
6386 case DW_CFA_GNU_negative_offset_extended
:
6389 if (frame_need_space (fc
, reg
) < 0)
6390 reg_prefix
= bad_reg
;
6391 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6392 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6393 reg_prefix
, regname (reg
, 0),
6394 l
* fc
->data_factor
);
6395 if (*reg_prefix
== '\0')
6397 fc
->col_type
[reg
] = DW_CFA_offset
;
6398 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6403 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
6404 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
6406 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
6411 if (do_debug_frames_interp
)
6412 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6415 eh_addr_size
= saved_eh_addr_size
;
6428 display_gdb_index (struct dwarf_section
*section
,
6429 void *file ATTRIBUTE_UNUSED
)
6431 unsigned char *start
= section
->start
;
6433 uint32_t cu_list_offset
, tu_list_offset
;
6434 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6435 unsigned int cu_list_elements
, tu_list_elements
;
6436 unsigned int address_table_size
, symbol_table_slots
;
6437 unsigned char *cu_list
, *tu_list
;
6438 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6441 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6443 printf (_("Contents of the %s section:\n"), section
->name
);
6445 if (section
->size
< 6 * sizeof (uint32_t))
6447 warn (_("Truncated header in the %s section.\n"), section
->name
);
6451 version
= byte_get_little_endian (start
, 4);
6452 printf (_("Version %ld\n"), (long) version
);
6454 /* Prior versions are obsolete, and future versions may not be
6455 backwards compatible. */
6456 if (version
< 3 || version
> 8)
6458 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6462 warn (_("The address table data in version 3 may be wrong.\n"));
6464 warn (_("Version 4 does not support case insensitive lookups.\n"));
6466 warn (_("Version 5 does not include inlined functions.\n"));
6468 warn (_("Version 6 does not include symbol attributes.\n"));
6469 /* Version 7 indices generated by Gold have bad type unit references,
6470 PR binutils/15021. But we don't know if the index was generated by
6471 Gold or not, so to avoid worrying users with gdb-generated indices
6472 we say nothing for version 7 here. */
6474 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6475 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6476 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6477 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6478 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6480 if (cu_list_offset
> section
->size
6481 || tu_list_offset
> section
->size
6482 || address_table_offset
> section
->size
6483 || symbol_table_offset
> section
->size
6484 || constant_pool_offset
> section
->size
)
6486 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6490 /* PR 17531: file: 418d0a8a. */
6491 if (tu_list_offset
< cu_list_offset
)
6493 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6494 tu_list_offset
, cu_list_offset
);
6498 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6500 if (address_table_offset
< tu_list_offset
)
6502 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6503 address_table_offset
, tu_list_offset
);
6507 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6509 /* PR 17531: file: 18a47d3d. */
6510 if (symbol_table_offset
< address_table_offset
)
6512 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6513 symbol_table_offset
, address_table_offset
);
6517 address_table_size
= symbol_table_offset
- address_table_offset
;
6519 if (constant_pool_offset
< symbol_table_offset
)
6521 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6522 constant_pool_offset
, symbol_table_offset
);
6526 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6528 cu_list
= start
+ cu_list_offset
;
6529 tu_list
= start
+ tu_list_offset
;
6530 address_table
= start
+ address_table_offset
;
6531 symbol_table
= start
+ symbol_table_offset
;
6532 constant_pool
= start
+ constant_pool_offset
;
6534 if (address_table
+ address_table_size
* (2 + 8 + 4) > section
->start
+ section
->size
)
6536 warn (_("Address table extends beyond end of section. %x"), address_table_size
);
6540 printf (_("\nCU table:\n"));
6541 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6543 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6544 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6546 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6547 (unsigned long) cu_offset
,
6548 (unsigned long) (cu_offset
+ cu_length
- 1));
6551 printf (_("\nTU table:\n"));
6552 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6554 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6555 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6556 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6558 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6559 (unsigned long) tu_offset
,
6560 (unsigned long) type_offset
);
6561 print_dwarf_vma (signature
, 8);
6565 printf (_("\nAddress table:\n"));
6566 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
6569 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6570 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6571 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6573 print_dwarf_vma (low
, 8);
6574 print_dwarf_vma (high
, 8);
6575 printf (_("%lu\n"), (unsigned long) cu_index
);
6578 printf (_("\nSymbol table:\n"));
6579 for (i
= 0; i
< symbol_table_slots
; ++i
)
6581 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6582 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6583 uint32_t num_cus
, cu
;
6585 if (name_offset
!= 0
6586 || cu_vector_offset
!= 0)
6590 /* PR 17531: file: 5b7b07ad. */
6591 if (constant_pool
+ name_offset
< constant_pool
6592 || constant_pool
+ name_offset
>= section
->start
+ section
->size
)
6594 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
6595 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6599 printf ("[%3u] %.*s:", i
,
6600 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
6601 constant_pool
+ name_offset
);
6603 if (constant_pool
+ cu_vector_offset
< constant_pool
6604 || constant_pool
+ cu_vector_offset
>= section
->start
+ section
->size
)
6606 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
6607 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6608 cu_vector_offset
, i
);
6612 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
6614 if (num_cus
* 4 < num_cus
6615 || constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4 >=
6616 section
->start
+ section
->size
)
6618 printf ("<invalid number of CUs: %d>\n", num_cus
);
6619 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6626 for (j
= 0; j
< num_cus
; ++j
)
6629 gdb_index_symbol_kind kind
;
6631 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6632 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6633 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6634 cu
= GDB_INDEX_CU_VALUE (cu
);
6635 /* Convert to TU number if it's for a type unit. */
6636 if (cu
>= cu_list_elements
/ 2)
6637 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6638 (unsigned long) (cu
- cu_list_elements
/ 2));
6640 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6642 printf (" [%s, %s]",
6643 is_static
? _("static") : _("global"),
6644 get_gdb_index_symbol_kind_name (kind
));
6656 /* Pre-allocate enough space for the CU/TU sets needed. */
6659 prealloc_cu_tu_list (unsigned int nshndx
)
6661 if (shndx_pool
== NULL
)
6663 shndx_pool_size
= nshndx
;
6664 shndx_pool_used
= 0;
6665 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6666 sizeof (unsigned int));
6670 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6671 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6672 sizeof (unsigned int));
6677 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6679 if (shndx_pool_used
>= shndx_pool_size
)
6681 error (_("Internal error: out of space in the shndx pool.\n"));
6684 shndx_pool
[shndx_pool_used
++] = shndx
;
6688 end_cu_tu_entry (void)
6690 if (shndx_pool_used
>= shndx_pool_size
)
6692 error (_("Internal error: out of space in the shndx pool.\n"));
6695 shndx_pool
[shndx_pool_used
++] = 0;
6698 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6701 get_DW_SECT_short_name (unsigned int dw_sect
)
6703 static char buf
[16];
6711 case DW_SECT_ABBREV
:
6717 case DW_SECT_STR_OFFSETS
:
6719 case DW_SECT_MACINFO
:
6727 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6731 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6732 These sections are extensions for Fission.
6733 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6736 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6738 unsigned char *phdr
= section
->start
;
6739 unsigned char *limit
= phdr
+ section
->size
;
6740 unsigned char *phash
;
6741 unsigned char *pindex
;
6742 unsigned char *ppool
;
6743 unsigned int version
;
6744 unsigned int ncols
= 0;
6746 unsigned int nslots
;
6749 dwarf_vma signature_high
;
6750 dwarf_vma signature_low
;
6753 /* PR 17512: file: 002-168123-0.004. */
6756 warn (_("Section %s is empty\n"), section
->name
);
6759 /* PR 17512: file: 002-376-0.004. */
6760 if (section
->size
< 24)
6762 warn (_("Section %s is too small to contain a CU/TU header"),
6767 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
6769 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
6770 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
6771 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
6774 pindex
= phash
+ nslots
* 8;
6775 ppool
= pindex
+ nslots
* 4;
6779 printf (_("Contents of the %s section:\n\n"), section
->name
);
6780 printf (_(" Version: %d\n"), version
);
6782 printf (_(" Number of columns: %d\n"), ncols
);
6783 printf (_(" Number of used entries: %d\n"), nused
);
6784 printf (_(" Number of slots: %d\n\n"), nslots
);
6789 warn (_("Section %s too small for %d hash table entries\n"),
6790 section
->name
, nslots
);
6797 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6798 for (i
= 0; i
< nslots
; i
++)
6800 unsigned char *shndx_list
;
6803 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
6804 if (signature_high
!= 0 || signature_low
!= 0)
6806 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
6807 shndx_list
= ppool
+ j
* 4;
6809 printf (_(" [%3d] Signature: 0x%s Sections: "),
6810 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6811 buf
, sizeof (buf
)));
6814 if (shndx_list
>= limit
)
6816 warn (_("Section %s too small for shndx pool\n"),
6820 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
6824 printf (" %d", shndx
);
6826 add_shndx_to_cu_tu_entry (shndx
);
6838 else if (version
== 2)
6841 unsigned int dw_sect
;
6842 unsigned char *ph
= phash
;
6843 unsigned char *pi
= pindex
;
6844 unsigned char *poffsets
= ppool
+ ncols
* 4;
6845 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
6846 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
6847 bfd_boolean is_tu_index
;
6848 struct cu_tu_set
*this_set
= NULL
;
6850 unsigned char *prow
;
6852 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
6856 warn (_("Section %s too small for offset and size tables\n"),
6863 printf (_(" Offset table\n"));
6864 printf (" slot %-16s ",
6865 is_tu_index
? _("signature") : _("dwo_id"));
6872 tu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6878 cu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6885 for (j
= 0; j
< ncols
; j
++)
6887 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6888 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
6893 for (i
= 0; i
< nslots
; i
++)
6895 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
6897 SAFE_BYTE_GET (row
, pi
, 4, limit
);
6900 /* PR 17531: file: a05f6ab3. */
6903 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
6909 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
6911 prow
= poffsets
+ (row
- 1) * ncols
* 4;
6914 printf (_(" [%3d] 0x%s"),
6915 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6916 buf
, sizeof (buf
)));
6917 for (j
= 0; j
< ncols
; j
++)
6919 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
6921 printf (" %8d", val
);
6924 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6925 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
6941 printf (_(" Size table\n"));
6942 printf (" slot %-16s ",
6943 is_tu_index
? _("signature") : _("dwo_id"));
6946 for (j
= 0; j
< ncols
; j
++)
6948 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
6950 printf (" %8s", get_DW_SECT_short_name (val
));
6956 for (i
= 0; i
< nslots
; i
++)
6958 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
6960 SAFE_BYTE_GET (row
, pi
, 4, limit
);
6963 prow
= psizes
+ (row
- 1) * ncols
* 4;
6966 printf (_(" [%3d] 0x%s"),
6967 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6968 buf
, sizeof (buf
)));
6970 for (j
= 0; j
< ncols
; j
++)
6972 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
6974 printf (" %8d", val
);
6977 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6978 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
6990 else if (do_display
)
6991 printf (_(" Unsupported version (%d)\n"), version
);
6999 /* Load the CU and TU indexes if present. This will build a list of
7000 section sets that we can use to associate a .debug_info.dwo section
7001 with its associated .debug_abbrev.dwo section in a .dwp file. */
7004 load_cu_tu_indexes (void *file
)
7006 /* If we have already loaded (or tried to load) the CU and TU indexes
7007 then do not bother to repeat the task. */
7008 if (cu_tu_indexes_read
)
7011 if (load_debug_section (dwp_cu_index
, file
))
7012 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
7014 if (load_debug_section (dwp_tu_index
, file
))
7015 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
7017 cu_tu_indexes_read
= 1;
7020 /* Find the set of sections that includes section SHNDX. */
7023 find_cu_tu_set (void *file
, unsigned int shndx
)
7027 load_cu_tu_indexes (file
);
7029 /* Find SHNDX in the shndx pool. */
7030 for (i
= 0; i
< shndx_pool_used
; i
++)
7031 if (shndx_pool
[i
] == shndx
)
7034 if (i
>= shndx_pool_used
)
7037 /* Now backup to find the first entry in the set. */
7038 while (i
> 0 && shndx_pool
[i
- 1] != 0)
7041 return shndx_pool
+ i
;
7044 /* Display a .debug_cu_index or .debug_tu_index section. */
7047 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
7049 return process_cu_tu_index (section
, 1);
7053 display_debug_not_supported (struct dwarf_section
*section
,
7054 void *file ATTRIBUTE_UNUSED
)
7056 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7063 cmalloc (size_t nmemb
, size_t size
)
7065 /* Check for overflow. */
7066 if (nmemb
>= ~(size_t) 0 / size
)
7069 return malloc (nmemb
* size
);
7073 xcmalloc (size_t nmemb
, size_t size
)
7075 /* Check for overflow. */
7076 if (nmemb
>= ~(size_t) 0 / size
)
7079 return xmalloc (nmemb
* size
);
7083 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
7085 /* Check for overflow. */
7086 if (nmemb
>= ~(size_t) 0 / size
)
7089 return xrealloc (ptr
, nmemb
* size
);
7093 free_debug_memory (void)
7099 for (i
= 0; i
< max
; i
++)
7100 free_debug_section ((enum dwarf_section_display_enum
) i
);
7102 if (debug_information
!= NULL
)
7104 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
7106 for (i
= 0; i
< num_debug_info_entries
; i
++)
7108 if (!debug_information
[i
].max_loc_offsets
)
7110 free (debug_information
[i
].loc_offsets
);
7111 free (debug_information
[i
].have_frame_base
);
7113 if (!debug_information
[i
].max_range_lists
)
7114 free (debug_information
[i
].range_lists
);
7118 free (debug_information
);
7119 debug_information
= NULL
;
7120 num_debug_info_entries
= 0;
7125 dwarf_select_sections_by_names (const char *names
)
7129 const char * option
;
7133 debug_dump_long_opts
;
7135 static const debug_dump_long_opts opts_table
[] =
7137 /* Please keep this table alpha- sorted. */
7138 { "Ranges", & do_debug_ranges
, 1 },
7139 { "abbrev", & do_debug_abbrevs
, 1 },
7140 { "addr", & do_debug_addr
, 1 },
7141 { "aranges", & do_debug_aranges
, 1 },
7142 { "cu_index", & do_debug_cu_index
, 1 },
7143 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
7144 { "frames", & do_debug_frames
, 1 },
7145 { "frames-interp", & do_debug_frames_interp
, 1 },
7146 /* The special .gdb_index section. */
7147 { "gdb_index", & do_gdb_index
, 1 },
7148 { "info", & do_debug_info
, 1 },
7149 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
7150 { "loc", & do_debug_loc
, 1 },
7151 { "macro", & do_debug_macinfo
, 1 },
7152 { "pubnames", & do_debug_pubnames
, 1 },
7153 { "pubtypes", & do_debug_pubtypes
, 1 },
7154 /* This entry is for compatability
7155 with earlier versions of readelf. */
7156 { "ranges", & do_debug_aranges
, 1 },
7157 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
7158 { "str", & do_debug_str
, 1 },
7159 /* These trace_* sections are used by Itanium VMS. */
7160 { "trace_abbrev", & do_trace_abbrevs
, 1 },
7161 { "trace_aranges", & do_trace_aranges
, 1 },
7162 { "trace_info", & do_trace_info
, 1 },
7171 const debug_dump_long_opts
* entry
;
7173 for (entry
= opts_table
; entry
->option
; entry
++)
7175 size_t len
= strlen (entry
->option
);
7177 if (strncmp (p
, entry
->option
, len
) == 0
7178 && (p
[len
] == ',' || p
[len
] == '\0'))
7180 * entry
->variable
|= entry
->val
;
7182 /* The --debug-dump=frames-interp option also
7183 enables the --debug-dump=frames option. */
7184 if (do_debug_frames_interp
)
7185 do_debug_frames
= 1;
7192 if (entry
->option
== NULL
)
7194 warn (_("Unrecognized debug option '%s'\n"), p
);
7195 p
= strchr (p
, ',');
7206 dwarf_select_sections_by_letters (const char *letters
)
7208 unsigned int lindex
= 0;
7210 while (letters
[lindex
])
7211 switch (letters
[lindex
++])
7218 do_debug_abbrevs
= 1;
7222 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
7226 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
7230 do_debug_pubnames
= 1;
7234 do_debug_pubtypes
= 1;
7238 do_debug_aranges
= 1;
7242 do_debug_ranges
= 1;
7246 do_debug_frames_interp
= 1;
7248 do_debug_frames
= 1;
7252 do_debug_macinfo
= 1;
7264 warn (_("Unrecognized debug option '%s'\n"), optarg
);
7270 dwarf_select_sections_all (void)
7273 do_debug_abbrevs
= 1;
7274 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
7275 do_debug_pubnames
= 1;
7276 do_debug_pubtypes
= 1;
7277 do_debug_aranges
= 1;
7278 do_debug_ranges
= 1;
7279 do_debug_frames
= 1;
7280 do_debug_macinfo
= 1;
7285 do_trace_abbrevs
= 1;
7286 do_trace_aranges
= 1;
7288 do_debug_cu_index
= 1;
7291 struct dwarf_section_display debug_displays
[] =
7293 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0, NULL
},
7294 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7295 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0, NULL
},
7296 display_debug_aranges
, &do_debug_aranges
, 1 },
7297 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0, NULL
},
7298 display_debug_frames
, &do_debug_frames
, 1 },
7299 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
, NULL
},
7300 display_debug_info
, &do_debug_info
, 1 },
7301 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0, NULL
},
7302 display_debug_lines
, &do_debug_lines
, 1 },
7303 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0, NULL
},
7304 display_debug_pubnames
, &do_debug_pubnames
, 0 },
7305 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0, NULL
},
7306 display_debug_gnu_pubnames
, &do_debug_pubnames
, 0 },
7307 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0, NULL
},
7308 display_debug_frames
, &do_debug_frames
, 1 },
7309 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0, NULL
},
7310 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7311 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0, NULL
},
7312 display_debug_macro
, &do_debug_macinfo
, 1 },
7313 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0, NULL
},
7314 display_debug_str
, &do_debug_str
, 0 },
7315 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0, NULL
},
7316 display_debug_loc
, &do_debug_loc
, 1 },
7317 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
},
7318 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
7319 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
},
7320 display_debug_gnu_pubnames
, &do_debug_pubtypes
, 0 },
7321 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0, NULL
},
7322 display_debug_ranges
, &do_debug_ranges
, 1 },
7323 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0, NULL
},
7324 display_debug_not_supported
, NULL
, 0 },
7325 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0, NULL
},
7326 display_debug_not_supported
, NULL
, 0 },
7327 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
, NULL
},
7328 display_debug_types
, &do_debug_info
, 1 },
7329 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0, NULL
},
7330 display_debug_not_supported
, NULL
, 0 },
7331 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7332 display_gdb_index
, &do_gdb_index
, 0 },
7333 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
, NULL
},
7334 display_trace_info
, &do_trace_info
, 1 },
7335 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0, NULL
},
7336 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
7337 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0, NULL
},
7338 display_debug_aranges
, &do_trace_aranges
, 0 },
7339 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
},
7340 display_debug_info
, &do_debug_info
, 1 },
7341 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7342 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7343 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
},
7344 display_debug_types
, &do_debug_info
, 1 },
7345 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7346 display_debug_lines
, &do_debug_lines
, 1 },
7347 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7348 display_debug_loc
, &do_debug_loc
, 1 },
7349 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7350 display_debug_macro
, &do_debug_macinfo
, 1 },
7351 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7352 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7353 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7354 display_debug_str
, &do_debug_str
, 1 },
7355 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0, NULL
},
7356 display_debug_str_offsets
, NULL
, 0 },
7357 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7358 display_debug_str_offsets
, NULL
, 0 },
7359 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0, NULL
},
7360 display_debug_addr
, &do_debug_addr
, 1 },
7361 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7362 display_cu_index
, &do_debug_cu_index
, 0 },
7363 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7364 display_cu_index
, &do_debug_cu_index
, 0 },