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 __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
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 /* MIPS extension. */
1939 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1940 /* UPC extension. */
1941 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1943 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1944 printf (_("(implementation defined: %s)"),
1945 dwarf_vmatoa ("x", uvalue
));
1947 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
1952 case DW_AT_encoding
:
1956 case DW_ATE_void
: printf ("(void)"); break;
1957 case DW_ATE_address
: printf ("(machine address)"); break;
1958 case DW_ATE_boolean
: printf ("(boolean)"); break;
1959 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1960 case DW_ATE_float
: printf ("(float)"); break;
1961 case DW_ATE_signed
: printf ("(signed)"); break;
1962 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1963 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1964 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1965 /* DWARF 2.1 values: */
1966 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1967 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1968 /* DWARF 3 values: */
1969 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1970 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1971 case DW_ATE_edited
: printf ("(edited)"); break;
1972 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1973 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1974 /* HP extensions: */
1975 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1976 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1977 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1978 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1979 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1980 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1981 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1984 if (uvalue
>= DW_ATE_lo_user
1985 && uvalue
<= DW_ATE_hi_user
)
1986 printf (_("(user defined type)"));
1988 printf (_("(unknown type)"));
1993 case DW_AT_accessibility
:
1997 case DW_ACCESS_public
: printf ("(public)"); break;
1998 case DW_ACCESS_protected
: printf ("(protected)"); break;
1999 case DW_ACCESS_private
: printf ("(private)"); break;
2001 printf (_("(unknown accessibility)"));
2006 case DW_AT_visibility
:
2010 case DW_VIS_local
: printf ("(local)"); break;
2011 case DW_VIS_exported
: printf ("(exported)"); break;
2012 case DW_VIS_qualified
: printf ("(qualified)"); break;
2013 default: printf (_("(unknown visibility)")); break;
2017 case DW_AT_virtuality
:
2021 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2022 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2023 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2024 default: printf (_("(unknown virtuality)")); break;
2028 case DW_AT_identifier_case
:
2032 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2033 case DW_ID_up_case
: printf ("(up_case)"); break;
2034 case DW_ID_down_case
: printf ("(down_case)"); break;
2035 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2036 default: printf (_("(unknown case)")); break;
2040 case DW_AT_calling_convention
:
2044 case DW_CC_normal
: printf ("(normal)"); break;
2045 case DW_CC_program
: printf ("(program)"); break;
2046 case DW_CC_nocall
: printf ("(nocall)"); break;
2048 if (uvalue
>= DW_CC_lo_user
2049 && uvalue
<= DW_CC_hi_user
)
2050 printf (_("(user defined)"));
2052 printf (_("(unknown convention)"));
2056 case DW_AT_ordering
:
2060 case -1: printf (_("(undefined)")); break;
2061 case 0: printf ("(row major)"); break;
2062 case 1: printf ("(column major)"); break;
2066 case DW_AT_frame_base
:
2067 have_frame_base
= 1;
2068 case DW_AT_location
:
2069 case DW_AT_string_length
:
2070 case DW_AT_return_addr
:
2071 case DW_AT_data_member_location
:
2072 case DW_AT_vtable_elem_location
:
2074 case DW_AT_static_link
:
2075 case DW_AT_use_location
:
2076 case DW_AT_GNU_call_site_value
:
2077 case DW_AT_GNU_call_site_data_value
:
2078 case DW_AT_GNU_call_site_target
:
2079 case DW_AT_GNU_call_site_target_clobbered
:
2080 if ((dwarf_version
< 4
2081 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2082 || form
== DW_FORM_sec_offset
)
2083 printf (_(" (location list)"));
2085 case DW_AT_allocated
:
2086 case DW_AT_associated
:
2087 case DW_AT_data_location
:
2089 case DW_AT_upper_bound
:
2090 case DW_AT_lower_bound
:
2093 int need_frame_base
;
2096 need_frame_base
= decode_location_expression (block_start
,
2101 cu_offset
, section
);
2103 if (need_frame_base
&& !have_frame_base
)
2104 printf (_(" [without DW_AT_frame_base]"));
2110 if (form
== DW_FORM_ref_sig8
2111 || form
== DW_FORM_GNU_ref_alt
)
2114 if (form
== DW_FORM_ref1
2115 || form
== DW_FORM_ref2
2116 || form
== DW_FORM_ref4
2117 || form
== DW_FORM_ref_udata
)
2118 uvalue
+= cu_offset
;
2120 if (uvalue
>= section
->size
)
2121 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2122 dwarf_vmatoa ("x", uvalue
),
2123 (unsigned long) (orig_data
- section
->start
));
2126 unsigned long abbrev_number
;
2127 abbrev_entry
* entry
;
2129 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2131 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2132 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2133 use different abbrev table, and we don't track .debug_info chunks
2135 if (form
!= DW_FORM_ref_addr
)
2137 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2138 if (entry
->entry
== abbrev_number
)
2141 printf (" (%s)", get_TAG_name (entry
->tag
));
2156 get_AT_name (unsigned long attribute
)
2161 return "DW_AT value: 0";
2163 /* One value is shared by the MIPS and HP extensions: */
2164 if (attribute
== DW_AT_MIPS_fde
)
2165 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2167 name
= get_DW_AT_name (attribute
);
2171 static char buffer
[100];
2173 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2181 static unsigned char *
2182 read_and_display_attr (unsigned long attribute
,
2184 unsigned char * data
,
2185 unsigned char * end
,
2186 dwarf_vma cu_offset
,
2187 dwarf_vma pointer_size
,
2188 dwarf_vma offset_size
,
2190 debug_info
* debug_info_p
,
2192 struct dwarf_section
* section
,
2193 struct cu_tu_set
* this_set
)
2196 printf (" %-18s:", get_AT_name (attribute
));
2197 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2198 cu_offset
, pointer_size
, offset_size
,
2199 dwarf_version
, debug_info_p
,
2200 do_loc
, section
, this_set
);
2206 /* Process the contents of a .debug_info section. If do_loc is non-zero
2207 then we are scanning for location lists and we do not want to display
2208 anything to the user. If do_types is non-zero, we are processing
2209 a .debug_types section instead of a .debug_info section. */
2212 process_debug_info (struct dwarf_section
*section
,
2214 enum dwarf_section_display_enum abbrev_sec
,
2218 unsigned char *start
= section
->start
;
2219 unsigned char *end
= start
+ section
->size
;
2220 unsigned char *section_begin
;
2222 unsigned int num_units
= 0;
2224 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2225 && num_debug_info_entries
== 0
2230 /* First scan the section to get the number of comp units. */
2231 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2234 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2235 will be the length. For a 64-bit DWARF section, it'll be
2236 the escape code 0xffffffff followed by an 8 byte length. */
2237 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2239 if (length
== 0xffffffff)
2241 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2242 section_begin
+= length
+ 12;
2244 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2246 warn (_("Reserved length value (0x%s) found in section %s\n"),
2247 dwarf_vmatoa ("x", length
), section
->name
);
2251 section_begin
+= length
+ 4;
2253 /* Negative values are illegal, they may even cause infinite
2254 looping. This can happen if we can't accurately apply
2255 relocations to an object file. */
2256 if ((signed long) length
<= 0)
2258 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2259 dwarf_vmatoa ("x", length
), section
->name
);
2266 error (_("No comp units in %s section ?\n"), section
->name
);
2270 /* Then allocate an array to hold the information. */
2271 debug_information
= (debug_info
*) cmalloc (num_units
,
2272 sizeof (* debug_information
));
2273 if (debug_information
== NULL
)
2275 error (_("Not enough memory for a debug info array of %u entries\n"),
2283 if (dwarf_start_die
== 0)
2284 printf (_("Contents of the %s section:\n\n"), section
->name
);
2286 load_debug_section (str
, file
);
2287 load_debug_section (str_dwo
, file
);
2288 load_debug_section (str_index
, file
);
2289 load_debug_section (str_index_dwo
, file
);
2290 load_debug_section (debug_addr
, file
);
2293 load_debug_section (abbrev_sec
, file
);
2294 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2296 warn (_("Unable to locate %s section!\n"),
2297 debug_displays
[abbrev_sec
].section
.name
);
2301 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2303 DWARF2_Internal_CompUnit compunit
;
2304 unsigned char *hdrptr
;
2305 unsigned char *tags
;
2306 int level
, last_level
, saved_level
;
2307 dwarf_vma cu_offset
;
2308 unsigned int offset_size
;
2309 int initial_length_size
;
2310 dwarf_vma signature_high
= 0;
2311 dwarf_vma signature_low
= 0;
2312 dwarf_vma type_offset
= 0;
2313 struct cu_tu_set
*this_set
;
2314 dwarf_vma abbrev_base
;
2319 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2321 if (compunit
.cu_length
== 0xffffffff)
2323 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2325 initial_length_size
= 12;
2330 initial_length_size
= 4;
2333 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2335 cu_offset
= start
- section_begin
;
2337 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2339 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2341 if (this_set
== NULL
)
2344 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2348 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2349 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2352 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2353 /* PR 17512: file: 001-108546-0.001:0.1. */
2354 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2356 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2357 compunit
.cu_pointer_size
, offset_size
);
2358 compunit
.cu_pointer_size
= offset_size
;
2363 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2365 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2368 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2369 && num_debug_info_entries
== 0
2372 debug_information
[unit
].cu_offset
= cu_offset
;
2373 debug_information
[unit
].pointer_size
2374 = compunit
.cu_pointer_size
;
2375 debug_information
[unit
].offset_size
= offset_size
;
2376 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2377 debug_information
[unit
].base_address
= 0;
2378 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2379 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2380 debug_information
[unit
].loc_offsets
= NULL
;
2381 debug_information
[unit
].have_frame_base
= NULL
;
2382 debug_information
[unit
].max_loc_offsets
= 0;
2383 debug_information
[unit
].num_loc_offsets
= 0;
2384 debug_information
[unit
].range_lists
= NULL
;
2385 debug_information
[unit
].max_range_lists
= 0;
2386 debug_information
[unit
].num_range_lists
= 0;
2389 if (!do_loc
&& dwarf_start_die
== 0)
2391 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2392 dwarf_vmatoa ("x", cu_offset
));
2393 printf (_(" Length: 0x%s (%s)\n"),
2394 dwarf_vmatoa ("x", compunit
.cu_length
),
2395 offset_size
== 8 ? "64-bit" : "32-bit");
2396 printf (_(" Version: %d\n"), compunit
.cu_version
);
2397 printf (_(" Abbrev Offset: 0x%s\n"),
2398 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2399 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2404 printf (_(" Signature: 0x%s\n"),
2405 dwarf_vmatoa64 (signature_high
, signature_low
,
2406 buf
, sizeof (buf
)));
2407 printf (_(" Type Offset: 0x%s\n"),
2408 dwarf_vmatoa ("x", type_offset
));
2410 if (this_set
!= NULL
)
2412 dwarf_vma
*offsets
= this_set
->section_offsets
;
2413 size_t *sizes
= this_set
->section_sizes
;
2415 printf (_(" Section contributions:\n"));
2416 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2417 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2418 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2419 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2420 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2421 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2422 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2423 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2424 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2425 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2426 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2427 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2431 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2434 warn (_("Debug info is corrupted, length of CU at %s"
2435 " extends beyond end of section (length = %s)\n"),
2436 dwarf_vmatoa ("x", cu_offset
),
2437 dwarf_vmatoa ("x", compunit
.cu_length
));
2441 start
+= compunit
.cu_length
+ initial_length_size
;
2443 if (compunit
.cu_version
!= 2
2444 && compunit
.cu_version
!= 3
2445 && compunit
.cu_version
!= 4)
2447 warn (_("CU at offset %s contains corrupt or "
2448 "unsupported version number: %d.\n"),
2449 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2455 /* Process the abbrevs used by this compilation unit. */
2456 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2457 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2458 (unsigned long) compunit
.cu_abbrev_offset
,
2459 (unsigned long) abbrev_size
);
2461 process_abbrev_section
2462 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2463 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2464 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2465 + abbrev_base
+ abbrev_size
));
2470 while (tags
< start
)
2472 unsigned int bytes_read
;
2473 unsigned long abbrev_number
;
2474 unsigned long die_offset
;
2475 abbrev_entry
*entry
;
2477 int do_printing
= 1;
2479 die_offset
= tags
- section_begin
;
2481 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2484 /* A null DIE marks the end of a list of siblings or it may also be
2485 a section padding. */
2486 if (abbrev_number
== 0)
2488 /* Check if it can be a section padding for the last CU. */
2489 if (level
== 0 && start
== end
)
2493 for (chk
= tags
; chk
< start
; chk
++)
2500 if (!do_loc
&& die_offset
>= dwarf_start_die
2501 && (dwarf_cutoff_level
== -1
2502 || level
< dwarf_cutoff_level
))
2503 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2509 static unsigned num_bogus_warns
= 0;
2511 if (num_bogus_warns
< 3)
2513 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2514 die_offset
, section
->name
);
2516 if (num_bogus_warns
== 3)
2517 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2520 if (dwarf_start_die
!= 0 && level
< saved_level
)
2527 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2531 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2532 saved_level
= level
;
2533 do_printing
= (dwarf_cutoff_level
== -1
2534 || level
< dwarf_cutoff_level
);
2536 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2537 level
, die_offset
, abbrev_number
);
2538 else if (dwarf_cutoff_level
== -1
2539 || last_level
< dwarf_cutoff_level
)
2540 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2545 /* Scan through the abbreviation list until we reach the
2547 for (entry
= first_abbrev
;
2548 entry
&& entry
->entry
!= abbrev_number
;
2549 entry
= entry
->next
)
2554 if (!do_loc
&& do_printing
)
2559 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2560 die_offset
, abbrev_number
);
2564 if (!do_loc
&& do_printing
)
2565 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2570 need_base_address
= 0;
2572 case DW_TAG_compile_unit
:
2573 need_base_address
= 1;
2575 case DW_TAG_entry_point
:
2576 case DW_TAG_subprogram
:
2577 need_base_address
= 0;
2578 /* Assuming that there is no DW_AT_frame_base. */
2579 have_frame_base
= 0;
2583 for (attr
= entry
->first_attr
;
2584 attr
&& attr
->attribute
;
2589 if (! do_loc
&& do_printing
)
2590 /* Show the offset from where the tag was extracted. */
2591 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2593 arg
= debug_information
;
2594 if (debug_information
)
2597 tags
= read_and_display_attr (attr
->attribute
,
2602 compunit
.cu_pointer_size
,
2604 compunit
.cu_version
,
2606 do_loc
|| ! do_printing
,
2611 if (entry
->children
)
2616 /* Set num_debug_info_entries here so that it can be used to check if
2617 we need to process .debug_loc and .debug_ranges sections. */
2618 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2619 && num_debug_info_entries
== 0
2621 num_debug_info_entries
= num_units
;
2629 /* Locate and scan the .debug_info section in the file and record the pointer
2630 sizes and offsets for the compilation units in it. Usually an executable
2631 will have just one pointer size, but this is not guaranteed, and so we try
2632 not to make any assumptions. Returns zero upon failure, or the number of
2633 compilation units upon success. */
2636 load_debug_info (void * file
)
2638 /* Reset the last pointer size so that we can issue correct error
2639 messages if we are displaying the contents of more than one section. */
2640 last_pointer_size
= 0;
2641 warned_about_missing_comp_units
= FALSE
;
2643 /* If we have already tried and failed to load the .debug_info
2644 section then do not bother to repeat the task. */
2645 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2648 /* If we already have the information there is nothing else to do. */
2649 if (num_debug_info_entries
> 0)
2650 return num_debug_info_entries
;
2652 /* If this is a DWARF package file, load the CU and TU indexes. */
2653 load_cu_tu_indexes (file
);
2655 if (load_debug_section (info
, file
)
2656 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2657 return num_debug_info_entries
;
2658 else if (load_debug_section (info_dwo
, file
)
2659 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2661 return num_debug_info_entries
;
2663 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2667 /* Read a DWARF .debug_line section header starting at DATA.
2668 Upon success returns an updated DATA pointer and the LINFO
2669 structure and the END_OF_SEQUENCE pointer will be filled in.
2670 Otherwise returns NULL. */
2672 static unsigned char *
2673 read_debug_line_header (struct dwarf_section
* section
,
2674 unsigned char * data
,
2675 unsigned char * end
,
2676 DWARF2_Internal_LineInfo
* linfo
,
2677 unsigned char ** end_of_sequence
)
2679 unsigned char *hdrptr
;
2680 unsigned int offset_size
;
2681 unsigned int initial_length_size
;
2683 /* Extract information from the Line Number Program Header.
2684 (section 6.2.4 in the Dwarf3 doc). */
2687 /* Get and check the length of the block. */
2688 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2690 if (linfo
->li_length
== 0xffffffff)
2692 /* This section is 64-bit DWARF 3. */
2693 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2695 initial_length_size
= 12;
2700 initial_length_size
= 4;
2703 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2705 /* If the length is just a bias against the initial_length_size then
2706 this means that the field has a relocation against it which has not
2707 been applied. (Ie we are dealing with an object file, not a linked
2708 binary). Do not complain but instead assume that the rest of the
2709 section applies to this particular header. */
2710 if (linfo
->li_length
== - initial_length_size
)
2712 linfo
->li_length
= section
->size
- initial_length_size
;
2716 warn (_("The line info appears to be corrupt - the section is too small\n"));
2721 /* Get and check the version number. */
2722 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2724 if (linfo
->li_version
!= 2
2725 && linfo
->li_version
!= 3
2726 && linfo
->li_version
!= 4)
2728 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2732 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2733 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2735 if (linfo
->li_version
>= 4)
2737 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2739 if (linfo
->li_max_ops_per_insn
== 0)
2741 warn (_("Invalid maximum operations per insn.\n"));
2746 linfo
->li_max_ops_per_insn
= 1;
2748 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2749 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2750 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2751 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2753 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2754 /* PR 17512: file:002-117414-0.004. */
2755 if (* end_of_sequence
> end
)
2757 warn (_("Line length %lld extends beyond end of section\n"), linfo
->li_length
);
2758 * end_of_sequence
= end
;
2766 display_debug_lines_raw (struct dwarf_section
*section
,
2767 unsigned char *data
,
2770 unsigned char *start
= section
->start
;
2772 printf (_("Raw dump of debug contents of section %s:\n\n"),
2777 static DWARF2_Internal_LineInfo saved_linfo
;
2778 DWARF2_Internal_LineInfo linfo
;
2779 unsigned char *standard_opcodes
;
2780 unsigned char *end_of_sequence
;
2781 unsigned int last_dir_entry
= 0;
2784 if (const_strneq (section
->name
, ".debug_line.")
2785 /* Note: the following does not apply to .debug_line.dwo sections.
2786 These are full debug_line sections. */
2787 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2789 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2790 section containing just the Line Number Statements. They are
2791 created by the assembler and intended to be used alongside gcc's
2792 -ffunction-sections command line option. When the linker's
2793 garbage collection decides to discard a .text.<foo> section it
2794 can then also discard the line number information in .debug_line.<foo>.
2796 Since the section is a fragment it does not have the details
2797 needed to fill out a LineInfo structure, so instead we use the
2798 details from the last full debug_line section that we processed. */
2799 end_of_sequence
= end
;
2800 standard_opcodes
= NULL
;
2801 linfo
= saved_linfo
;
2802 reset_state_machine (linfo
.li_default_is_stmt
);
2806 unsigned char * hdrptr
;
2808 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2809 & end_of_sequence
)) == NULL
)
2812 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2813 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2814 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2815 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2816 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2817 if (linfo
.li_version
>= 4)
2818 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2819 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2820 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2821 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2822 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2824 /* PR 17512: file: 1665-6428-0.004. */
2825 if (linfo
.li_line_range
== 0)
2827 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2828 linfo
.li_line_range
= 1;
2831 reset_state_machine (linfo
.li_default_is_stmt
);
2833 /* Display the contents of the Opcodes table. */
2834 standard_opcodes
= hdrptr
;
2836 /* PR 17512: file: 002-417945-0.004. */
2837 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
2839 warn (_("Line Base extends beyond end of section\n"));
2843 printf (_("\n Opcodes:\n"));
2845 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2846 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2848 /* Display the contents of the Directory table. */
2849 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2852 printf (_("\n The Directory Table is empty.\n"));
2855 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2856 (long)(data
- start
));
2858 while (data
< end
&& *data
!= 0)
2860 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
2862 data
+= strnlen ((char *) data
, end
- data
) + 1;
2865 /* PR 17512: file: 002-132094-0.004. */
2866 if (data
>= end
- 1)
2870 /* Skip the NUL at the end of the table. */
2873 /* Display the contents of the File Name table. */
2875 printf (_("\n The File Name Table is empty.\n"));
2878 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2879 (long)(data
- start
));
2880 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2882 while (data
< end
&& *data
!= 0)
2884 unsigned char *name
;
2885 unsigned int bytes_read
;
2887 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2889 data
+= strnlen ((char *) data
, end
- data
) + 1;
2892 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2895 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2898 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2900 printf ("%.*s\n", (int)(end
- name
), name
);
2904 warn (_("Corrupt file name table entry\n"));
2910 /* Skip the NUL at the end of the table. */
2913 saved_linfo
= linfo
;
2916 /* Now display the statements. */
2917 if (data
>= end_of_sequence
)
2918 printf (_(" No Line Number Statements.\n"));
2921 printf (_(" Line Number Statements:\n"));
2923 while (data
< end_of_sequence
)
2925 unsigned char op_code
;
2926 dwarf_signed_vma adv
;
2928 unsigned int bytes_read
;
2930 printf (" [0x%08lx]", (long)(data
- start
));
2934 if (op_code
>= linfo
.li_opcode_base
)
2936 op_code
-= linfo
.li_opcode_base
;
2937 uladv
= (op_code
/ linfo
.li_line_range
);
2938 if (linfo
.li_max_ops_per_insn
== 1)
2940 uladv
*= linfo
.li_min_insn_length
;
2941 state_machine_regs
.address
+= uladv
;
2942 printf (_(" Special opcode %d: "
2943 "advance Address by %s to 0x%s"),
2944 op_code
, dwarf_vmatoa ("u", uladv
),
2945 dwarf_vmatoa ("x", state_machine_regs
.address
));
2949 state_machine_regs
.address
2950 += ((state_machine_regs
.op_index
+ uladv
)
2951 / linfo
.li_max_ops_per_insn
)
2952 * linfo
.li_min_insn_length
;
2953 state_machine_regs
.op_index
2954 = (state_machine_regs
.op_index
+ uladv
)
2955 % linfo
.li_max_ops_per_insn
;
2956 printf (_(" Special opcode %d: "
2957 "advance Address by %s to 0x%s[%d]"),
2958 op_code
, dwarf_vmatoa ("u", uladv
),
2959 dwarf_vmatoa ("x", state_machine_regs
.address
),
2960 state_machine_regs
.op_index
);
2962 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2963 state_machine_regs
.line
+= adv
;
2964 printf (_(" and Line by %s to %d\n"),
2965 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
2967 else switch (op_code
)
2969 case DW_LNS_extended_op
:
2970 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
2974 printf (_(" Copy\n"));
2977 case DW_LNS_advance_pc
:
2978 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2980 if (linfo
.li_max_ops_per_insn
== 1)
2982 uladv
*= linfo
.li_min_insn_length
;
2983 state_machine_regs
.address
+= uladv
;
2984 printf (_(" Advance PC by %s to 0x%s\n"),
2985 dwarf_vmatoa ("u", uladv
),
2986 dwarf_vmatoa ("x", state_machine_regs
.address
));
2990 state_machine_regs
.address
2991 += ((state_machine_regs
.op_index
+ uladv
)
2992 / linfo
.li_max_ops_per_insn
)
2993 * linfo
.li_min_insn_length
;
2994 state_machine_regs
.op_index
2995 = (state_machine_regs
.op_index
+ uladv
)
2996 % linfo
.li_max_ops_per_insn
;
2997 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
2998 dwarf_vmatoa ("u", uladv
),
2999 dwarf_vmatoa ("x", state_machine_regs
.address
),
3000 state_machine_regs
.op_index
);
3004 case DW_LNS_advance_line
:
3005 adv
= read_sleb128 (data
, & bytes_read
, end
);
3007 state_machine_regs
.line
+= adv
;
3008 printf (_(" Advance Line by %s to %d\n"),
3009 dwarf_vmatoa ("d", adv
),
3010 state_machine_regs
.line
);
3013 case DW_LNS_set_file
:
3014 adv
= read_uleb128 (data
, & bytes_read
, end
);
3016 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3017 dwarf_vmatoa ("d", adv
));
3018 state_machine_regs
.file
= adv
;
3021 case DW_LNS_set_column
:
3022 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3024 printf (_(" Set column to %s\n"),
3025 dwarf_vmatoa ("u", uladv
));
3026 state_machine_regs
.column
= uladv
;
3029 case DW_LNS_negate_stmt
:
3030 adv
= state_machine_regs
.is_stmt
;
3032 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3033 state_machine_regs
.is_stmt
= adv
;
3036 case DW_LNS_set_basic_block
:
3037 printf (_(" Set basic block\n"));
3038 state_machine_regs
.basic_block
= 1;
3041 case DW_LNS_const_add_pc
:
3042 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3043 if (linfo
.li_max_ops_per_insn
)
3045 uladv
*= linfo
.li_min_insn_length
;
3046 state_machine_regs
.address
+= uladv
;
3047 printf (_(" Advance PC by constant %s to 0x%s\n"),
3048 dwarf_vmatoa ("u", uladv
),
3049 dwarf_vmatoa ("x", state_machine_regs
.address
));
3053 state_machine_regs
.address
3054 += ((state_machine_regs
.op_index
+ uladv
)
3055 / linfo
.li_max_ops_per_insn
)
3056 * linfo
.li_min_insn_length
;
3057 state_machine_regs
.op_index
3058 = (state_machine_regs
.op_index
+ uladv
)
3059 % linfo
.li_max_ops_per_insn
;
3060 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3061 dwarf_vmatoa ("u", uladv
),
3062 dwarf_vmatoa ("x", state_machine_regs
.address
),
3063 state_machine_regs
.op_index
);
3067 case DW_LNS_fixed_advance_pc
:
3068 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3069 state_machine_regs
.address
+= uladv
;
3070 state_machine_regs
.op_index
= 0;
3071 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3072 dwarf_vmatoa ("u", uladv
),
3073 dwarf_vmatoa ("x", state_machine_regs
.address
));
3076 case DW_LNS_set_prologue_end
:
3077 printf (_(" Set prologue_end to true\n"));
3080 case DW_LNS_set_epilogue_begin
:
3081 printf (_(" Set epilogue_begin to true\n"));
3084 case DW_LNS_set_isa
:
3085 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3087 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3091 printf (_(" Unknown opcode %d with operands: "), op_code
);
3093 if (standard_opcodes
!= NULL
)
3094 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3096 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3098 i
== 1 ? "" : ", ");
3114 unsigned char *name
;
3115 unsigned int directory_index
;
3116 unsigned int modification_date
;
3117 unsigned int length
;
3120 /* Output a decoded representation of the .debug_line section. */
3123 display_debug_lines_decoded (struct dwarf_section
*section
,
3124 unsigned char *data
,
3127 static DWARF2_Internal_LineInfo saved_linfo
;
3129 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3134 /* This loop amounts to one iteration per compilation unit. */
3135 DWARF2_Internal_LineInfo linfo
;
3136 unsigned char *standard_opcodes
;
3137 unsigned char *end_of_sequence
;
3139 File_Entry
*file_table
= NULL
;
3140 unsigned int n_files
= 0;
3141 unsigned char **directory_table
= NULL
;
3142 unsigned int n_directories
= 0;
3144 if (const_strneq (section
->name
, ".debug_line.")
3145 /* Note: the following does not apply to .debug_line.dwo sections.
3146 These are full debug_line sections. */
3147 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3149 /* See comment in display_debug_lines_raw(). */
3150 end_of_sequence
= end
;
3151 standard_opcodes
= NULL
;
3152 linfo
= saved_linfo
;
3153 reset_state_machine (linfo
.li_default_is_stmt
);
3157 unsigned char *hdrptr
;
3159 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3160 & end_of_sequence
)) == NULL
)
3163 reset_state_machine (linfo
.li_default_is_stmt
);
3165 /* Save a pointer to the contents of the Opcodes table. */
3166 standard_opcodes
= hdrptr
;
3168 /* Traverse the Directory table just to count entries. */
3169 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3172 unsigned char *ptr_directory_table
= data
;
3176 data
+= strnlen ((char *) data
, end
- data
) + 1;
3180 /* Go through the directory table again to save the directories. */
3181 directory_table
= (unsigned char **)
3182 xmalloc (n_directories
* sizeof (unsigned char *));
3185 while (*ptr_directory_table
!= 0)
3187 directory_table
[i
] = ptr_directory_table
;
3188 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3189 ptr_directory_table
- end
) + 1;
3193 /* Skip the NUL at the end of the table. */
3196 /* Traverse the File Name table just to count the entries. */
3199 unsigned char *ptr_file_name_table
= data
;
3203 unsigned int bytes_read
;
3205 /* Skip Name, directory index, last modification time and length
3207 data
+= strnlen ((char *) data
, end
- data
) + 1;
3208 read_uleb128 (data
, & bytes_read
, end
);
3210 read_uleb128 (data
, & bytes_read
, end
);
3212 read_uleb128 (data
, & bytes_read
, end
);
3218 /* Go through the file table again to save the strings. */
3219 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3222 while (*ptr_file_name_table
!= 0)
3224 unsigned int bytes_read
;
3226 file_table
[i
].name
= ptr_file_name_table
;
3227 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3228 end
- ptr_file_name_table
) + 1;
3230 /* We are not interested in directory, time or size. */
3231 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3233 ptr_file_name_table
+= bytes_read
;
3234 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3236 ptr_file_name_table
+= bytes_read
;
3237 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3238 ptr_file_name_table
+= bytes_read
;
3243 /* Print the Compilation Unit's name and a header. */
3244 if (directory_table
== NULL
)
3246 printf (_("CU: %s:\n"), file_table
[0].name
);
3247 printf (_("File name Line number Starting address\n"));
3251 unsigned int ix
= file_table
[0].directory_index
;
3252 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3254 if (do_wide
|| strlen (directory
) < 76)
3255 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3257 printf ("%s:\n", file_table
[0].name
);
3259 printf (_("File name Line number Starting address\n"));
3263 /* Skip the NUL at the end of the table. */
3266 saved_linfo
= linfo
;
3269 /* This loop iterates through the Dwarf Line Number Program. */
3270 while (data
< end_of_sequence
)
3272 unsigned char op_code
;
3274 unsigned long int uladv
;
3275 unsigned int bytes_read
;
3276 int is_special_opcode
= 0;
3280 if (op_code
>= linfo
.li_opcode_base
)
3282 op_code
-= linfo
.li_opcode_base
;
3283 uladv
= (op_code
/ linfo
.li_line_range
);
3284 if (linfo
.li_max_ops_per_insn
== 1)
3286 uladv
*= linfo
.li_min_insn_length
;
3287 state_machine_regs
.address
+= uladv
;
3291 state_machine_regs
.address
3292 += ((state_machine_regs
.op_index
+ uladv
)
3293 / linfo
.li_max_ops_per_insn
)
3294 * linfo
.li_min_insn_length
;
3295 state_machine_regs
.op_index
3296 = (state_machine_regs
.op_index
+ uladv
)
3297 % linfo
.li_max_ops_per_insn
;
3300 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3301 state_machine_regs
.line
+= adv
;
3302 is_special_opcode
= 1;
3304 else switch (op_code
)
3306 case DW_LNS_extended_op
:
3308 unsigned int ext_op_code_len
;
3309 unsigned char ext_op_code
;
3310 unsigned char *op_code_data
= data
;
3312 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3314 op_code_data
+= bytes_read
;
3316 if (ext_op_code_len
== 0)
3318 warn (_("Badly formed extended line op encountered!\n"));
3321 ext_op_code_len
+= bytes_read
;
3322 ext_op_code
= *op_code_data
++;
3324 switch (ext_op_code
)
3326 case DW_LNE_end_sequence
:
3327 reset_state_machine (linfo
.li_default_is_stmt
);
3329 case DW_LNE_set_address
:
3330 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3332 ext_op_code_len
- bytes_read
- 1,
3334 state_machine_regs
.op_index
= 0;
3336 case DW_LNE_define_file
:
3338 file_table
= (File_Entry
*) xrealloc
3339 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3341 ++state_machine_regs
.last_file_entry
;
3342 /* Source file name. */
3343 file_table
[n_files
].name
= op_code_data
;
3344 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3345 /* Directory index. */
3346 file_table
[n_files
].directory_index
=
3347 read_uleb128 (op_code_data
, & bytes_read
,
3349 op_code_data
+= bytes_read
;
3350 /* Last modification time. */
3351 file_table
[n_files
].modification_date
=
3352 read_uleb128 (op_code_data
, & bytes_read
,
3354 op_code_data
+= bytes_read
;
3356 file_table
[n_files
].length
=
3357 read_uleb128 (op_code_data
, & bytes_read
,
3363 case DW_LNE_set_discriminator
:
3364 case DW_LNE_HP_set_sequence
:
3365 /* Simply ignored. */
3369 printf (_("UNKNOWN (%u): length %d\n"),
3370 ext_op_code
, ext_op_code_len
- bytes_read
);
3373 data
+= ext_op_code_len
;
3379 case DW_LNS_advance_pc
:
3380 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3382 if (linfo
.li_max_ops_per_insn
== 1)
3384 uladv
*= linfo
.li_min_insn_length
;
3385 state_machine_regs
.address
+= uladv
;
3389 state_machine_regs
.address
3390 += ((state_machine_regs
.op_index
+ uladv
)
3391 / linfo
.li_max_ops_per_insn
)
3392 * linfo
.li_min_insn_length
;
3393 state_machine_regs
.op_index
3394 = (state_machine_regs
.op_index
+ uladv
)
3395 % linfo
.li_max_ops_per_insn
;
3399 case DW_LNS_advance_line
:
3400 adv
= read_sleb128 (data
, & bytes_read
, end
);
3402 state_machine_regs
.line
+= adv
;
3405 case DW_LNS_set_file
:
3406 adv
= read_uleb128 (data
, & bytes_read
, end
);
3408 state_machine_regs
.file
= adv
;
3410 if (file_table
== NULL
)
3411 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3412 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3413 /* If directory index is 0, that means current directory. */
3414 printf ("\n./%s:[++]\n",
3415 file_table
[state_machine_regs
.file
- 1].name
);
3416 else if (directory_table
== NULL
)
3417 printf (_("\n [Use directory table entry %d]\n"),
3418 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3420 /* The directory index starts counting at 1. */
3421 printf ("\n%s/%s:\n",
3422 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3423 file_table
[state_machine_regs
.file
- 1].name
);
3426 case DW_LNS_set_column
:
3427 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3429 state_machine_regs
.column
= uladv
;
3432 case DW_LNS_negate_stmt
:
3433 adv
= state_machine_regs
.is_stmt
;
3435 state_machine_regs
.is_stmt
= adv
;
3438 case DW_LNS_set_basic_block
:
3439 state_machine_regs
.basic_block
= 1;
3442 case DW_LNS_const_add_pc
:
3443 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3444 if (linfo
.li_max_ops_per_insn
== 1)
3446 uladv
*= linfo
.li_min_insn_length
;
3447 state_machine_regs
.address
+= uladv
;
3451 state_machine_regs
.address
3452 += ((state_machine_regs
.op_index
+ uladv
)
3453 / linfo
.li_max_ops_per_insn
)
3454 * linfo
.li_min_insn_length
;
3455 state_machine_regs
.op_index
3456 = (state_machine_regs
.op_index
+ uladv
)
3457 % linfo
.li_max_ops_per_insn
;
3461 case DW_LNS_fixed_advance_pc
:
3462 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3463 state_machine_regs
.address
+= uladv
;
3464 state_machine_regs
.op_index
= 0;
3467 case DW_LNS_set_prologue_end
:
3470 case DW_LNS_set_epilogue_begin
:
3473 case DW_LNS_set_isa
:
3474 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3476 printf (_(" Set ISA to %lu\n"), uladv
);
3480 printf (_(" Unknown opcode %d with operands: "), op_code
);
3482 if (standard_opcodes
!= NULL
)
3483 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3485 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3487 i
== 1 ? "" : ", ");
3494 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3495 to the DWARF address/line matrix. */
3496 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3497 || (op_code
== DW_LNS_copy
))
3499 const unsigned int MAX_FILENAME_LENGTH
= 35;
3501 char *newFileName
= NULL
;
3502 size_t fileNameLength
;
3505 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3507 fileName
= "<unknown>";
3509 fileNameLength
= strlen (fileName
);
3511 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3513 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3514 /* Truncate file name */
3515 strncpy (newFileName
,
3516 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3517 MAX_FILENAME_LENGTH
+ 1);
3521 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3522 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3525 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3527 if (linfo
.li_max_ops_per_insn
== 1)
3528 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3529 newFileName
, state_machine_regs
.line
,
3530 state_machine_regs
.address
);
3532 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3533 newFileName
, state_machine_regs
.line
,
3534 state_machine_regs
.address
,
3535 state_machine_regs
.op_index
);
3539 if (linfo
.li_max_ops_per_insn
== 1)
3540 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3541 newFileName
, state_machine_regs
.line
,
3542 state_machine_regs
.address
);
3544 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3545 newFileName
, state_machine_regs
.line
,
3546 state_machine_regs
.address
,
3547 state_machine_regs
.op_index
);
3550 if (op_code
== DW_LNE_end_sequence
)
3564 if (directory_table
)
3566 free (directory_table
);
3567 directory_table
= NULL
;
3578 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3580 unsigned char *data
= section
->start
;
3581 unsigned char *end
= data
+ section
->size
;
3583 int retValDecoded
= 1;
3585 if (do_debug_lines
== 0)
3586 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3588 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3589 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3591 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3592 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3594 if (!retValRaw
|| !retValDecoded
)
3601 find_debug_info_for_offset (unsigned long offset
)
3605 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3608 for (i
= 0; i
< num_debug_info_entries
; i
++)
3609 if (debug_information
[i
].cu_offset
== offset
)
3610 return debug_information
+ i
;
3616 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
3618 /* See gdb/gdb-index.h. */
3619 static const char * const kinds
[] =
3631 return _ (kinds
[kind
]);
3635 display_debug_pubnames_worker (struct dwarf_section
*section
,
3636 void *file ATTRIBUTE_UNUSED
,
3639 DWARF2_Internal_PubNames names
;
3640 unsigned char *start
= section
->start
;
3641 unsigned char *end
= start
+ section
->size
;
3643 /* It does not matter if this load fails,
3644 we test for that later on. */
3645 load_debug_info (file
);
3647 printf (_("Contents of the %s section:\n\n"), section
->name
);
3651 unsigned char *data
;
3652 unsigned long offset
;
3653 unsigned int offset_size
, initial_length_size
;
3657 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3658 if (names
.pn_length
== 0xffffffff)
3660 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3662 initial_length_size
= 12;
3667 initial_length_size
= 4;
3670 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3671 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3673 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3674 && num_debug_info_entries
> 0
3675 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3676 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3677 (unsigned long) names
.pn_offset
, section
->name
);
3679 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3681 start
+= names
.pn_length
+ initial_length_size
;
3683 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3685 static int warned
= 0;
3689 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3696 printf (_(" Length: %ld\n"),
3697 (long) names
.pn_length
);
3698 printf (_(" Version: %d\n"),
3700 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3701 (unsigned long) names
.pn_offset
);
3702 printf (_(" Size of area in .debug_info section: %ld\n"),
3703 (long) names
.pn_size
);
3706 printf (_("\n Offset Kind Name\n"));
3708 printf (_("\n Offset\tName\n"));
3712 bfd_size_type maxprint
;
3714 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3718 data
+= offset_size
;
3721 maxprint
= (end
- data
) - 1;
3725 unsigned int kind_data
;
3726 gdb_index_symbol_kind kind
;
3727 const char *kind_name
;
3730 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
3733 /* GCC computes the kind as the upper byte in the CU index
3734 word, and then right shifts it by the CU index size.
3735 Left shift KIND to where the gdb-index.h accessor macros
3737 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
3738 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
3739 kind_name
= get_gdb_index_symbol_kind_name (kind
);
3740 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
3741 printf (" %-6lx %s,%-10s %.*s\n",
3742 offset
, is_static
? _("s") : _("g"),
3743 kind_name
, (int) maxprint
, data
);
3746 printf (" %-6lx\t%.*s\n", offset
, (int) maxprint
, data
);
3748 data
+= strnlen ((char *) data
, maxprint
) + 1;
3753 while (offset
!= 0);
3761 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
3763 return display_debug_pubnames_worker (section
, file
, 0);
3767 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
3769 return display_debug_pubnames_worker (section
, file
, 1);
3773 display_debug_macinfo (struct dwarf_section
*section
,
3774 void *file ATTRIBUTE_UNUSED
)
3776 unsigned char *start
= section
->start
;
3777 unsigned char *end
= start
+ section
->size
;
3778 unsigned char *curr
= start
;
3779 unsigned int bytes_read
;
3780 enum dwarf_macinfo_record_type op
;
3782 printf (_("Contents of the %s section:\n\n"), section
->name
);
3786 unsigned int lineno
;
3787 const unsigned char *string
;
3789 op
= (enum dwarf_macinfo_record_type
) *curr
;
3794 case DW_MACINFO_start_file
:
3796 unsigned int filenum
;
3798 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3800 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3803 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3808 case DW_MACINFO_end_file
:
3809 printf (_(" DW_MACINFO_end_file\n"));
3812 case DW_MACINFO_define
:
3813 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3816 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3817 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3821 case DW_MACINFO_undef
:
3822 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3825 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3826 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3830 case DW_MACINFO_vendor_ext
:
3832 unsigned int constant
;
3834 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3837 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3838 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3848 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3849 filename and dirname corresponding to file name table entry with index
3850 FILEIDX. Return NULL on failure. */
3852 static unsigned char *
3853 get_line_filename_and_dirname (dwarf_vma line_offset
,
3855 unsigned char **dir_name
)
3857 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3858 unsigned char *hdrptr
, *dirtable
, *file_name
;
3859 unsigned int offset_size
, initial_length_size
;
3860 unsigned int version
, opcode_base
, bytes_read
;
3861 dwarf_vma length
, diridx
;
3862 const unsigned char * end
;
3865 if (section
->start
== NULL
3866 || line_offset
>= section
->size
3870 hdrptr
= section
->start
+ line_offset
;
3871 end
= section
->start
+ section
->size
;
3873 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3874 if (length
== 0xffffffff)
3876 /* This section is 64-bit DWARF 3. */
3877 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3879 initial_length_size
= 12;
3884 initial_length_size
= 4;
3886 if (length
+ initial_length_size
> section
->size
)
3889 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3890 if (version
!= 2 && version
!= 3 && version
!= 4)
3892 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3894 hdrptr
++; /* Skip max_ops_per_insn. */
3895 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3897 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3898 if (opcode_base
== 0)
3901 hdrptr
+= opcode_base
- 1;
3903 /* Skip over dirname table. */
3904 while (*hdrptr
!= '\0')
3905 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3906 hdrptr
++; /* Skip the NUL at the end of the table. */
3907 /* Now skip over preceding filename table entries. */
3908 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3910 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3911 read_uleb128 (hdrptr
, &bytes_read
, end
);
3912 hdrptr
+= bytes_read
;
3913 read_uleb128 (hdrptr
, &bytes_read
, end
);
3914 hdrptr
+= bytes_read
;
3915 read_uleb128 (hdrptr
, &bytes_read
, end
);
3916 hdrptr
+= bytes_read
;
3918 if (hdrptr
== end
|| *hdrptr
== '\0')
3921 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3922 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
3925 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
3926 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
3927 if (*dirtable
== '\0')
3929 *dir_name
= dirtable
;
3934 display_debug_macro (struct dwarf_section
*section
,
3937 unsigned char *start
= section
->start
;
3938 unsigned char *end
= start
+ section
->size
;
3939 unsigned char *curr
= start
;
3940 unsigned char *extended_op_buf
[256];
3941 unsigned int bytes_read
;
3943 load_debug_section (str
, file
);
3944 load_debug_section (line
, file
);
3946 printf (_("Contents of the %s section:\n\n"), section
->name
);
3950 unsigned int lineno
, version
, flags
;
3951 unsigned int offset_size
= 4;
3952 const unsigned char *string
;
3953 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
3954 unsigned char **extended_ops
= NULL
;
3956 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
3959 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3964 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
3967 printf (_(" Offset: 0x%lx\n"),
3968 (unsigned long) sec_offset
);
3969 printf (_(" Version: %d\n"), version
);
3970 printf (_(" Offset size: %d\n"), offset_size
);
3973 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
3974 printf (_(" Offset into .debug_line: 0x%lx\n"),
3975 (unsigned long) line_offset
);
3979 unsigned int i
, count
, op
;
3982 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
3984 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
3985 extended_ops
= extended_op_buf
;
3988 printf (_(" Extension opcode arguments:\n"));
3989 for (i
= 0; i
< count
; i
++)
3991 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3992 extended_ops
[op
] = curr
;
3993 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
3996 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
3999 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
4000 for (n
= 0; n
< nargs
; n
++)
4004 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
4005 printf ("%s%s", get_FORM_name (form
),
4006 n
== nargs
- 1 ? "\n" : ", ");
4016 case DW_FORM_block1
:
4017 case DW_FORM_block2
:
4018 case DW_FORM_block4
:
4020 case DW_FORM_string
:
4022 case DW_FORM_sec_offset
:
4025 error (_("Invalid extension opcode form %s\n"),
4026 get_FORM_name (form
));
4042 error (_(".debug_macro section not zero terminated\n"));
4046 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4052 case DW_MACRO_GNU_start_file
:
4054 unsigned int filenum
;
4055 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4057 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4059 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4062 if ((flags
& 2) == 0)
4063 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4066 = get_line_filename_and_dirname (line_offset
, filenum
,
4068 if (file_name
== NULL
)
4069 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4072 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4074 dir_name
!= NULL
? (const char *) dir_name
: "",
4075 dir_name
!= NULL
? "/" : "", file_name
);
4079 case DW_MACRO_GNU_end_file
:
4080 printf (_(" DW_MACRO_GNU_end_file\n"));
4083 case DW_MACRO_GNU_define
:
4084 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4087 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4088 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4092 case DW_MACRO_GNU_undef
:
4093 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4096 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4097 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4101 case DW_MACRO_GNU_define_indirect
:
4102 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4104 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4105 string
= fetch_indirect_string (offset
);
4106 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4110 case DW_MACRO_GNU_undef_indirect
:
4111 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4113 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4114 string
= fetch_indirect_string (offset
);
4115 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4119 case DW_MACRO_GNU_transparent_include
:
4120 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4121 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4122 (unsigned long) offset
);
4125 case DW_MACRO_GNU_define_indirect_alt
:
4126 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4128 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4129 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4130 lineno
, (unsigned long) offset
);
4133 case DW_MACRO_GNU_undef_indirect_alt
:
4134 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4136 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4137 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4138 lineno
, (unsigned long) offset
);
4141 case DW_MACRO_GNU_transparent_include_alt
:
4142 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4143 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4144 (unsigned long) offset
);
4148 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
4150 error (_(" Unknown macro opcode %02x seen\n"), op
);
4155 /* Skip over unhandled opcodes. */
4157 unsigned char *desc
= extended_ops
[op
];
4158 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
4162 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
4165 printf (_(" DW_MACRO_GNU_%02x -"), op
);
4166 for (n
= 0; n
< nargs
; n
++)
4170 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
4172 = read_and_display_attr_value (0, val
,
4173 curr
, end
, 0, 0, offset_size
,
4174 version
, NULL
, 0, NULL
,
4192 display_debug_abbrev (struct dwarf_section
*section
,
4193 void *file ATTRIBUTE_UNUSED
)
4195 abbrev_entry
*entry
;
4196 unsigned char *start
= section
->start
;
4197 unsigned char *end
= start
+ section
->size
;
4199 printf (_("Contents of the %s section:\n\n"), section
->name
);
4203 unsigned char *last
;
4208 start
= process_abbrev_section (start
, end
);
4210 if (first_abbrev
== NULL
)
4213 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4215 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4219 printf (" %ld %s [%s]\n",
4221 get_TAG_name (entry
->tag
),
4222 entry
->children
? _("has children") : _("no children"));
4224 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4225 printf (" %-18s %s\n",
4226 get_AT_name (attr
->attribute
),
4227 get_FORM_name (attr
->form
));
4237 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4240 display_loc_list (struct dwarf_section
*section
,
4241 unsigned char **start_ptr
,
4242 int debug_info_entry
,
4243 unsigned long offset
,
4244 unsigned long base_address
,
4247 unsigned char *start
= *start_ptr
;
4248 unsigned char *section_end
= section
->start
+ section
->size
;
4249 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4250 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4251 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4252 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4256 unsigned short length
;
4257 int need_frame_base
;
4259 if (pointer_size
< 2 || pointer_size
> 8)
4261 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4262 pointer_size
, debug_info_entry
);
4268 if (start
+ 2 * pointer_size
> section_end
)
4270 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4275 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4277 /* Note: we use sign extension here in order to be sure that we can detect
4278 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4279 address will not affect the values that we display since we always show
4280 hex values, and always the bottom 32-bits. */
4281 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4282 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4284 if (begin
== 0 && end
== 0)
4286 printf (_("<End of list>\n"));
4290 /* Check base address specifiers. */
4291 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4294 print_dwarf_vma (begin
, pointer_size
);
4295 print_dwarf_vma (end
, pointer_size
);
4296 printf (_("(base address)\n"));
4300 if (start
+ 2 > section_end
)
4302 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4307 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4309 if (start
+ length
> section_end
)
4311 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4316 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4317 print_dwarf_vma (end
+ base_address
, pointer_size
);
4320 need_frame_base
= decode_location_expression (start
,
4325 cu_offset
, section
);
4328 if (need_frame_base
&& !has_frame_base
)
4329 printf (_(" [without DW_AT_frame_base]"));
4332 fputs (_(" (start == end)"), stdout
);
4333 else if (begin
> end
)
4334 fputs (_(" (start > end)"), stdout
);
4344 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4345 right-adjusted in a field of length LEN, and followed by a space. */
4348 print_addr_index (unsigned int idx
, unsigned int len
)
4350 static char buf
[15];
4351 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4352 printf ("%*s ", len
, buf
);
4355 /* Display a location list from a .dwo section. It uses address indexes rather
4356 than embedded addresses. This code closely follows display_loc_list, but the
4357 two are sufficiently different that combining things is very ugly. */
4360 display_loc_list_dwo (struct dwarf_section
*section
,
4361 unsigned char **start_ptr
,
4362 int debug_info_entry
,
4363 unsigned long offset
,
4366 unsigned char *start
= *start_ptr
;
4367 unsigned char *section_end
= section
->start
+ section
->size
;
4368 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4369 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4370 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4371 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4373 unsigned short length
;
4374 int need_frame_base
;
4376 unsigned int bytes_read
;
4378 if (pointer_size
< 2 || pointer_size
> 8)
4380 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4381 pointer_size
, debug_info_entry
);
4387 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4389 if (start
>= section_end
)
4391 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4396 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4399 case 0: /* A terminating entry. */
4401 printf (_("<End of list>\n"));
4403 case 1: /* A base-address entry. */
4404 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4405 start
+= bytes_read
;
4406 print_addr_index (idx
, 8);
4408 printf (_("(base address selection entry)\n"));
4410 case 2: /* A start/end entry. */
4411 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4412 start
+= bytes_read
;
4413 print_addr_index (idx
, 8);
4414 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4415 start
+= bytes_read
;
4416 print_addr_index (idx
, 8);
4418 case 3: /* A start/length entry. */
4419 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4420 start
+= bytes_read
;
4421 print_addr_index (idx
, 8);
4422 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4423 printf ("%08x ", idx
);
4425 case 4: /* An offset pair entry. */
4426 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4427 printf ("%08x ", idx
);
4428 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4429 printf ("%08x ", idx
);
4432 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4437 if (start
+ 2 > section_end
)
4439 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4444 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4445 if (start
+ length
> section_end
)
4447 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4453 need_frame_base
= decode_location_expression (start
,
4458 cu_offset
, section
);
4461 if (need_frame_base
&& !has_frame_base
)
4462 printf (_(" [without DW_AT_frame_base]"));
4472 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4474 static dwarf_vma
*loc_offsets
;
4477 loc_offsets_compar (const void *ap
, const void *bp
)
4479 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4480 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4482 return (a
> b
) - (b
> a
);
4486 display_debug_loc (struct dwarf_section
*section
, void *file
)
4488 unsigned char *start
= section
->start
;
4489 unsigned long bytes
;
4490 unsigned char *section_begin
= start
;
4491 unsigned int num_loc_list
= 0;
4492 unsigned long last_offset
= 0;
4493 unsigned int first
= 0;
4497 int seen_first_offset
= 0;
4498 int locs_sorted
= 1;
4499 unsigned char *next
;
4500 unsigned int *array
= NULL
;
4501 const char *suffix
= strrchr (section
->name
, '.');
4504 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4507 bytes
= section
->size
;
4511 printf (_("\nThe %s section is empty.\n"), section
->name
);
4515 if (load_debug_info (file
) == 0)
4517 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4522 /* Check the order of location list in .debug_info section. If
4523 offsets of location lists are in the ascending order, we can
4524 use `debug_information' directly. */
4525 for (i
= 0; i
< num_debug_info_entries
; i
++)
4529 num
= debug_information
[i
].num_loc_offsets
;
4530 if (num
> num_loc_list
)
4533 /* Check if we can use `debug_information' directly. */
4534 if (locs_sorted
&& num
!= 0)
4536 if (!seen_first_offset
)
4538 /* This is the first location list. */
4539 last_offset
= debug_information
[i
].loc_offsets
[0];
4541 seen_first_offset
= 1;
4547 for (; j
< num
; j
++)
4550 debug_information
[i
].loc_offsets
[j
])
4555 last_offset
= debug_information
[i
].loc_offsets
[j
];
4560 if (!seen_first_offset
)
4561 error (_("No location lists in .debug_info section!\n"));
4563 if (debug_information
[first
].num_loc_offsets
> 0
4564 && debug_information
[first
].loc_offsets
[0] != 0)
4565 warn (_("Location lists in %s section start at 0x%s\n"),
4567 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4570 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4571 printf (_("Contents of the %s section:\n\n"), section
->name
);
4572 printf (_(" Offset Begin End Expression\n"));
4574 seen_first_offset
= 0;
4575 for (i
= first
; i
< num_debug_info_entries
; i
++)
4577 unsigned long offset
;
4578 unsigned long base_address
;
4583 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4585 loc_offsets
= debug_information
[i
].loc_offsets
;
4586 qsort (array
, debug_information
[i
].num_loc_offsets
,
4587 sizeof (*array
), loc_offsets_compar
);
4590 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4592 j
= locs_sorted
? k
: array
[k
];
4594 && debug_information
[i
].loc_offsets
[locs_sorted
4595 ? k
- 1 : array
[k
- 1]]
4596 == debug_information
[i
].loc_offsets
[j
])
4598 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4599 offset
= debug_information
[i
].loc_offsets
[j
];
4600 next
= section_begin
+ offset
;
4601 base_address
= debug_information
[i
].base_address
;
4603 if (!seen_first_offset
)
4604 seen_first_offset
= 1;
4608 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4609 (unsigned long) (start
- section_begin
),
4610 (unsigned long) (next
- section_begin
));
4611 else if (start
> next
)
4612 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4613 (unsigned long) (start
- section_begin
),
4614 (unsigned long) (next
- section_begin
));
4618 if (offset
>= bytes
)
4620 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4626 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4628 display_loc_list (section
, &start
, i
, offset
, base_address
,
4633 if (start
< section
->start
+ section
->size
)
4634 warn (_("There are %ld unused bytes at the end of section %s\n"),
4635 (long) (section
->start
+ section
->size
- start
), section
->name
);
4642 display_debug_str (struct dwarf_section
*section
,
4643 void *file ATTRIBUTE_UNUSED
)
4645 unsigned char *start
= section
->start
;
4646 unsigned long bytes
= section
->size
;
4647 dwarf_vma addr
= section
->address
;
4651 printf (_("\nThe %s section is empty.\n"), section
->name
);
4655 printf (_("Contents of the %s section:\n\n"), section
->name
);
4663 lbytes
= (bytes
> 16 ? 16 : bytes
);
4665 printf (" 0x%8.8lx ", (unsigned long) addr
);
4667 for (j
= 0; j
< 16; j
++)
4670 printf ("%2.2x", start
[j
]);
4678 for (j
= 0; j
< lbytes
; j
++)
4681 if (k
>= ' ' && k
< 0x80)
4700 display_debug_info (struct dwarf_section
*section
, void *file
)
4702 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4706 display_debug_types (struct dwarf_section
*section
, void *file
)
4708 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4712 display_trace_info (struct dwarf_section
*section
, void *file
)
4714 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4718 display_debug_aranges (struct dwarf_section
*section
,
4719 void *file ATTRIBUTE_UNUSED
)
4721 unsigned char *start
= section
->start
;
4722 unsigned char *end
= start
+ section
->size
;
4724 printf (_("Contents of the %s section:\n\n"), section
->name
);
4726 /* It does not matter if this load fails,
4727 we test for that later on. */
4728 load_debug_info (file
);
4732 unsigned char *hdrptr
;
4733 DWARF2_Internal_ARange arange
;
4734 unsigned char *addr_ranges
;
4737 unsigned char address_size
;
4739 unsigned int offset_size
;
4740 unsigned int initial_length_size
;
4744 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4745 if (arange
.ar_length
== 0xffffffff)
4747 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4749 initial_length_size
= 12;
4754 initial_length_size
= 4;
4757 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4758 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4760 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4761 && num_debug_info_entries
> 0
4762 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4763 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4764 (unsigned long) arange
.ar_info_offset
, section
->name
);
4766 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4767 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4769 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4771 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4775 printf (_(" Length: %ld\n"),
4776 (long) arange
.ar_length
);
4777 printf (_(" Version: %d\n"), arange
.ar_version
);
4778 printf (_(" Offset into .debug_info: 0x%lx\n"),
4779 (unsigned long) arange
.ar_info_offset
);
4780 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4781 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4783 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4785 /* PR 17512: file: 001-108546-0.001:0.1. */
4786 if (address_size
== 0 || address_size
> 8)
4788 error (_("Invalid address size in %s section!\n"),
4793 /* The DWARF spec does not require that the address size be a power
4794 of two, but we do. This will have to change if we ever encounter
4795 an uneven architecture. */
4796 if ((address_size
& (address_size
- 1)) != 0)
4798 warn (_("Pointer size + Segment size is not a power of two.\n"));
4802 if (address_size
> 4)
4803 printf (_("\n Address Length\n"));
4805 printf (_("\n Address Length\n"));
4807 addr_ranges
= hdrptr
;
4809 /* Must pad to an alignment boundary that is twice the address size. */
4810 excess
= (hdrptr
- start
) % (2 * address_size
);
4812 addr_ranges
+= (2 * address_size
) - excess
;
4814 start
+= arange
.ar_length
+ initial_length_size
;
4816 while (addr_ranges
+ 2 * address_size
<= start
)
4818 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4819 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4822 print_dwarf_vma (address
, address_size
);
4823 print_dwarf_vma (length
, address_size
);
4833 /* Comparison function for qsort. */
4835 comp_addr_base (const void * v0
, const void * v1
)
4837 debug_info
* info0
= (debug_info
*) v0
;
4838 debug_info
* info1
= (debug_info
*) v1
;
4839 return info0
->addr_base
- info1
->addr_base
;
4842 /* Display the debug_addr section. */
4844 display_debug_addr (struct dwarf_section
*section
,
4847 debug_info
**debug_addr_info
;
4848 unsigned char *entry
;
4853 if (section
->size
== 0)
4855 printf (_("\nThe %s section is empty.\n"), section
->name
);
4859 if (load_debug_info (file
) == 0)
4861 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4866 printf (_("Contents of the %s section:\n\n"), section
->name
);
4868 debug_addr_info
= (debug_info
**) xmalloc ((num_debug_info_entries
+ 1)
4869 * sizeof (debug_info
*));
4872 for (i
= 0; i
< num_debug_info_entries
; i
++)
4874 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4875 debug_addr_info
[count
++] = &debug_information
[i
];
4878 /* Add a sentinel to make iteration convenient. */
4879 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
4880 debug_addr_info
[count
]->addr_base
= section
->size
;
4882 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
4883 for (i
= 0; i
< count
; i
++)
4886 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
4888 printf (_(" For compilation unit at offset 0x%s:\n"),
4889 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
4891 printf (_("\tIndex\tAddress\n"));
4892 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
4893 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
4897 dwarf_vma base
= byte_get (entry
, address_size
);
4898 printf (_("\t%d:\t"), idx
);
4899 print_dwarf_vma (base
, address_size
);
4901 entry
+= address_size
;
4907 free (debug_addr_info
);
4911 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4913 display_debug_str_offsets (struct dwarf_section
*section
,
4914 void *file ATTRIBUTE_UNUSED
)
4916 if (section
->size
== 0)
4918 printf (_("\nThe %s section is empty.\n"), section
->name
);
4921 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
4922 what the offset size is for this section. */
4926 /* Each debug_information[x].range_lists[y] gets this representation for
4927 sorting purposes. */
4931 /* The debug_information[x].range_lists[y] value. */
4932 unsigned long ranges_offset
;
4934 /* Original debug_information to find parameters of the data. */
4935 debug_info
*debug_info_p
;
4938 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4941 range_entry_compar (const void *ap
, const void *bp
)
4943 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
4944 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
4945 const unsigned long a
= a_re
->ranges_offset
;
4946 const unsigned long b
= b_re
->ranges_offset
;
4948 return (a
> b
) - (b
> a
);
4952 display_debug_ranges (struct dwarf_section
*section
,
4953 void *file ATTRIBUTE_UNUSED
)
4955 unsigned char *start
= section
->start
;
4956 unsigned char *last_start
= start
;
4957 unsigned long bytes
= section
->size
;
4958 unsigned char *section_begin
= start
;
4959 unsigned char *finish
= start
+ bytes
;
4960 unsigned int num_range_list
, i
;
4961 struct range_entry
*range_entries
, *range_entry_fill
;
4965 printf (_("\nThe %s section is empty.\n"), section
->name
);
4969 if (load_debug_info (file
) == 0)
4971 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4977 for (i
= 0; i
< num_debug_info_entries
; i
++)
4978 num_range_list
+= debug_information
[i
].num_range_lists
;
4980 if (num_range_list
== 0)
4982 /* This can happen when the file was compiled with -gsplit-debug
4983 which removes references to range lists from the primary .o file. */
4984 printf (_("No range lists in .debug_info section.\n"));
4988 range_entries
= (struct range_entry
*)
4989 xmalloc (sizeof (*range_entries
) * num_range_list
);
4990 range_entry_fill
= range_entries
;
4992 for (i
= 0; i
< num_debug_info_entries
; i
++)
4994 debug_info
*debug_info_p
= &debug_information
[i
];
4997 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
4999 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
5000 range_entry_fill
->debug_info_p
= debug_info_p
;
5005 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
5006 range_entry_compar
);
5008 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
5009 warn (_("Range lists in %s section start at 0x%lx\n"),
5010 section
->name
, range_entries
[0].ranges_offset
);
5012 printf (_("Contents of the %s section:\n\n"), section
->name
);
5013 printf (_(" Offset Begin End\n"));
5015 for (i
= 0; i
< num_range_list
; i
++)
5017 struct range_entry
*range_entry
= &range_entries
[i
];
5018 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
5019 unsigned int pointer_size
;
5020 unsigned long offset
;
5021 unsigned char *next
;
5022 unsigned long base_address
;
5024 pointer_size
= debug_info_p
->pointer_size
;
5025 offset
= range_entry
->ranges_offset
;
5026 next
= section_begin
+ offset
;
5027 base_address
= debug_info_p
->base_address
;
5029 /* PR 17512: file: 001-101485-0.001:0.1. */
5030 if (pointer_size
< 2 || pointer_size
> 8)
5032 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5033 pointer_size
, offset
);
5037 if (dwarf_check
!= 0 && i
> 0)
5040 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5041 (unsigned long) (start
- section_begin
),
5042 (unsigned long) (next
- section_begin
), section
->name
);
5043 else if (start
> next
)
5045 if (next
== last_start
)
5047 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5048 (unsigned long) (start
- section_begin
),
5049 (unsigned long) (next
- section_begin
), section
->name
);
5055 while (start
< finish
)
5060 /* Note: we use sign extension here in order to be sure that
5061 we can detect the -1 escape value. Sign extension into the
5062 top 32 bits of a 32-bit address will not affect the values
5063 that we display since we always show hex values, and always
5064 the bottom 32-bits. */
5065 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
5066 if (start
>= finish
)
5068 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
5070 printf (" %8.8lx ", offset
);
5072 if (begin
== 0 && end
== 0)
5074 printf (_("<End of list>\n"));
5078 /* Check base address specifiers. */
5079 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
5082 print_dwarf_vma (begin
, pointer_size
);
5083 print_dwarf_vma (end
, pointer_size
);
5084 printf ("(base address)\n");
5088 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5089 print_dwarf_vma (end
+ base_address
, pointer_size
);
5092 fputs (_("(start == end)"), stdout
);
5093 else if (begin
> end
)
5094 fputs (_("(start > end)"), stdout
);
5101 free (range_entries
);
5106 typedef struct Frame_Chunk
5108 struct Frame_Chunk
*next
;
5109 unsigned char *chunk_start
;
5111 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5112 short int *col_type
;
5115 unsigned int code_factor
;
5122 unsigned char fde_encoding
;
5123 unsigned char cfa_exp
;
5124 unsigned char ptr_size
;
5125 unsigned char segment_size
;
5129 static const char *const *dwarf_regnames
;
5130 static unsigned int dwarf_regnames_count
;
5132 /* A marker for a col_type that means this column was never referenced
5133 in the frame info. */
5134 #define DW_CFA_unreferenced (-1)
5136 /* Return 0 if no more space is needed, 1 if more space is needed,
5137 -1 for invalid reg. */
5140 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
5142 unsigned int prev
= fc
->ncols
;
5144 if (reg
< (unsigned int) fc
->ncols
)
5147 if (dwarf_regnames_count
5148 && reg
> dwarf_regnames_count
)
5151 fc
->ncols
= reg
+ 1;
5152 /* PR 17512: file: 10450-2643-0.004.
5153 If reg == -1 then this can happen... */
5157 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
5158 sizeof (short int));
5159 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
5160 /* PR 17512: file:002-10025-0.005. */
5161 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
5163 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5169 while (prev
< fc
->ncols
)
5171 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
5172 fc
->col_offset
[prev
] = 0;
5178 static const char *const dwarf_regnames_i386
[] =
5180 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5181 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5182 "eip", "eflags", NULL
, /* 8 - 10 */
5183 "st0", "st1", "st2", "st3", /* 11 - 14 */
5184 "st4", "st5", "st6", "st7", /* 15 - 18 */
5185 NULL
, NULL
, /* 19 - 20 */
5186 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5187 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5188 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5189 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5190 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5191 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5192 "tr", "ldtr", /* 48 - 49 */
5193 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5194 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5195 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5196 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5197 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5198 NULL
, NULL
, NULL
, /* 90 - 92 */
5199 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5203 init_dwarf_regnames_i386 (void)
5205 dwarf_regnames
= dwarf_regnames_i386
;
5206 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5209 static const char *const dwarf_regnames_x86_64
[] =
5211 "rax", "rdx", "rcx", "rbx",
5212 "rsi", "rdi", "rbp", "rsp",
5213 "r8", "r9", "r10", "r11",
5214 "r12", "r13", "r14", "r15",
5216 "xmm0", "xmm1", "xmm2", "xmm3",
5217 "xmm4", "xmm5", "xmm6", "xmm7",
5218 "xmm8", "xmm9", "xmm10", "xmm11",
5219 "xmm12", "xmm13", "xmm14", "xmm15",
5220 "st0", "st1", "st2", "st3",
5221 "st4", "st5", "st6", "st7",
5222 "mm0", "mm1", "mm2", "mm3",
5223 "mm4", "mm5", "mm6", "mm7",
5225 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5226 "fs.base", "gs.base", NULL
, NULL
,
5228 "mxcsr", "fcw", "fsw",
5229 "xmm16", "xmm17", "xmm18", "xmm19",
5230 "xmm20", "xmm21", "xmm22", "xmm23",
5231 "xmm24", "xmm25", "xmm26", "xmm27",
5232 "xmm28", "xmm29", "xmm30", "xmm31",
5233 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5234 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5235 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5236 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5237 NULL
, NULL
, NULL
, /* 115 - 117 */
5238 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5242 init_dwarf_regnames_x86_64 (void)
5244 dwarf_regnames
= dwarf_regnames_x86_64
;
5245 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5248 static const char *const dwarf_regnames_aarch64
[] =
5250 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5251 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5252 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5253 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5254 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5255 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5256 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5257 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5258 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5259 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5260 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5261 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5265 init_dwarf_regnames_aarch64 (void)
5267 dwarf_regnames
= dwarf_regnames_aarch64
;
5268 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
5272 init_dwarf_regnames (unsigned int e_machine
)
5278 init_dwarf_regnames_i386 ();
5284 init_dwarf_regnames_x86_64 ();
5288 init_dwarf_regnames_aarch64 ();
5297 regname (unsigned int regno
, int row
)
5299 static char reg
[64];
5301 && regno
< dwarf_regnames_count
5302 && dwarf_regnames
[regno
] != NULL
)
5305 return dwarf_regnames
[regno
];
5306 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5307 dwarf_regnames
[regno
]);
5310 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5315 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
5320 if (*max_regs
< fc
->ncols
)
5321 *max_regs
= fc
->ncols
;
5323 if (*need_col_headers
)
5325 static const char *sloc
= " LOC";
5327 *need_col_headers
= 0;
5329 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5331 for (r
= 0; r
< *max_regs
; r
++)
5332 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5337 printf ("%-5s ", regname (r
, 1));
5343 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5345 strcpy (tmp
, "exp");
5347 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5348 printf ("%-8s ", tmp
);
5350 for (r
= 0; r
< fc
->ncols
; r
++)
5352 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5354 switch (fc
->col_type
[r
])
5356 case DW_CFA_undefined
:
5359 case DW_CFA_same_value
:
5363 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5365 case DW_CFA_val_offset
:
5366 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5368 case DW_CFA_register
:
5369 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5371 case DW_CFA_expression
:
5372 strcpy (tmp
, "exp");
5374 case DW_CFA_val_expression
:
5375 strcpy (tmp
, "vexp");
5378 strcpy (tmp
, "n/a");
5381 printf ("%-5s ", tmp
);
5387 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5388 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5389 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5391 static unsigned char *
5392 read_cie (unsigned char *start
, unsigned char *end
,
5393 Frame_Chunk
**p_cie
, int *p_version
,
5394 unsigned long *p_aug_len
, unsigned char **p_aug
)
5398 unsigned int length_return
;
5399 unsigned char *augmentation_data
= NULL
;
5400 unsigned long augmentation_data_len
= 0;
5403 /* PR 17512: file: 001-228113-0.004. */
5407 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5408 memset (fc
, 0, sizeof (Frame_Chunk
));
5410 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5411 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5415 fc
->augmentation
= (char *) start
;
5416 /* PR 17512: file: 001-228113-0.004.
5417 Skip past augmentation name, but avoid running off the end of the data. */
5419 if (* start
++ == '\0')
5423 warn (_("No terminator for augmentation name\n"));
5427 if (strcmp (fc
->augmentation
, "eh") == 0)
5428 start
+= eh_addr_size
;
5432 GET (fc
->ptr_size
, 1);
5433 GET (fc
->segment_size
, 1);
5434 eh_addr_size
= fc
->ptr_size
;
5438 fc
->ptr_size
= eh_addr_size
;
5439 fc
->segment_size
= 0;
5441 fc
->code_factor
= LEB ();
5442 fc
->data_factor
= SLEB ();
5452 if (fc
->augmentation
[0] == 'z')
5454 augmentation_data_len
= LEB ();
5455 augmentation_data
= start
;
5456 start
+= augmentation_data_len
;
5457 /* PR 17512: file: 11042-2589-0.004. */
5460 warn (_("Augmentation data too long: 0x%lx"), augmentation_data_len
);
5465 if (augmentation_data_len
)
5467 unsigned char *p
, *q
;
5468 p
= (unsigned char *) fc
->augmentation
+ 1;
5469 q
= augmentation_data
;
5471 while (p
< end
&& q
< augmentation_data
+ augmentation_data_len
)
5476 q
+= 1 + size_of_encoded_value (*q
);
5478 fc
->fde_encoding
= *q
++;
5489 *p_version
= version
;
5492 *p_aug_len
= augmentation_data_len
;
5493 *p_aug
= augmentation_data
;
5499 display_debug_frames (struct dwarf_section
*section
,
5500 void *file ATTRIBUTE_UNUSED
)
5502 unsigned char *start
= section
->start
;
5503 unsigned char *end
= start
+ section
->size
;
5504 unsigned char *section_start
= start
;
5505 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
5506 Frame_Chunk
*remembered_state
= 0;
5508 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5509 unsigned int length_return
;
5510 unsigned int max_regs
= 0;
5511 const char *bad_reg
= _("bad register: ");
5512 int saved_eh_addr_size
= eh_addr_size
;
5514 printf (_("Contents of the %s section:\n"), section
->name
);
5518 unsigned char *saved_start
;
5519 unsigned char *block_end
;
5524 int need_col_headers
= 1;
5525 unsigned char *augmentation_data
= NULL
;
5526 unsigned long augmentation_data_len
= 0;
5527 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5528 unsigned int offset_size
;
5529 unsigned int initial_length_size
;
5531 saved_start
= start
;
5533 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5537 printf ("\n%08lx ZERO terminator\n\n",
5538 (unsigned long)(saved_start
- section_start
));
5539 /* Skip any zero terminators that directly follow.
5540 A corrupt section size could have loaded a whole
5541 slew of zero filled memory bytes. eg
5542 PR 17512: file: 070-19381-0.004. */
5543 while (start
< end
&& * start
== 0)
5548 if (length
== 0xffffffff)
5550 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5552 initial_length_size
= 12;
5557 initial_length_size
= 4;
5560 block_end
= saved_start
+ length
+ initial_length_size
;
5561 if (block_end
> end
|| block_end
< start
)
5563 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5564 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5565 (unsigned long) (saved_start
- section_start
));
5569 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5571 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5572 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5577 start
= read_cie (start
, end
, &cie
, &version
,
5578 &augmentation_data_len
, &augmentation_data
);
5579 /* PR 17512: file: 027-135133-0.005. */
5586 fc
->chunk_start
= saved_start
;
5587 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5590 frame_need_space (fc
, mreg
);
5591 if (fc
->fde_encoding
)
5592 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5594 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5595 print_dwarf_vma (length
, fc
->ptr_size
);
5596 print_dwarf_vma (cie_id
, offset_size
);
5598 if (do_debug_frames_interp
)
5600 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5601 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5606 printf (" Version: %d\n", version
);
5607 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5610 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5611 printf (" Segment Size: %u\n", fc
->segment_size
);
5613 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5614 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5615 printf (" Return address column: %d\n", fc
->ra
);
5617 if (augmentation_data_len
)
5621 printf (" Augmentation data: ");
5622 for (i
= 0; i
< augmentation_data_len
; ++i
)
5623 /* FIXME: If do_wide is FALSE, then we should
5624 add carriage returns at 80 columns... */
5625 printf (" %02x", augmentation_data
[i
]);
5633 unsigned char *look_for
;
5634 static Frame_Chunk fde_fc
;
5635 unsigned long segment_selector
;
5639 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
5640 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
5643 look_for
= section_start
+ cie_id
;
5645 if (look_for
<= saved_start
)
5647 for (cie
= chunks
; cie
; cie
= cie
->next
)
5648 if (cie
->chunk_start
== look_for
)
5653 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
5654 if (cie
->chunk_start
== look_for
)
5658 unsigned int off_size
;
5659 unsigned char *cie_scan
;
5661 cie_scan
= look_for
;
5663 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
5664 if (length
== 0xffffffff)
5666 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
5673 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
5676 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
5677 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
5682 read_cie (cie_scan
, end
, &cie
, &version
,
5683 &augmentation_data_len
, &augmentation_data
);
5684 /* PR 17512: file: 3450-2098-0.004. */
5687 warn (_("Failed to read CIE information\n"));
5690 cie
->next
= forward_refs
;
5692 cie
->chunk_start
= look_for
;
5693 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5696 frame_need_space (cie
, mreg
);
5697 if (cie
->fde_encoding
)
5699 = size_of_encoded_value (cie
->fde_encoding
);
5706 memset (fc
, 0, sizeof (Frame_Chunk
));
5710 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5711 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5712 (unsigned long) (saved_start
- section_start
));
5714 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5715 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5716 frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0);
5718 fc
->augmentation
= "";
5719 fc
->fde_encoding
= 0;
5720 fc
->ptr_size
= eh_addr_size
;
5721 fc
->segment_size
= 0;
5725 fc
->ncols
= cie
->ncols
;
5726 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5727 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5728 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5729 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5730 fc
->augmentation
= cie
->augmentation
;
5731 fc
->ptr_size
= cie
->ptr_size
;
5732 eh_addr_size
= cie
->ptr_size
;
5733 fc
->segment_size
= cie
->segment_size
;
5734 fc
->code_factor
= cie
->code_factor
;
5735 fc
->data_factor
= cie
->data_factor
;
5736 fc
->cfa_reg
= cie
->cfa_reg
;
5737 fc
->cfa_offset
= cie
->cfa_offset
;
5739 frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0);
5740 fc
->fde_encoding
= cie
->fde_encoding
;
5743 if (fc
->fde_encoding
)
5744 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5746 segment_selector
= 0;
5747 if (fc
->segment_size
)
5748 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5750 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
5752 /* FIXME: It appears that sometimes the final pc_range value is
5753 encoded in less than encoded_ptr_size bytes. See the x86_64
5754 run of the "objcopy on compressed debug sections" test for an
5756 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5758 if (cie
->augmentation
[0] == 'z')
5760 augmentation_data_len
= LEB ();
5761 augmentation_data
= start
;
5762 start
+= augmentation_data_len
;
5763 /* PR 17512: file: 722-8446-0.004. */
5766 warn (_("Corrupt augmentation data length: %lx\n"),
5767 augmentation_data_len
);
5769 augmentation_data
= NULL
;
5770 augmentation_data_len
= 0;
5774 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5775 (unsigned long)(saved_start
- section_start
),
5776 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
5777 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5778 (unsigned long)(cie
->chunk_start
- section_start
));
5780 if (fc
->segment_size
)
5781 printf ("%04lx:", segment_selector
);
5784 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
5785 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
5787 if (! do_debug_frames_interp
&& augmentation_data_len
)
5791 printf (" Augmentation data: ");
5792 for (i
= 0; i
< augmentation_data_len
; ++i
)
5793 printf (" %02x", augmentation_data
[i
]);
5799 /* At this point, fc is the current chunk, cie (if any) is set, and
5800 we're about to interpret instructions for the chunk. */
5801 /* ??? At present we need to do this always, since this sizes the
5802 fc->col_type and fc->col_offset arrays, which we write into always.
5803 We should probably split the interpreted and non-interpreted bits
5804 into two different routines, since there's so much that doesn't
5805 really overlap between them. */
5806 if (1 || do_debug_frames_interp
)
5808 /* Start by making a pass over the chunk, allocating storage
5809 and taking note of what registers are used. */
5810 unsigned char *tmp
= start
;
5812 while (start
< block_end
)
5814 unsigned int reg
, op
, opa
;
5822 /* Warning: if you add any more cases to this switch, be
5823 sure to add them to the corresponding switch below. */
5826 case DW_CFA_advance_loc
:
5830 if (frame_need_space (fc
, opa
) >= 0)
5831 fc
->col_type
[opa
] = DW_CFA_undefined
;
5833 case DW_CFA_restore
:
5834 if (frame_need_space (fc
, opa
) >= 0)
5835 fc
->col_type
[opa
] = DW_CFA_undefined
;
5837 case DW_CFA_set_loc
:
5838 start
+= encoded_ptr_size
;
5840 case DW_CFA_advance_loc1
:
5843 case DW_CFA_advance_loc2
:
5846 case DW_CFA_advance_loc4
:
5849 case DW_CFA_offset_extended
:
5850 case DW_CFA_val_offset
:
5851 reg
= LEB (); LEB ();
5852 if (frame_need_space (fc
, reg
) >= 0)
5853 fc
->col_type
[reg
] = DW_CFA_undefined
;
5855 case DW_CFA_restore_extended
:
5857 frame_need_space (fc
, reg
);
5858 if (frame_need_space (fc
, reg
) >= 0)
5859 fc
->col_type
[reg
] = DW_CFA_undefined
;
5861 case DW_CFA_undefined
:
5863 if (frame_need_space (fc
, reg
) >= 0)
5864 fc
->col_type
[reg
] = DW_CFA_undefined
;
5866 case DW_CFA_same_value
:
5868 if (frame_need_space (fc
, reg
) >= 0)
5869 fc
->col_type
[reg
] = DW_CFA_undefined
;
5871 case DW_CFA_register
:
5872 reg
= LEB (); LEB ();
5873 if (frame_need_space (fc
, reg
) >= 0)
5874 fc
->col_type
[reg
] = DW_CFA_undefined
;
5876 case DW_CFA_def_cfa
:
5879 case DW_CFA_def_cfa_register
:
5882 case DW_CFA_def_cfa_offset
:
5885 case DW_CFA_def_cfa_expression
:
5887 if (start
+ temp
< start
)
5889 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
5895 case DW_CFA_expression
:
5896 case DW_CFA_val_expression
:
5899 if (start
+ temp
< start
)
5901 /* PR 17512: file:306-192417-0.005. */
5902 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
5907 if (frame_need_space (fc
, reg
) >= 0)
5908 fc
->col_type
[reg
] = DW_CFA_undefined
;
5910 case DW_CFA_offset_extended_sf
:
5911 case DW_CFA_val_offset_sf
:
5912 reg
= LEB (); SLEB ();
5913 if (frame_need_space (fc
, reg
) >= 0)
5914 fc
->col_type
[reg
] = DW_CFA_undefined
;
5916 case DW_CFA_def_cfa_sf
:
5919 case DW_CFA_def_cfa_offset_sf
:
5922 case DW_CFA_MIPS_advance_loc8
:
5925 case DW_CFA_GNU_args_size
:
5928 case DW_CFA_GNU_negative_offset_extended
:
5929 reg
= LEB (); LEB ();
5930 if (frame_need_space (fc
, reg
) >= 0)
5931 fc
->col_type
[reg
] = DW_CFA_undefined
;
5940 /* Now we know what registers are used, make a second pass over
5941 the chunk, this time actually printing out the info. */
5943 while (start
< block_end
)
5946 unsigned long ul
, reg
, roffs
;
5950 const char *reg_prefix
= "";
5957 /* Warning: if you add any more cases to this switch, be
5958 sure to add them to the corresponding switch above. */
5961 case DW_CFA_advance_loc
:
5962 if (do_debug_frames_interp
)
5963 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5965 printf (" DW_CFA_advance_loc: %d to %s\n",
5966 opa
* fc
->code_factor
,
5967 dwarf_vmatoa_1 (NULL
,
5968 fc
->pc_begin
+ opa
* fc
->code_factor
,
5970 fc
->pc_begin
+= opa
* fc
->code_factor
;
5975 if (opa
>= (unsigned int) fc
->ncols
)
5976 reg_prefix
= bad_reg
;
5977 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5978 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
5979 reg_prefix
, regname (opa
, 0),
5980 roffs
* fc
->data_factor
);
5981 if (*reg_prefix
== '\0')
5983 fc
->col_type
[opa
] = DW_CFA_offset
;
5984 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
5988 case DW_CFA_restore
:
5989 if (opa
>= (unsigned int) cie
->ncols
5990 || opa
>= (unsigned int) fc
->ncols
)
5991 reg_prefix
= bad_reg
;
5992 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5993 printf (" DW_CFA_restore: %s%s\n",
5994 reg_prefix
, regname (opa
, 0));
5995 if (*reg_prefix
== '\0')
5997 fc
->col_type
[opa
] = cie
->col_type
[opa
];
5998 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
5999 if (do_debug_frames_interp
6000 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
6001 fc
->col_type
[opa
] = DW_CFA_undefined
;
6005 case DW_CFA_set_loc
:
6006 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
6007 if (do_debug_frames_interp
)
6008 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6010 printf (" DW_CFA_set_loc: %s\n",
6011 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
6015 case DW_CFA_advance_loc1
:
6016 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
6017 if (do_debug_frames_interp
)
6018 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6020 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6021 (unsigned long) (ofs
* fc
->code_factor
),
6022 dwarf_vmatoa_1 (NULL
,
6023 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6025 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6028 case DW_CFA_advance_loc2
:
6029 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
6030 if (do_debug_frames_interp
)
6031 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6033 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6034 (unsigned long) (ofs
* fc
->code_factor
),
6035 dwarf_vmatoa_1 (NULL
,
6036 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6038 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6041 case DW_CFA_advance_loc4
:
6042 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
6043 if (do_debug_frames_interp
)
6044 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6046 printf (" DW_CFA_advance_loc4: %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_offset_extended
:
6057 if (reg
>= (unsigned int) fc
->ncols
)
6058 reg_prefix
= bad_reg
;
6059 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6060 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6061 reg_prefix
, regname (reg
, 0),
6062 roffs
* fc
->data_factor
);
6063 if (*reg_prefix
== '\0')
6065 fc
->col_type
[reg
] = DW_CFA_offset
;
6066 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6070 case DW_CFA_val_offset
:
6073 if (reg
>= (unsigned int) fc
->ncols
)
6074 reg_prefix
= bad_reg
;
6075 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6076 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6077 reg_prefix
, regname (reg
, 0),
6078 roffs
* fc
->data_factor
);
6079 if (*reg_prefix
== '\0')
6081 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6082 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6086 case DW_CFA_restore_extended
:
6088 if (reg
>= (unsigned int) cie
->ncols
6089 || reg
>= (unsigned int) fc
->ncols
)
6090 reg_prefix
= bad_reg
;
6091 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6092 printf (" DW_CFA_restore_extended: %s%s\n",
6093 reg_prefix
, regname (reg
, 0));
6094 if (*reg_prefix
== '\0')
6096 fc
->col_type
[reg
] = cie
->col_type
[reg
];
6097 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
6101 case DW_CFA_undefined
:
6103 if (reg
>= (unsigned int) fc
->ncols
)
6104 reg_prefix
= bad_reg
;
6105 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6106 printf (" DW_CFA_undefined: %s%s\n",
6107 reg_prefix
, regname (reg
, 0));
6108 if (*reg_prefix
== '\0')
6110 fc
->col_type
[reg
] = DW_CFA_undefined
;
6111 fc
->col_offset
[reg
] = 0;
6115 case DW_CFA_same_value
:
6117 if (reg
>= (unsigned int) fc
->ncols
)
6118 reg_prefix
= bad_reg
;
6119 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6120 printf (" DW_CFA_same_value: %s%s\n",
6121 reg_prefix
, regname (reg
, 0));
6122 if (*reg_prefix
== '\0')
6124 fc
->col_type
[reg
] = DW_CFA_same_value
;
6125 fc
->col_offset
[reg
] = 0;
6129 case DW_CFA_register
:
6132 if (reg
>= (unsigned int) fc
->ncols
)
6133 reg_prefix
= bad_reg
;
6134 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6136 printf (" DW_CFA_register: %s%s in ",
6137 reg_prefix
, regname (reg
, 0));
6138 puts (regname (roffs
, 0));
6140 if (*reg_prefix
== '\0')
6142 fc
->col_type
[reg
] = DW_CFA_register
;
6143 fc
->col_offset
[reg
] = roffs
;
6147 case DW_CFA_remember_state
:
6148 if (! do_debug_frames_interp
)
6149 printf (" DW_CFA_remember_state\n");
6150 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6151 rs
->cfa_offset
= fc
->cfa_offset
;
6152 rs
->cfa_reg
= fc
->cfa_reg
;
6154 rs
->cfa_exp
= fc
->cfa_exp
;
6155 rs
->ncols
= fc
->ncols
;
6156 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
6157 sizeof (* rs
->col_type
));
6158 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
6159 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
6160 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
6161 rs
->next
= remembered_state
;
6162 remembered_state
= rs
;
6165 case DW_CFA_restore_state
:
6166 if (! do_debug_frames_interp
)
6167 printf (" DW_CFA_restore_state\n");
6168 rs
= remembered_state
;
6171 remembered_state
= rs
->next
;
6172 fc
->cfa_offset
= rs
->cfa_offset
;
6173 fc
->cfa_reg
= rs
->cfa_reg
;
6175 fc
->cfa_exp
= rs
->cfa_exp
;
6176 frame_need_space (fc
, rs
->ncols
- 1);
6177 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
6178 memcpy (fc
->col_offset
, rs
->col_offset
,
6179 rs
->ncols
* sizeof (* rs
->col_offset
));
6180 free (rs
->col_type
);
6181 free (rs
->col_offset
);
6184 else if (do_debug_frames_interp
)
6185 printf ("Mismatched DW_CFA_restore_state\n");
6188 case DW_CFA_def_cfa
:
6189 fc
->cfa_reg
= LEB ();
6190 fc
->cfa_offset
= LEB ();
6192 if (! do_debug_frames_interp
)
6193 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6194 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6197 case DW_CFA_def_cfa_register
:
6198 fc
->cfa_reg
= LEB ();
6200 if (! do_debug_frames_interp
)
6201 printf (" DW_CFA_def_cfa_register: %s\n",
6202 regname (fc
->cfa_reg
, 0));
6205 case DW_CFA_def_cfa_offset
:
6206 fc
->cfa_offset
= LEB ();
6207 if (! do_debug_frames_interp
)
6208 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
6212 if (! do_debug_frames_interp
)
6213 printf (" DW_CFA_nop\n");
6216 case DW_CFA_def_cfa_expression
:
6218 if (start
>= block_end
|| start
+ ul
> block_end
)
6220 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
6223 if (! do_debug_frames_interp
)
6225 printf (" DW_CFA_def_cfa_expression (");
6226 decode_location_expression (start
, eh_addr_size
, 0, -1,
6234 case DW_CFA_expression
:
6237 if (reg
>= (unsigned int) fc
->ncols
)
6238 reg_prefix
= bad_reg
;
6239 /* PR 17512: file: 069-133014-0.006. */
6240 if (start
>= block_end
|| start
+ ul
> block_end
)
6242 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
6245 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6247 printf (" DW_CFA_expression: %s%s (",
6248 reg_prefix
, regname (reg
, 0));
6249 decode_location_expression (start
, eh_addr_size
, 0, -1,
6253 if (*reg_prefix
== '\0')
6254 fc
->col_type
[reg
] = DW_CFA_expression
;
6258 case DW_CFA_val_expression
:
6261 if (reg
>= (unsigned int) fc
->ncols
)
6262 reg_prefix
= bad_reg
;
6263 if (start
>= block_end
|| start
+ ul
> block_end
)
6265 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
6268 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6270 printf (" DW_CFA_val_expression: %s%s (",
6271 reg_prefix
, regname (reg
, 0));
6272 decode_location_expression (start
, eh_addr_size
, 0, -1,
6276 if (*reg_prefix
== '\0')
6277 fc
->col_type
[reg
] = DW_CFA_val_expression
;
6281 case DW_CFA_offset_extended_sf
:
6284 if (frame_need_space (fc
, reg
) < 0)
6285 reg_prefix
= bad_reg
;
6286 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6287 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6288 reg_prefix
, regname (reg
, 0),
6289 l
* fc
->data_factor
);
6290 if (*reg_prefix
== '\0')
6292 fc
->col_type
[reg
] = DW_CFA_offset
;
6293 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6297 case DW_CFA_val_offset_sf
:
6300 if (frame_need_space (fc
, reg
) < 0)
6301 reg_prefix
= bad_reg
;
6302 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6303 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6304 reg_prefix
, regname (reg
, 0),
6305 l
* fc
->data_factor
);
6306 if (*reg_prefix
== '\0')
6308 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6309 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6313 case DW_CFA_def_cfa_sf
:
6314 fc
->cfa_reg
= LEB ();
6315 fc
->cfa_offset
= SLEB ();
6316 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6318 if (! do_debug_frames_interp
)
6319 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6320 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6323 case DW_CFA_def_cfa_offset_sf
:
6324 fc
->cfa_offset
= SLEB ();
6325 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6326 if (! do_debug_frames_interp
)
6327 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
6330 case DW_CFA_MIPS_advance_loc8
:
6331 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
6332 if (do_debug_frames_interp
)
6333 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6335 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6336 (unsigned long) (ofs
* fc
->code_factor
),
6337 dwarf_vmatoa_1 (NULL
,
6338 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6340 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6343 case DW_CFA_GNU_window_save
:
6344 if (! do_debug_frames_interp
)
6345 printf (" DW_CFA_GNU_window_save\n");
6348 case DW_CFA_GNU_args_size
:
6350 if (! do_debug_frames_interp
)
6351 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
6354 case DW_CFA_GNU_negative_offset_extended
:
6357 if (frame_need_space (fc
, reg
) < 0)
6358 reg_prefix
= bad_reg
;
6359 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6360 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6361 reg_prefix
, regname (reg
, 0),
6362 l
* fc
->data_factor
);
6363 if (*reg_prefix
== '\0')
6365 fc
->col_type
[reg
] = DW_CFA_offset
;
6366 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6371 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
6372 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
6374 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
6379 if (do_debug_frames_interp
)
6380 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6383 eh_addr_size
= saved_eh_addr_size
;
6396 display_gdb_index (struct dwarf_section
*section
,
6397 void *file ATTRIBUTE_UNUSED
)
6399 unsigned char *start
= section
->start
;
6401 uint32_t cu_list_offset
, tu_list_offset
;
6402 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6403 unsigned int cu_list_elements
, tu_list_elements
;
6404 unsigned int address_table_size
, symbol_table_slots
;
6405 unsigned char *cu_list
, *tu_list
;
6406 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6409 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6411 printf (_("Contents of the %s section:\n"), section
->name
);
6413 if (section
->size
< 6 * sizeof (uint32_t))
6415 warn (_("Truncated header in the %s section.\n"), section
->name
);
6419 version
= byte_get_little_endian (start
, 4);
6420 printf (_("Version %ld\n"), (long) version
);
6422 /* Prior versions are obsolete, and future versions may not be
6423 backwards compatible. */
6424 if (version
< 3 || version
> 8)
6426 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6430 warn (_("The address table data in version 3 may be wrong.\n"));
6432 warn (_("Version 4 does not support case insensitive lookups.\n"));
6434 warn (_("Version 5 does not include inlined functions.\n"));
6436 warn (_("Version 6 does not include symbol attributes.\n"));
6437 /* Version 7 indices generated by Gold have bad type unit references,
6438 PR binutils/15021. But we don't know if the index was generated by
6439 Gold or not, so to avoid worrying users with gdb-generated indices
6440 we say nothing for version 7 here. */
6442 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6443 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6444 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6445 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6446 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6448 if (cu_list_offset
> section
->size
6449 || tu_list_offset
> section
->size
6450 || address_table_offset
> section
->size
6451 || symbol_table_offset
> section
->size
6452 || constant_pool_offset
> section
->size
)
6454 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6458 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6459 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6460 address_table_size
= symbol_table_offset
- address_table_offset
;
6461 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6463 cu_list
= start
+ cu_list_offset
;
6464 tu_list
= start
+ tu_list_offset
;
6465 address_table
= start
+ address_table_offset
;
6466 symbol_table
= start
+ symbol_table_offset
;
6467 constant_pool
= start
+ constant_pool_offset
;
6469 printf (_("\nCU table:\n"));
6470 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6472 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6473 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6475 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6476 (unsigned long) cu_offset
,
6477 (unsigned long) (cu_offset
+ cu_length
- 1));
6480 printf (_("\nTU table:\n"));
6481 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6483 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6484 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6485 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6487 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6488 (unsigned long) tu_offset
,
6489 (unsigned long) type_offset
);
6490 print_dwarf_vma (signature
, 8);
6494 printf (_("\nAddress table:\n"));
6495 for (i
= 0; i
< address_table_size
; i
+= 2 * 8 + 4)
6497 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6498 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6499 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6501 print_dwarf_vma (low
, 8);
6502 print_dwarf_vma (high
, 8);
6503 printf (_("%lu\n"), (unsigned long) cu_index
);
6506 printf (_("\nSymbol table:\n"));
6507 for (i
= 0; i
< symbol_table_slots
; ++i
)
6509 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6510 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6511 uint32_t num_cus
, cu
;
6513 if (name_offset
!= 0
6514 || cu_vector_offset
!= 0)
6518 printf ("[%3u] %s:", i
, constant_pool
+ name_offset
);
6519 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
6522 for (j
= 0; j
< num_cus
; ++j
)
6525 gdb_index_symbol_kind kind
;
6527 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6528 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6529 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6530 cu
= GDB_INDEX_CU_VALUE (cu
);
6531 /* Convert to TU number if it's for a type unit. */
6532 if (cu
>= cu_list_elements
/ 2)
6533 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6534 (unsigned long) (cu
- cu_list_elements
/ 2));
6536 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6538 printf (" [%s, %s]",
6539 is_static
? _("static") : _("global"),
6540 get_gdb_index_symbol_kind_name (kind
));
6552 /* Pre-allocate enough space for the CU/TU sets needed. */
6555 prealloc_cu_tu_list (unsigned int nshndx
)
6557 if (shndx_pool
== NULL
)
6559 shndx_pool_size
= nshndx
;
6560 shndx_pool_used
= 0;
6561 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6562 sizeof (unsigned int));
6566 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6567 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6568 sizeof (unsigned int));
6573 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6575 if (shndx_pool_used
>= shndx_pool_size
)
6577 error (_("Internal error: out of space in the shndx pool.\n"));
6580 shndx_pool
[shndx_pool_used
++] = shndx
;
6584 end_cu_tu_entry (void)
6586 if (shndx_pool_used
>= shndx_pool_size
)
6588 error (_("Internal error: out of space in the shndx pool.\n"));
6591 shndx_pool
[shndx_pool_used
++] = 0;
6594 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6597 get_DW_SECT_short_name (unsigned int dw_sect
)
6599 static char buf
[16];
6607 case DW_SECT_ABBREV
:
6613 case DW_SECT_STR_OFFSETS
:
6615 case DW_SECT_MACINFO
:
6623 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6627 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6628 These sections are extensions for Fission.
6629 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6632 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6634 unsigned char *phdr
= section
->start
;
6635 unsigned char *limit
= phdr
+ section
->size
;
6636 unsigned char *phash
;
6637 unsigned char *pindex
;
6638 unsigned char *ppool
;
6639 unsigned int version
;
6640 unsigned int ncols
= 0;
6642 unsigned int nslots
;
6645 dwarf_vma signature_high
;
6646 dwarf_vma signature_low
;
6649 /* PR 17512: file: 002-168123-0.004. */
6652 warn (_("Section %s is empty\n"), section
->name
);
6655 /* PR 17512: file: 002-376-0.004. */
6656 if (section
->size
< 24)
6658 warn (_("Section %s is too small to contain a CU/TU header"),
6663 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
6665 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
6666 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
6667 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
6670 pindex
= phash
+ nslots
* 8;
6671 ppool
= pindex
+ nslots
* 4;
6675 printf (_("Contents of the %s section:\n\n"), section
->name
);
6676 printf (_(" Version: %d\n"), version
);
6678 printf (_(" Number of columns: %d\n"), ncols
);
6679 printf (_(" Number of used entries: %d\n"), nused
);
6680 printf (_(" Number of slots: %d\n\n"), nslots
);
6685 warn (_("Section %s too small for %d hash table entries\n"),
6686 section
->name
, nslots
);
6693 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6694 for (i
= 0; i
< nslots
; i
++)
6696 unsigned char *shndx_list
;
6699 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
6700 if (signature_high
!= 0 || signature_low
!= 0)
6702 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
6703 shndx_list
= ppool
+ j
* 4;
6705 printf (_(" [%3d] Signature: 0x%s Sections: "),
6706 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6707 buf
, sizeof (buf
)));
6710 if (shndx_list
>= limit
)
6712 warn (_("Section %s too small for shndx pool\n"),
6716 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
6720 printf (" %d", shndx
);
6722 add_shndx_to_cu_tu_entry (shndx
);
6734 else if (version
== 2)
6737 unsigned int dw_sect
;
6738 unsigned char *ph
= phash
;
6739 unsigned char *pi
= pindex
;
6740 unsigned char *poffsets
= ppool
+ ncols
* 4;
6741 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
6742 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
6743 bfd_boolean is_tu_index
;
6744 struct cu_tu_set
*this_set
= NULL
;
6746 unsigned char *prow
;
6748 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
6752 warn (_("Section %s too small for offset and size tables\n"),
6759 printf (_(" Offset table\n"));
6760 printf (" slot %-16s ",
6761 is_tu_index
? _("signature") : _("dwo_id"));
6768 tu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6774 cu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6781 for (j
= 0; j
< ncols
; j
++)
6783 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6784 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
6789 for (i
= 0; i
< nslots
; i
++)
6791 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
6793 SAFE_BYTE_GET (row
, pi
, 4, limit
);
6797 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
6799 prow
= poffsets
+ (row
- 1) * ncols
* 4;
6802 printf (_(" [%3d] 0x%s"),
6803 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6804 buf
, sizeof (buf
)));
6805 for (j
= 0; j
< ncols
; j
++)
6807 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
6809 printf (" %8d", val
);
6812 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6813 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
6829 printf (_(" Size table\n"));
6830 printf (" slot %-16s ",
6831 is_tu_index
? _("signature") : _("dwo_id"));
6834 for (j
= 0; j
< ncols
; j
++)
6836 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
6838 printf (" %8s", get_DW_SECT_short_name (val
));
6844 for (i
= 0; i
< nslots
; i
++)
6846 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
6848 SAFE_BYTE_GET (row
, pi
, 4, limit
);
6851 prow
= psizes
+ (row
- 1) * ncols
* 4;
6854 printf (_(" [%3d] 0x%s"),
6855 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6856 buf
, sizeof (buf
)));
6858 for (j
= 0; j
< ncols
; j
++)
6860 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
6862 printf (" %8d", val
);
6865 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6866 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
6878 else if (do_display
)
6879 printf (_(" Unsupported version (%d)\n"), version
);
6887 /* Load the CU and TU indexes if present. This will build a list of
6888 section sets that we can use to associate a .debug_info.dwo section
6889 with its associated .debug_abbrev.dwo section in a .dwp file. */
6892 load_cu_tu_indexes (void *file
)
6894 /* If we have already loaded (or tried to load) the CU and TU indexes
6895 then do not bother to repeat the task. */
6896 if (cu_tu_indexes_read
)
6899 if (load_debug_section (dwp_cu_index
, file
))
6900 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
6902 if (load_debug_section (dwp_tu_index
, file
))
6903 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
6905 cu_tu_indexes_read
= 1;
6908 /* Find the set of sections that includes section SHNDX. */
6911 find_cu_tu_set (void *file
, unsigned int shndx
)
6915 load_cu_tu_indexes (file
);
6917 /* Find SHNDX in the shndx pool. */
6918 for (i
= 0; i
< shndx_pool_used
; i
++)
6919 if (shndx_pool
[i
] == shndx
)
6922 if (i
>= shndx_pool_used
)
6925 /* Now backup to find the first entry in the set. */
6926 while (i
> 0 && shndx_pool
[i
- 1] != 0)
6929 return shndx_pool
+ i
;
6932 /* Display a .debug_cu_index or .debug_tu_index section. */
6935 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
6937 return process_cu_tu_index (section
, 1);
6941 display_debug_not_supported (struct dwarf_section
*section
,
6942 void *file ATTRIBUTE_UNUSED
)
6944 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6951 cmalloc (size_t nmemb
, size_t size
)
6953 /* Check for overflow. */
6954 if (nmemb
>= ~(size_t) 0 / size
)
6957 return malloc (nmemb
* size
);
6961 xcmalloc (size_t nmemb
, size_t size
)
6963 /* Check for overflow. */
6964 if (nmemb
>= ~(size_t) 0 / size
)
6967 return xmalloc (nmemb
* size
);
6971 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
6973 /* Check for overflow. */
6974 if (nmemb
>= ~(size_t) 0 / size
)
6977 return xrealloc (ptr
, nmemb
* size
);
6981 free_debug_memory (void)
6987 for (i
= 0; i
< max
; i
++)
6988 free_debug_section ((enum dwarf_section_display_enum
) i
);
6990 if (debug_information
!= NULL
)
6992 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
6994 for (i
= 0; i
< num_debug_info_entries
; i
++)
6996 if (!debug_information
[i
].max_loc_offsets
)
6998 free (debug_information
[i
].loc_offsets
);
6999 free (debug_information
[i
].have_frame_base
);
7001 if (!debug_information
[i
].max_range_lists
)
7002 free (debug_information
[i
].range_lists
);
7006 free (debug_information
);
7007 debug_information
= NULL
;
7008 num_debug_info_entries
= 0;
7013 dwarf_select_sections_by_names (const char *names
)
7017 const char * option
;
7021 debug_dump_long_opts
;
7023 static const debug_dump_long_opts opts_table
[] =
7025 /* Please keep this table alpha- sorted. */
7026 { "Ranges", & do_debug_ranges
, 1 },
7027 { "abbrev", & do_debug_abbrevs
, 1 },
7028 { "addr", & do_debug_addr
, 1 },
7029 { "aranges", & do_debug_aranges
, 1 },
7030 { "cu_index", & do_debug_cu_index
, 1 },
7031 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
7032 { "frames", & do_debug_frames
, 1 },
7033 { "frames-interp", & do_debug_frames_interp
, 1 },
7034 /* The special .gdb_index section. */
7035 { "gdb_index", & do_gdb_index
, 1 },
7036 { "info", & do_debug_info
, 1 },
7037 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
7038 { "loc", & do_debug_loc
, 1 },
7039 { "macro", & do_debug_macinfo
, 1 },
7040 { "pubnames", & do_debug_pubnames
, 1 },
7041 { "pubtypes", & do_debug_pubtypes
, 1 },
7042 /* This entry is for compatability
7043 with earlier versions of readelf. */
7044 { "ranges", & do_debug_aranges
, 1 },
7045 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
7046 { "str", & do_debug_str
, 1 },
7047 /* These trace_* sections are used by Itanium VMS. */
7048 { "trace_abbrev", & do_trace_abbrevs
, 1 },
7049 { "trace_aranges", & do_trace_aranges
, 1 },
7050 { "trace_info", & do_trace_info
, 1 },
7059 const debug_dump_long_opts
* entry
;
7061 for (entry
= opts_table
; entry
->option
; entry
++)
7063 size_t len
= strlen (entry
->option
);
7065 if (strncmp (p
, entry
->option
, len
) == 0
7066 && (p
[len
] == ',' || p
[len
] == '\0'))
7068 * entry
->variable
|= entry
->val
;
7070 /* The --debug-dump=frames-interp option also
7071 enables the --debug-dump=frames option. */
7072 if (do_debug_frames_interp
)
7073 do_debug_frames
= 1;
7080 if (entry
->option
== NULL
)
7082 warn (_("Unrecognized debug option '%s'\n"), p
);
7083 p
= strchr (p
, ',');
7094 dwarf_select_sections_by_letters (const char *letters
)
7096 unsigned int lindex
= 0;
7098 while (letters
[lindex
])
7099 switch (letters
[lindex
++])
7106 do_debug_abbrevs
= 1;
7110 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
7114 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
7118 do_debug_pubnames
= 1;
7122 do_debug_pubtypes
= 1;
7126 do_debug_aranges
= 1;
7130 do_debug_ranges
= 1;
7134 do_debug_frames_interp
= 1;
7136 do_debug_frames
= 1;
7140 do_debug_macinfo
= 1;
7152 warn (_("Unrecognized debug option '%s'\n"), optarg
);
7158 dwarf_select_sections_all (void)
7161 do_debug_abbrevs
= 1;
7162 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
7163 do_debug_pubnames
= 1;
7164 do_debug_pubtypes
= 1;
7165 do_debug_aranges
= 1;
7166 do_debug_ranges
= 1;
7167 do_debug_frames
= 1;
7168 do_debug_macinfo
= 1;
7173 do_trace_abbrevs
= 1;
7174 do_trace_aranges
= 1;
7176 do_debug_cu_index
= 1;
7179 struct dwarf_section_display debug_displays
[] =
7181 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0 },
7182 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7183 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0 },
7184 display_debug_aranges
, &do_debug_aranges
, 1 },
7185 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0 },
7186 display_debug_frames
, &do_debug_frames
, 1 },
7187 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
},
7188 display_debug_info
, &do_debug_info
, 1 },
7189 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0 },
7190 display_debug_lines
, &do_debug_lines
, 1 },
7191 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0 },
7192 display_debug_pubnames
, &do_debug_pubnames
, 0 },
7193 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0 },
7194 display_debug_gnu_pubnames
, &do_debug_pubnames
, 0 },
7195 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0 },
7196 display_debug_frames
, &do_debug_frames
, 1 },
7197 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0 },
7198 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7199 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0 },
7200 display_debug_macro
, &do_debug_macinfo
, 1 },
7201 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0 },
7202 display_debug_str
, &do_debug_str
, 0 },
7203 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0 },
7204 display_debug_loc
, &do_debug_loc
, 1 },
7205 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0 },
7206 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
7207 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0 },
7208 display_debug_gnu_pubnames
, &do_debug_pubtypes
, 0 },
7209 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0 },
7210 display_debug_ranges
, &do_debug_ranges
, 1 },
7211 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0 },
7212 display_debug_not_supported
, NULL
, 0 },
7213 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0 },
7214 display_debug_not_supported
, NULL
, 0 },
7215 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
},
7216 display_debug_types
, &do_debug_info
, 1 },
7217 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0 },
7218 display_debug_not_supported
, NULL
, 0 },
7219 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0 },
7220 display_gdb_index
, &do_gdb_index
, 0 },
7221 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
},
7222 display_trace_info
, &do_trace_info
, 1 },
7223 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0 },
7224 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
7225 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0 },
7226 display_debug_aranges
, &do_trace_aranges
, 0 },
7227 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
7228 display_debug_info
, &do_debug_info
, 1 },
7229 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0 },
7230 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7231 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
7232 display_debug_types
, &do_debug_info
, 1 },
7233 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0 },
7234 display_debug_lines
, &do_debug_lines
, 1 },
7235 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0 },
7236 display_debug_loc
, &do_debug_loc
, 1 },
7237 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0 },
7238 display_debug_macro
, &do_debug_macinfo
, 1 },
7239 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0 },
7240 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7241 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0 },
7242 display_debug_str
, &do_debug_str
, 1 },
7243 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0 },
7244 display_debug_str_offsets
, NULL
, 0 },
7245 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0 },
7246 display_debug_str_offsets
, NULL
, 0 },
7247 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0 },
7248 display_debug_addr
, &do_debug_addr
, 1 },
7249 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0 },
7250 display_cu_index
, &do_debug_cu_index
, 0 },
7251 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0 },
7252 display_cu_index
, &do_debug_cu_index
, 0 },