1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright 2005-2013 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 #if !HAVE_DECL_STRNLEN
33 size_t strnlen (const char *, size_t);
36 static const char *regname (unsigned int regno
, int row
);
38 static int have_frame_base
;
39 static int need_base_address
;
41 static unsigned int last_pointer_size
= 0;
42 static int warned_about_missing_comp_units
= FALSE
;
44 static unsigned int num_debug_info_entries
= 0;
45 static debug_info
*debug_information
= NULL
;
46 /* Special value for num_debug_info_entries to indicate
47 that the .debug_info section could not be loaded/parsed. */
48 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
55 int do_debug_pubnames
;
56 int do_debug_pubtypes
;
60 int do_debug_frames_interp
;
69 int do_debug_cu_index
;
72 int dwarf_cutoff_level
= -1;
73 unsigned long dwarf_start_die
;
77 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
78 sections. For version 1 package files, each set is stored in SHNDX_POOL
79 as a zero-terminated list of section indexes comprising one set of debug
80 sections from a .dwo file. */
82 static int cu_tu_indexes_read
= 0;
83 static unsigned int *shndx_pool
= NULL
;
84 static unsigned int shndx_pool_size
= 0;
85 static unsigned int shndx_pool_used
= 0;
87 /* For version 2 package files, each set contains an array of section offsets
88 and an array of section sizes, giving the offset and size of the
89 contribution from a CU or TU within one of the debug sections.
90 When displaying debug info from a package file, we need to use these
91 tables to locate the corresponding contributions to each section. */
96 dwarf_vma section_offsets
[DW_SECT_MAX
];
97 size_t section_sizes
[DW_SECT_MAX
];
100 static int cu_count
= 0;
101 static int tu_count
= 0;
102 static struct cu_tu_set
*cu_sets
= NULL
;
103 static struct cu_tu_set
*tu_sets
= NULL
;
105 static void load_cu_tu_indexes (void *file
);
107 /* Values for do_debug_lines. */
108 #define FLAG_DEBUG_LINES_RAW 1
109 #define FLAG_DEBUG_LINES_DECODED 2
112 size_of_encoded_value (int encoding
)
114 switch (encoding
& 0x7)
117 case 0: return eh_addr_size
;
125 get_encoded_value (unsigned char *data
,
127 struct dwarf_section
*section
)
129 int size
= size_of_encoded_value (encoding
);
132 if (encoding
& DW_EH_PE_signed
)
133 val
= byte_get_signed (data
, size
);
135 val
= byte_get (data
, size
);
137 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
138 val
+= section
->address
+ (data
- section
->start
);
142 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
144 #define DWARF_VMA_FMT "ll"
145 #define DWARF_VMA_FMT_LONG "%16.16llx"
147 #define DWARF_VMA_FMT "I64"
148 #define DWARF_VMA_FMT_LONG "%016I64x"
151 #define DWARF_VMA_FMT "l"
152 #define DWARF_VMA_FMT_LONG "%16.16lx"
155 /* Convert a dwarf vma value into a string. Returns a pointer to a static
156 buffer containing the converted VALUE. The value is converted according
157 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
158 it specifies the maximum number of bytes to be displayed in the converted
159 value and FMTCH is ignored - hex is always used. */
162 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
164 /* As dwarf_vmatoa is used more then once in a printf call
165 for output, we are cycling through an fixed array of pointers
166 for return address. */
167 static int buf_pos
= 0;
168 static struct dwarf_vmatoa_buf
174 ret
= buf
[buf_pos
++].place
;
175 buf_pos
%= ARRAY_SIZE (buf
);
179 /* Printf does not have a way of specifiying a maximum field width for an
180 integer value, so we print the full value into a buffer and then select
181 the precision we need. */
182 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
185 return ret
+ (16 - 2 * num_bytes
);
191 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
192 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
197 static inline const char *
198 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
200 return dwarf_vmatoa_1 (fmtch
, value
, 0);
203 /* Print a dwarf_vma value (typically an address, offset or length) in
204 hexadecimal format, followed by a space. The length of the VALUE (and
205 hence the precision displayed) is determined by the NUM_BYTES parameter. */
208 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
210 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
213 /* Format a 64-bit value, given as two 32-bit values, in hex.
214 For reentrancy, this uses a buffer provided by the caller. */
217 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
218 unsigned int buf_len
)
223 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
226 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
227 snprintf (buf
+ len
, buf_len
- len
,
228 "%08" DWARF_VMA_FMT
"x", lvalue
);
234 /* Read in a LEB128 encoded value starting at address DATA.
235 If SIGN is true, return a signed LEB128 value.
236 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
237 No bytes will be read at address END or beyond. */
240 read_leb128 (unsigned char *data
,
241 unsigned int *length_return
,
243 const unsigned char * const end
)
245 dwarf_vma result
= 0;
246 unsigned int num_read
= 0;
247 unsigned int shift
= 0;
248 unsigned char byte
= 0;
255 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
258 if ((byte
& 0x80) == 0)
262 if (length_return
!= NULL
)
263 *length_return
= num_read
;
265 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
266 result
|= -1L << shift
;
271 /* Create a signed version to avoid painful typecasts. */
272 static inline dwarf_signed_vma
273 read_sleb128 (unsigned char * data
,
274 unsigned int * length_return
,
275 const unsigned char * const end
)
277 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
280 static inline dwarf_vma
281 read_uleb128 (unsigned char * data
,
282 unsigned int * length_return
,
283 const unsigned char * const end
)
285 return read_leb128 (data
, length_return
, FALSE
, end
);
288 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
291 int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
292 unsigned int amount = (AMOUNT); \
293 if (((PTR) + amount) >= (END)) \
296 amount = (END) - (PTR); \
301 VAL = byte_get ((PTR), amount); \
307 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
310 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
315 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
318 unsigned int amount = (AMOUNT); \
319 if (((PTR) + amount) >= (END)) \
322 amount = (END) - (PTR); \
327 VAL = byte_get_signed ((PTR), amount); \
333 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
336 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
341 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
344 if (((PTR) + 8) <= (END)) \
346 byte_get_64 ((PTR), (HIGH), (LOW)); \
350 * (LOW) = * (HIGH) = 0; \
355 typedef struct State_Machine_Registers
363 unsigned char op_index
;
364 unsigned char end_sequence
;
365 /* This variable hold the number of the last entry seen
366 in the File Table. */
367 unsigned int last_file_entry
;
370 static SMR state_machine_regs
;
373 reset_state_machine (int is_stmt
)
375 state_machine_regs
.address
= 0;
376 state_machine_regs
.op_index
= 0;
377 state_machine_regs
.file
= 1;
378 state_machine_regs
.line
= 1;
379 state_machine_regs
.column
= 0;
380 state_machine_regs
.is_stmt
= is_stmt
;
381 state_machine_regs
.basic_block
= 0;
382 state_machine_regs
.end_sequence
= 0;
383 state_machine_regs
.last_file_entry
= 0;
386 /* Handled an extend line op.
387 Returns the number of bytes read. */
390 process_extended_line_op (unsigned char * data
,
394 unsigned char op_code
;
395 unsigned int bytes_read
;
398 unsigned char *orig_data
= data
;
401 len
= read_uleb128 (data
, & bytes_read
, end
);
404 if (len
== 0 || data
== end
)
406 warn (_("badly formed extended line op encountered!\n"));
413 printf (_(" Extended opcode %d: "), op_code
);
417 case DW_LNE_end_sequence
:
418 printf (_("End of Sequence\n\n"));
419 reset_state_machine (is_stmt
);
422 case DW_LNE_set_address
:
423 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
424 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
425 state_machine_regs
.address
= adr
;
426 state_machine_regs
.op_index
= 0;
429 case DW_LNE_define_file
:
430 printf (_("define new File Table entry\n"));
431 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
432 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
435 data
+= strnlen ((char *) data
, end
- data
) + 1;
436 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
438 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
440 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
442 printf ("%s\n\n", name
);
444 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
445 warn (_("DW_LNE_define_file: Bad opcode length\n"));
448 case DW_LNE_set_discriminator
:
449 printf (_("set Discriminator to %s\n"),
450 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
454 case DW_LNE_HP_negate_is_UV_update
:
455 printf ("DW_LNE_HP_negate_is_UV_update\n");
457 case DW_LNE_HP_push_context
:
458 printf ("DW_LNE_HP_push_context\n");
460 case DW_LNE_HP_pop_context
:
461 printf ("DW_LNE_HP_pop_context\n");
463 case DW_LNE_HP_set_file_line_column
:
464 printf ("DW_LNE_HP_set_file_line_column\n");
466 case DW_LNE_HP_set_routine_name
:
467 printf ("DW_LNE_HP_set_routine_name\n");
469 case DW_LNE_HP_set_sequence
:
470 printf ("DW_LNE_HP_set_sequence\n");
472 case DW_LNE_HP_negate_post_semantics
:
473 printf ("DW_LNE_HP_negate_post_semantics\n");
475 case DW_LNE_HP_negate_function_exit
:
476 printf ("DW_LNE_HP_negate_function_exit\n");
478 case DW_LNE_HP_negate_front_end_logical
:
479 printf ("DW_LNE_HP_negate_front_end_logical\n");
481 case DW_LNE_HP_define_proc
:
482 printf ("DW_LNE_HP_define_proc\n");
484 case DW_LNE_HP_source_file_correlation
:
486 unsigned char *edata
= data
+ len
- bytes_read
- 1;
488 printf ("DW_LNE_HP_source_file_correlation\n");
494 opc
= read_uleb128 (data
, & bytes_read
, edata
);
499 case DW_LNE_HP_SFC_formfeed
:
500 printf (" DW_LNE_HP_SFC_formfeed\n");
502 case DW_LNE_HP_SFC_set_listing_line
:
503 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
505 read_uleb128 (data
, & bytes_read
, edata
)));
508 case DW_LNE_HP_SFC_associate
:
509 printf (" DW_LNE_HP_SFC_associate ");
512 read_uleb128 (data
, & bytes_read
, edata
)));
516 read_uleb128 (data
, & bytes_read
, edata
)));
520 read_uleb128 (data
, & bytes_read
, edata
)));
524 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
534 unsigned int rlen
= len
- bytes_read
- 1;
536 if (op_code
>= DW_LNE_lo_user
537 /* The test against DW_LNW_hi_user is redundant due to
538 the limited range of the unsigned char data type used
540 /*&& op_code <= DW_LNE_hi_user*/)
541 printf (_("user defined: "));
543 printf (_("UNKNOWN: "));
544 printf (_("length %d ["), rlen
);
546 printf (" %02x", *data
++);
555 static const unsigned char *
556 fetch_indirect_string (dwarf_vma offset
)
558 struct dwarf_section
*section
= &debug_displays
[str
].section
;
560 if (section
->start
== NULL
)
561 return (const unsigned char *) _("<no .debug_str section>");
563 /* DWARF sections under Mach-O have non-zero addresses. */
564 offset
-= section
->address
;
565 if (offset
> section
->size
)
567 warn (_("DW_FORM_strp offset too big: %s\n"),
568 dwarf_vmatoa ("x", offset
));
569 return (const unsigned char *) _("<offset is too big>");
572 return (const unsigned char *) section
->start
+ offset
;
576 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
577 dwarf_vma offset_size
, int dwo
)
579 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
580 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
581 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
582 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
583 dwarf_vma index_offset
= idx
* offset_size
;
584 dwarf_vma str_offset
;
586 if (index_section
->start
== NULL
)
587 return (dwo
? _("<no .debug_str_offsets.dwo section>")
588 : _("<no .debug_str_offsets section>"));
590 /* DWARF sections under Mach-O have non-zero addresses. */
591 index_offset
-= index_section
->address
;
592 if (this_set
!= NULL
)
593 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
594 if (index_offset
> index_section
->size
)
596 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
597 dwarf_vmatoa ("x", index_offset
));
598 return _("<index offset is too big>");
601 if (str_section
->start
== NULL
)
602 return (dwo
? _("<no .debug_str.dwo section>")
603 : _("<no .debug_str section>"));
605 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
606 str_offset
-= str_section
->address
;
607 if (str_offset
> str_section
->size
)
609 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
610 dwarf_vmatoa ("x", str_offset
));
611 return _("<indirect index offset is too big>");
614 return (const char *) str_section
->start
+ str_offset
;
618 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
620 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
622 if (section
->start
== NULL
)
623 return (_("<no .debug_addr section>"));
625 if (offset
+ bytes
> section
->size
)
627 warn (_("Offset into section %s too big: %s\n"),
628 section
->name
, dwarf_vmatoa ("x", offset
));
629 return "<offset too big>";
632 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
636 /* FIXME: There are better and more efficient ways to handle
637 these structures. For now though, I just want something that
638 is simple to implement. */
639 typedef struct abbrev_attr
641 unsigned long attribute
;
643 struct abbrev_attr
*next
;
647 typedef struct abbrev_entry
652 struct abbrev_attr
*first_attr
;
653 struct abbrev_attr
*last_attr
;
654 struct abbrev_entry
*next
;
658 static abbrev_entry
*first_abbrev
= NULL
;
659 static abbrev_entry
*last_abbrev
= NULL
;
666 for (abbrv
= first_abbrev
; abbrv
;)
668 abbrev_entry
*next_abbrev
= abbrv
->next
;
671 for (attr
= abbrv
->first_attr
; attr
;)
673 abbrev_attr
*next_attr
= attr
->next
;
683 last_abbrev
= first_abbrev
= NULL
;
687 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
691 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
696 entry
->entry
= number
;
698 entry
->children
= children
;
699 entry
->first_attr
= NULL
;
700 entry
->last_attr
= NULL
;
703 if (first_abbrev
== NULL
)
704 first_abbrev
= entry
;
706 last_abbrev
->next
= entry
;
712 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
716 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
721 attr
->attribute
= attribute
;
725 if (last_abbrev
->first_attr
== NULL
)
726 last_abbrev
->first_attr
= attr
;
728 last_abbrev
->last_attr
->next
= attr
;
730 last_abbrev
->last_attr
= attr
;
733 /* Processes the (partial) contents of a .debug_abbrev section.
734 Returns NULL if the end of the section was encountered.
735 Returns the address after the last byte read if the end of
736 an abbreviation set was found. */
738 static unsigned char *
739 process_abbrev_section (unsigned char *start
, unsigned char *end
)
741 if (first_abbrev
!= NULL
)
746 unsigned int bytes_read
;
749 unsigned long attribute
;
752 entry
= read_uleb128 (start
, & bytes_read
, end
);
755 /* A single zero is supposed to end the section according
756 to the standard. If there's more, then signal that to
763 tag
= read_uleb128 (start
, & bytes_read
, end
);
770 add_abbrev (entry
, tag
, children
);
776 attribute
= read_uleb128 (start
, & bytes_read
, end
);
781 form
= read_uleb128 (start
, & bytes_read
, end
);
786 add_abbrev_attr (attribute
, form
);
788 while (attribute
!= 0);
791 /* Report the missing single zero which ends the section. */
792 error (_(".debug_abbrev section not zero terminated\n"));
798 get_TAG_name (unsigned long tag
)
800 const char *name
= get_DW_TAG_name ((unsigned int)tag
);
804 static char buffer
[100];
806 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
814 get_FORM_name (unsigned long form
)
819 return "DW_FORM value: 0";
821 name
= get_DW_FORM_name (form
);
824 static char buffer
[100];
826 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
833 static unsigned char *
834 display_block (unsigned char *data
,
836 const unsigned char * const end
)
840 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length
));
842 maxlen
= (dwarf_vma
) (end
- data
);
843 length
= length
> maxlen
? maxlen
: length
;
846 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
852 decode_location_expression (unsigned char * data
,
853 unsigned int pointer_size
,
854 unsigned int offset_size
,
858 struct dwarf_section
* section
)
861 unsigned int bytes_read
;
863 dwarf_signed_vma svalue
;
864 unsigned char *end
= data
+ length
;
865 int need_frame_base
= 0;
874 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
875 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
878 printf ("DW_OP_deref");
881 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
882 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
885 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
886 printf ("DW_OP_const1s: %ld", (long) svalue
);
889 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
890 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
893 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
894 printf ("DW_OP_const2s: %ld", (long) svalue
);
897 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
898 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
901 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
902 printf ("DW_OP_const4s: %ld", (long) svalue
);
905 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
906 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
907 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
908 printf ("%lu", (unsigned long) uvalue
);
911 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
912 printf ("DW_OP_const8s: %ld ", (long) svalue
);
913 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
914 printf ("%ld", (long) svalue
);
917 printf ("DW_OP_constu: %s",
918 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
922 printf ("DW_OP_consts: %s",
923 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
927 printf ("DW_OP_dup");
930 printf ("DW_OP_drop");
933 printf ("DW_OP_over");
936 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
937 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
940 printf ("DW_OP_swap");
943 printf ("DW_OP_rot");
946 printf ("DW_OP_xderef");
949 printf ("DW_OP_abs");
952 printf ("DW_OP_and");
955 printf ("DW_OP_div");
958 printf ("DW_OP_minus");
961 printf ("DW_OP_mod");
964 printf ("DW_OP_mul");
967 printf ("DW_OP_neg");
970 printf ("DW_OP_not");
976 printf ("DW_OP_plus");
978 case DW_OP_plus_uconst
:
979 printf ("DW_OP_plus_uconst: %s",
980 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
984 printf ("DW_OP_shl");
987 printf ("DW_OP_shr");
990 printf ("DW_OP_shra");
993 printf ("DW_OP_xor");
996 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
997 printf ("DW_OP_bra: %ld", (long) svalue
);
1000 printf ("DW_OP_eq");
1003 printf ("DW_OP_ge");
1006 printf ("DW_OP_gt");
1009 printf ("DW_OP_le");
1012 printf ("DW_OP_lt");
1015 printf ("DW_OP_ne");
1018 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1019 printf ("DW_OP_skip: %ld", (long) svalue
);
1054 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1089 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1090 regname (op
- DW_OP_reg0
, 1));
1125 printf ("DW_OP_breg%d (%s): %s",
1127 regname (op
- DW_OP_breg0
, 1),
1128 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1133 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1135 printf ("DW_OP_regx: %s (%s)",
1136 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1139 need_frame_base
= 1;
1140 printf ("DW_OP_fbreg: %s",
1141 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1145 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1147 printf ("DW_OP_bregx: %s (%s) %s",
1148 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1149 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1153 printf ("DW_OP_piece: %s",
1154 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1157 case DW_OP_deref_size
:
1158 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1159 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1161 case DW_OP_xderef_size
:
1162 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1163 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1166 printf ("DW_OP_nop");
1169 /* DWARF 3 extensions. */
1170 case DW_OP_push_object_address
:
1171 printf ("DW_OP_push_object_address");
1174 /* XXX: Strictly speaking for 64-bit DWARF3 files
1175 this ought to be an 8-byte wide computation. */
1176 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1177 printf ("DW_OP_call2: <0x%s>",
1178 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1181 /* XXX: Strictly speaking for 64-bit DWARF3 files
1182 this ought to be an 8-byte wide computation. */
1183 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1184 printf ("DW_OP_call4: <0x%s>",
1185 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1187 case DW_OP_call_ref
:
1188 /* XXX: Strictly speaking for 64-bit DWARF3 files
1189 this ought to be an 8-byte wide computation. */
1190 if (dwarf_version
== -1)
1192 printf (_("(DW_OP_call_ref in frame info)"));
1193 /* No way to tell where the next op is, so just bail. */
1194 return need_frame_base
;
1196 if (dwarf_version
== 2)
1198 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1202 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1204 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1206 case DW_OP_form_tls_address
:
1207 printf ("DW_OP_form_tls_address");
1209 case DW_OP_call_frame_cfa
:
1210 printf ("DW_OP_call_frame_cfa");
1212 case DW_OP_bit_piece
:
1213 printf ("DW_OP_bit_piece: ");
1214 printf (_("size: %s "),
1215 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1217 printf (_("offset: %s "),
1218 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1222 /* DWARF 4 extensions. */
1223 case DW_OP_stack_value
:
1224 printf ("DW_OP_stack_value");
1227 case DW_OP_implicit_value
:
1228 printf ("DW_OP_implicit_value");
1229 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1231 display_block (data
, uvalue
, end
);
1235 /* GNU extensions. */
1236 case DW_OP_GNU_push_tls_address
:
1237 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1239 case DW_OP_GNU_uninit
:
1240 printf ("DW_OP_GNU_uninit");
1241 /* FIXME: Is there data associated with this OP ? */
1243 case DW_OP_GNU_encoded_addr
:
1249 addr
= get_encoded_value (data
, encoding
, section
);
1250 data
+= size_of_encoded_value (encoding
);
1252 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1253 print_dwarf_vma (addr
, pointer_size
);
1256 case DW_OP_GNU_implicit_pointer
:
1257 /* XXX: Strictly speaking for 64-bit DWARF3 files
1258 this ought to be an 8-byte wide computation. */
1259 if (dwarf_version
== -1)
1261 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1262 /* No way to tell where the next op is, so just bail. */
1263 return need_frame_base
;
1265 if (dwarf_version
== 2)
1267 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1271 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1273 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1274 dwarf_vmatoa ("x", uvalue
),
1275 dwarf_vmatoa ("d", read_sleb128 (data
,
1276 &bytes_read
, end
)));
1279 case DW_OP_GNU_entry_value
:
1280 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1282 printf ("DW_OP_GNU_entry_value: (");
1283 if (decode_location_expression (data
, pointer_size
, offset_size
,
1284 dwarf_version
, uvalue
,
1285 cu_offset
, section
))
1286 need_frame_base
= 1;
1290 case DW_OP_GNU_const_type
:
1291 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1293 printf ("DW_OP_GNU_const_type: <0x%s> ",
1294 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1295 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1296 display_block (data
, uvalue
, end
);
1299 case DW_OP_GNU_regval_type
:
1300 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1302 printf ("DW_OP_GNU_regval_type: %s (%s)",
1303 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1304 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1306 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1308 case DW_OP_GNU_deref_type
:
1309 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1310 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue
);
1311 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1313 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1315 case DW_OP_GNU_convert
:
1316 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1318 printf ("DW_OP_GNU_convert <0x%s>",
1319 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1321 case DW_OP_GNU_reinterpret
:
1322 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1324 printf ("DW_OP_GNU_reinterpret <0x%s>",
1325 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1327 case DW_OP_GNU_parameter_ref
:
1328 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1329 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1330 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1332 case DW_OP_GNU_addr_index
:
1333 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1335 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1337 case DW_OP_GNU_const_index
:
1338 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1340 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1343 /* HP extensions. */
1344 case DW_OP_HP_is_value
:
1345 printf ("DW_OP_HP_is_value");
1346 /* FIXME: Is there data associated with this OP ? */
1348 case DW_OP_HP_fltconst4
:
1349 printf ("DW_OP_HP_fltconst4");
1350 /* FIXME: Is there data associated with this OP ? */
1352 case DW_OP_HP_fltconst8
:
1353 printf ("DW_OP_HP_fltconst8");
1354 /* FIXME: Is there data associated with this OP ? */
1356 case DW_OP_HP_mod_range
:
1357 printf ("DW_OP_HP_mod_range");
1358 /* FIXME: Is there data associated with this OP ? */
1360 case DW_OP_HP_unmod_range
:
1361 printf ("DW_OP_HP_unmod_range");
1362 /* FIXME: Is there data associated with this OP ? */
1365 printf ("DW_OP_HP_tls");
1366 /* FIXME: Is there data associated with this OP ? */
1369 /* PGI (STMicroelectronics) extensions. */
1370 case DW_OP_PGI_omp_thread_num
:
1371 /* Pushes the thread number for the current thread as it would be
1372 returned by the standard OpenMP library function:
1373 omp_get_thread_num(). The "current thread" is the thread for
1374 which the expression is being evaluated. */
1375 printf ("DW_OP_PGI_omp_thread_num");
1379 if (op
>= DW_OP_lo_user
1380 && op
<= DW_OP_hi_user
)
1381 printf (_("(User defined location op)"));
1383 printf (_("(Unknown location op)"));
1384 /* No way to tell where the next op is, so just bail. */
1385 return need_frame_base
;
1388 /* Separate the ops. */
1393 return need_frame_base
;
1396 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1397 This is used for DWARF package files. */
1399 static struct cu_tu_set
*
1400 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1402 struct cu_tu_set
*p
;
1404 unsigned int dw_sect
;
1410 dw_sect
= DW_SECT_TYPES
;
1416 dw_sect
= DW_SECT_INFO
;
1420 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1428 /* Add INC to HIGH_BITS:LOW_BITS. */
1430 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1432 dwarf_vma tmp
= * low_bits
;
1436 /* FIXME: There is probably a better way of handling this:
1438 We need to cope with dwarf_vma being a 32-bit or 64-bit
1439 type. Plus regardless of its size LOW_BITS is meant to
1440 only hold 32-bits, so if there is overflow or wrap around
1441 we must propagate into HIGH_BITS. */
1442 if (tmp
< * low_bits
)
1446 else if (sizeof (tmp
) > 8
1456 static unsigned char *
1457 read_and_display_attr_value (unsigned long attribute
,
1459 unsigned char * data
,
1460 unsigned char * end
,
1461 dwarf_vma cu_offset
,
1462 dwarf_vma pointer_size
,
1463 dwarf_vma offset_size
,
1465 debug_info
* debug_info_p
,
1467 struct dwarf_section
* section
,
1468 struct cu_tu_set
* this_set
)
1470 dwarf_vma uvalue
= 0;
1471 unsigned char *block_start
= NULL
;
1472 unsigned char * orig_data
= data
;
1473 unsigned int bytes_read
;
1477 warn (_("corrupt attribute\n"));
1486 case DW_FORM_ref_addr
:
1487 if (dwarf_version
== 2)
1488 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1489 else if (dwarf_version
== 3 || dwarf_version
== 4)
1490 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1492 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1497 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1501 case DW_FORM_sec_offset
:
1502 case DW_FORM_GNU_ref_alt
:
1503 case DW_FORM_GNU_strp_alt
:
1504 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1507 case DW_FORM_flag_present
:
1514 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1519 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1524 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1528 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1532 case DW_FORM_GNU_str_index
:
1533 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1537 case DW_FORM_ref_udata
:
1539 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1543 case DW_FORM_indirect
:
1544 form
= read_uleb128 (data
, & bytes_read
, end
);
1547 printf (" %s", get_FORM_name (form
));
1548 return read_and_display_attr_value (attribute
, form
, data
, end
,
1549 cu_offset
, pointer_size
,
1550 offset_size
, dwarf_version
,
1551 debug_info_p
, do_loc
,
1553 case DW_FORM_GNU_addr_index
:
1554 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1561 case DW_FORM_ref_addr
:
1563 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue
));
1566 case DW_FORM_GNU_ref_alt
:
1568 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue
));
1574 case DW_FORM_ref_udata
:
1576 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1581 case DW_FORM_sec_offset
:
1583 printf (" 0x%s", dwarf_vmatoa ("x", uvalue
));
1586 case DW_FORM_flag_present
:
1593 printf (" %s", dwarf_vmatoa ("d", uvalue
));
1599 dwarf_vma high_bits
;
1603 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1605 if (form
== DW_FORM_ref8
)
1606 add64 (& high_bits
, & utmp
, cu_offset
);
1608 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1611 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1612 && num_debug_info_entries
== 0)
1614 if (sizeof (uvalue
) == 8)
1615 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1617 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1623 case DW_FORM_string
:
1625 printf (" %.*s", (int) (end
- data
), data
);
1626 data
+= strnlen ((char *) data
, end
- data
) + 1;
1630 case DW_FORM_exprloc
:
1631 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1632 block_start
= data
+ bytes_read
;
1634 data
= block_start
+ uvalue
;
1636 data
= display_block (block_start
, uvalue
, end
);
1639 case DW_FORM_block1
:
1640 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1641 block_start
= data
+ 1;
1643 data
= block_start
+ uvalue
;
1645 data
= display_block (block_start
, uvalue
, end
);
1648 case DW_FORM_block2
:
1649 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1650 block_start
= data
+ 2;
1652 data
= block_start
+ uvalue
;
1654 data
= display_block (block_start
, uvalue
, end
);
1657 case DW_FORM_block4
:
1658 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1659 block_start
= data
+ 4;
1661 data
= block_start
+ uvalue
;
1663 data
= display_block (block_start
, uvalue
, end
);
1668 printf (_(" (indirect string, offset: 0x%s): %s"),
1669 dwarf_vmatoa ("x", uvalue
),
1670 fetch_indirect_string (uvalue
));
1673 case DW_FORM_GNU_str_index
:
1676 const char *suffix
= strrchr (section
->name
, '.');
1677 int dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? 1 : 0;
1679 printf (_(" (indexed string: 0x%s): %s"),
1680 dwarf_vmatoa ("x", uvalue
),
1681 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
1685 case DW_FORM_GNU_strp_alt
:
1687 printf (_(" (alt indirect string, offset: 0x%s)"),
1688 dwarf_vmatoa ("x", uvalue
));
1691 case DW_FORM_indirect
:
1692 /* Handled above. */
1695 case DW_FORM_ref_sig8
:
1698 dwarf_vma high_bits
;
1701 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1702 printf (" signature: 0x%s",
1703 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
1708 case DW_FORM_GNU_addr_index
:
1710 printf (_(" (addr_index: 0x%s): %s"),
1711 dwarf_vmatoa ("x", uvalue
),
1712 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
1716 warn (_("Unrecognized form: %lu\n"), form
);
1720 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1721 && num_debug_info_entries
== 0
1722 && debug_info_p
!= NULL
)
1726 case DW_AT_frame_base
:
1727 have_frame_base
= 1;
1728 case DW_AT_location
:
1729 case DW_AT_string_length
:
1730 case DW_AT_return_addr
:
1731 case DW_AT_data_member_location
:
1732 case DW_AT_vtable_elem_location
:
1734 case DW_AT_static_link
:
1735 case DW_AT_use_location
:
1736 case DW_AT_GNU_call_site_value
:
1737 case DW_AT_GNU_call_site_data_value
:
1738 case DW_AT_GNU_call_site_target
:
1739 case DW_AT_GNU_call_site_target_clobbered
:
1740 if ((dwarf_version
< 4
1741 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1742 || form
== DW_FORM_sec_offset
)
1744 /* Process location list. */
1745 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1746 unsigned int num
= debug_info_p
->num_loc_offsets
;
1748 if (lmax
== 0 || num
>= lmax
)
1751 debug_info_p
->loc_offsets
= (dwarf_vma
*)
1752 xcrealloc (debug_info_p
->loc_offsets
,
1753 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1754 debug_info_p
->have_frame_base
= (int *)
1755 xcrealloc (debug_info_p
->have_frame_base
,
1756 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1757 debug_info_p
->max_loc_offsets
= lmax
;
1759 if (this_set
!= NULL
)
1760 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
1761 debug_info_p
->loc_offsets
[num
] = uvalue
;
1762 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1763 debug_info_p
->num_loc_offsets
++;
1768 if (need_base_address
)
1769 debug_info_p
->base_address
= uvalue
;
1772 case DW_AT_GNU_addr_base
:
1773 debug_info_p
->addr_base
= uvalue
;
1776 case DW_AT_GNU_ranges_base
:
1777 debug_info_p
->ranges_base
= uvalue
;
1781 if ((dwarf_version
< 4
1782 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1783 || form
== DW_FORM_sec_offset
)
1785 /* Process range list. */
1786 unsigned int lmax
= debug_info_p
->max_range_lists
;
1787 unsigned int num
= debug_info_p
->num_range_lists
;
1789 if (lmax
== 0 || num
>= lmax
)
1792 debug_info_p
->range_lists
= (dwarf_vma
*)
1793 xcrealloc (debug_info_p
->range_lists
,
1794 lmax
, sizeof (*debug_info_p
->range_lists
));
1795 debug_info_p
->max_range_lists
= lmax
;
1797 debug_info_p
->range_lists
[num
] = uvalue
;
1798 debug_info_p
->num_range_lists
++;
1807 if (do_loc
|| attribute
== 0)
1810 /* For some attributes we can display further information. */
1818 case DW_INL_not_inlined
:
1819 printf (_("(not inlined)"));
1821 case DW_INL_inlined
:
1822 printf (_("(inlined)"));
1824 case DW_INL_declared_not_inlined
:
1825 printf (_("(declared as inline but ignored)"));
1827 case DW_INL_declared_inlined
:
1828 printf (_("(declared as inline and inlined)"));
1831 printf (_(" (Unknown inline attribute value: %s)"),
1832 dwarf_vmatoa ("x", uvalue
));
1837 case DW_AT_language
:
1840 /* Ordered by the numeric value of these constants. */
1841 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1842 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1843 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1844 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1845 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1846 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1847 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1848 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1849 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1850 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1851 /* DWARF 2.1 values. */
1852 case DW_LANG_Java
: printf ("(Java)"); break;
1853 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1854 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1855 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1856 /* DWARF 3 values. */
1857 case DW_LANG_PLI
: printf ("(PLI)"); break;
1858 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1859 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1860 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1861 case DW_LANG_D
: printf ("(D)"); break;
1862 /* DWARF 4 values. */
1863 case DW_LANG_Python
: printf ("(Python)"); break;
1864 /* DWARF 5 values. */
1865 case DW_LANG_Go
: printf ("(Go)"); break;
1866 /* MIPS extension. */
1867 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1868 /* UPC extension. */
1869 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1871 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1872 printf (_("(implementation defined: %s)"),
1873 dwarf_vmatoa ("x", uvalue
));
1875 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
1880 case DW_AT_encoding
:
1883 case DW_ATE_void
: printf ("(void)"); break;
1884 case DW_ATE_address
: printf ("(machine address)"); break;
1885 case DW_ATE_boolean
: printf ("(boolean)"); break;
1886 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1887 case DW_ATE_float
: printf ("(float)"); break;
1888 case DW_ATE_signed
: printf ("(signed)"); break;
1889 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1890 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1891 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1892 /* DWARF 2.1 values: */
1893 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1894 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1895 /* DWARF 3 values: */
1896 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1897 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1898 case DW_ATE_edited
: printf ("(edited)"); break;
1899 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1900 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1901 /* HP extensions: */
1902 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1903 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1904 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1905 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1906 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1907 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1908 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1911 if (uvalue
>= DW_ATE_lo_user
1912 && uvalue
<= DW_ATE_hi_user
)
1913 printf (_("(user defined type)"));
1915 printf (_("(unknown type)"));
1920 case DW_AT_accessibility
:
1923 case DW_ACCESS_public
: printf ("(public)"); break;
1924 case DW_ACCESS_protected
: printf ("(protected)"); break;
1925 case DW_ACCESS_private
: printf ("(private)"); break;
1927 printf (_("(unknown accessibility)"));
1932 case DW_AT_visibility
:
1935 case DW_VIS_local
: printf ("(local)"); break;
1936 case DW_VIS_exported
: printf ("(exported)"); break;
1937 case DW_VIS_qualified
: printf ("(qualified)"); break;
1938 default: printf (_("(unknown visibility)")); break;
1942 case DW_AT_virtuality
:
1945 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1946 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1947 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1948 default: printf (_("(unknown virtuality)")); break;
1952 case DW_AT_identifier_case
:
1955 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1956 case DW_ID_up_case
: printf ("(up_case)"); break;
1957 case DW_ID_down_case
: printf ("(down_case)"); break;
1958 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1959 default: printf (_("(unknown case)")); break;
1963 case DW_AT_calling_convention
:
1966 case DW_CC_normal
: printf ("(normal)"); break;
1967 case DW_CC_program
: printf ("(program)"); break;
1968 case DW_CC_nocall
: printf ("(nocall)"); break;
1970 if (uvalue
>= DW_CC_lo_user
1971 && uvalue
<= DW_CC_hi_user
)
1972 printf (_("(user defined)"));
1974 printf (_("(unknown convention)"));
1978 case DW_AT_ordering
:
1981 case -1: printf (_("(undefined)")); break;
1982 case 0: printf ("(row major)"); break;
1983 case 1: printf ("(column major)"); break;
1987 case DW_AT_frame_base
:
1988 have_frame_base
= 1;
1989 case DW_AT_location
:
1990 case DW_AT_string_length
:
1991 case DW_AT_return_addr
:
1992 case DW_AT_data_member_location
:
1993 case DW_AT_vtable_elem_location
:
1995 case DW_AT_static_link
:
1996 case DW_AT_use_location
:
1997 case DW_AT_GNU_call_site_value
:
1998 case DW_AT_GNU_call_site_data_value
:
1999 case DW_AT_GNU_call_site_target
:
2000 case DW_AT_GNU_call_site_target_clobbered
:
2001 if ((dwarf_version
< 4
2002 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2003 || form
== DW_FORM_sec_offset
)
2004 printf (_("(location list)"));
2006 case DW_AT_allocated
:
2007 case DW_AT_associated
:
2008 case DW_AT_data_location
:
2010 case DW_AT_upper_bound
:
2011 case DW_AT_lower_bound
:
2014 int need_frame_base
;
2017 need_frame_base
= decode_location_expression (block_start
,
2022 cu_offset
, section
);
2024 if (need_frame_base
&& !have_frame_base
)
2025 printf (_(" [without DW_AT_frame_base]"));
2031 if (form
== DW_FORM_ref_sig8
2032 || form
== DW_FORM_GNU_ref_alt
)
2035 if (form
== DW_FORM_ref1
2036 || form
== DW_FORM_ref2
2037 || form
== DW_FORM_ref4
2038 || form
== DW_FORM_ref_udata
)
2039 uvalue
+= cu_offset
;
2041 if (uvalue
>= section
->size
)
2042 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2043 dwarf_vmatoa ("x", uvalue
),
2044 (unsigned long) (orig_data
- section
->start
));
2047 unsigned long abbrev_number
;
2048 abbrev_entry
* entry
;
2050 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2052 printf (_("[Abbrev Number: %ld"), abbrev_number
);
2053 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2054 use different abbrev table, and we don't track .debug_info chunks
2056 if (form
!= DW_FORM_ref_addr
)
2058 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2059 if (entry
->entry
== abbrev_number
)
2062 printf (" (%s)", get_TAG_name (entry
->tag
));
2077 get_AT_name (unsigned long attribute
)
2082 return "DW_AT value: 0";
2084 /* One value is shared by the MIPS and HP extensions: */
2085 if (attribute
== DW_AT_MIPS_fde
)
2086 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2088 name
= get_DW_AT_name (attribute
);
2092 static char buffer
[100];
2094 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2102 static unsigned char *
2103 read_and_display_attr (unsigned long attribute
,
2105 unsigned char * data
,
2106 unsigned char * end
,
2107 dwarf_vma cu_offset
,
2108 dwarf_vma pointer_size
,
2109 dwarf_vma offset_size
,
2111 debug_info
* debug_info_p
,
2113 struct dwarf_section
* section
,
2114 struct cu_tu_set
* this_set
)
2117 printf (" %-18s:", get_AT_name (attribute
));
2118 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2119 cu_offset
, pointer_size
, offset_size
,
2120 dwarf_version
, debug_info_p
,
2121 do_loc
, section
, this_set
);
2127 /* Process the contents of a .debug_info section. If do_loc is non-zero
2128 then we are scanning for location lists and we do not want to display
2129 anything to the user. If do_types is non-zero, we are processing
2130 a .debug_types section instead of a .debug_info section. */
2133 process_debug_info (struct dwarf_section
*section
,
2135 enum dwarf_section_display_enum abbrev_sec
,
2139 unsigned char *start
= section
->start
;
2140 unsigned char *end
= start
+ section
->size
;
2141 unsigned char *section_begin
;
2143 unsigned int num_units
= 0;
2145 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2146 && num_debug_info_entries
== 0
2151 /* First scan the section to get the number of comp units. */
2152 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2155 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2156 will be the length. For a 64-bit DWARF section, it'll be
2157 the escape code 0xffffffff followed by an 8 byte length. */
2158 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2160 if (length
== 0xffffffff)
2162 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2163 section_begin
+= length
+ 12;
2165 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2167 warn (_("Reserved length value (0x%s) found in section %s\n"),
2168 dwarf_vmatoa ("x", length
), section
->name
);
2172 section_begin
+= length
+ 4;
2174 /* Negative values are illegal, they may even cause infinite
2175 looping. This can happen if we can't accurately apply
2176 relocations to an object file. */
2177 if ((signed long) length
<= 0)
2179 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2180 dwarf_vmatoa ("x", length
), section
->name
);
2187 error (_("No comp units in %s section ?"), section
->name
);
2191 /* Then allocate an array to hold the information. */
2192 debug_information
= (debug_info
*) cmalloc (num_units
,
2193 sizeof (* debug_information
));
2194 if (debug_information
== NULL
)
2196 error (_("Not enough memory for a debug info array of %u entries"),
2204 if (dwarf_start_die
== 0)
2205 printf (_("Contents of the %s section:\n\n"), section
->name
);
2207 load_debug_section (str
, file
);
2208 load_debug_section (str_dwo
, file
);
2209 load_debug_section (str_index
, file
);
2210 load_debug_section (str_index_dwo
, file
);
2211 load_debug_section (debug_addr
, file
);
2214 load_debug_section (abbrev_sec
, file
);
2215 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2217 warn (_("Unable to locate %s section!\n"),
2218 debug_displays
[abbrev_sec
].section
.name
);
2222 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2224 DWARF2_Internal_CompUnit compunit
;
2225 unsigned char *hdrptr
;
2226 unsigned char *tags
;
2227 int level
, last_level
, saved_level
;
2228 dwarf_vma cu_offset
;
2229 unsigned int offset_size
;
2230 int initial_length_size
;
2231 dwarf_vma signature_high
= 0;
2232 dwarf_vma signature_low
= 0;
2233 dwarf_vma type_offset
= 0;
2234 struct cu_tu_set
*this_set
;
2235 dwarf_vma abbrev_base
;
2240 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2242 if (compunit
.cu_length
== 0xffffffff)
2244 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2246 initial_length_size
= 12;
2251 initial_length_size
= 4;
2254 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2256 cu_offset
= start
- section_begin
;
2258 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2260 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2262 if (this_set
== NULL
)
2265 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2269 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2270 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2273 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2277 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2279 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2282 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2283 && num_debug_info_entries
== 0
2286 debug_information
[unit
].cu_offset
= cu_offset
;
2287 debug_information
[unit
].pointer_size
2288 = compunit
.cu_pointer_size
;
2289 debug_information
[unit
].offset_size
= offset_size
;
2290 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2291 debug_information
[unit
].base_address
= 0;
2292 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2293 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2294 debug_information
[unit
].loc_offsets
= NULL
;
2295 debug_information
[unit
].have_frame_base
= NULL
;
2296 debug_information
[unit
].max_loc_offsets
= 0;
2297 debug_information
[unit
].num_loc_offsets
= 0;
2298 debug_information
[unit
].range_lists
= NULL
;
2299 debug_information
[unit
].max_range_lists
= 0;
2300 debug_information
[unit
].num_range_lists
= 0;
2303 if (!do_loc
&& dwarf_start_die
== 0)
2305 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2306 dwarf_vmatoa ("x", cu_offset
));
2307 printf (_(" Length: 0x%s (%s)\n"),
2308 dwarf_vmatoa ("x", compunit
.cu_length
),
2309 offset_size
== 8 ? "64-bit" : "32-bit");
2310 printf (_(" Version: %d\n"), compunit
.cu_version
);
2311 printf (_(" Abbrev Offset: 0x%s\n"),
2312 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2313 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2318 printf (_(" Signature: 0x%s\n"),
2319 dwarf_vmatoa64 (signature_high
, signature_low
,
2320 buf
, sizeof (buf
)));
2321 printf (_(" Type Offset: 0x%s\n"),
2322 dwarf_vmatoa ("x", type_offset
));
2324 if (this_set
!= NULL
)
2326 dwarf_vma
*offsets
= this_set
->section_offsets
;
2327 size_t *sizes
= this_set
->section_sizes
;
2329 printf (_(" Section contributions:\n"));
2330 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2331 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2332 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2333 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2334 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2335 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2336 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2337 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2338 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2339 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2340 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2341 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2345 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2348 warn (_("Debug info is corrupted, length of CU at %s"
2349 " extends beyond end of section (length = %s)\n"),
2350 dwarf_vmatoa ("x", cu_offset
),
2351 dwarf_vmatoa ("x", compunit
.cu_length
));
2355 start
+= compunit
.cu_length
+ initial_length_size
;
2357 if (compunit
.cu_version
!= 2
2358 && compunit
.cu_version
!= 3
2359 && compunit
.cu_version
!= 4)
2361 warn (_("CU at offset %s contains corrupt or "
2362 "unsupported version number: %d.\n"),
2363 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2369 /* Process the abbrevs used by this compilation unit. DWARF
2370 sections under Mach-O have non-zero addresses. */
2371 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2372 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2373 (unsigned long) compunit
.cu_abbrev_offset
,
2374 (unsigned long) abbrev_size
);
2376 process_abbrev_section
2377 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2378 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2379 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2380 + abbrev_base
+ abbrev_size
));
2385 while (tags
< start
)
2387 unsigned int bytes_read
;
2388 unsigned long abbrev_number
;
2389 unsigned long die_offset
;
2390 abbrev_entry
*entry
;
2392 int do_printing
= 1;
2394 die_offset
= tags
- section_begin
;
2396 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2399 /* A null DIE marks the end of a list of siblings or it may also be
2400 a section padding. */
2401 if (abbrev_number
== 0)
2403 /* Check if it can be a section padding for the last CU. */
2404 if (level
== 0 && start
== end
)
2408 for (chk
= tags
; chk
< start
; chk
++)
2415 if (!do_loc
&& die_offset
>= dwarf_start_die
2416 && (dwarf_cutoff_level
== -1
2417 || level
< dwarf_cutoff_level
))
2418 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2424 static unsigned num_bogus_warns
= 0;
2426 if (num_bogus_warns
< 3)
2428 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2429 die_offset
, section
->name
);
2431 if (num_bogus_warns
== 3)
2432 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2435 if (dwarf_start_die
!= 0 && level
< saved_level
)
2442 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2446 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2447 saved_level
= level
;
2448 do_printing
= (dwarf_cutoff_level
== -1
2449 || level
< dwarf_cutoff_level
);
2451 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2452 level
, die_offset
, abbrev_number
);
2453 else if (dwarf_cutoff_level
== -1
2454 || last_level
< dwarf_cutoff_level
)
2455 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2460 /* Scan through the abbreviation list until we reach the
2462 for (entry
= first_abbrev
;
2463 entry
&& entry
->entry
!= abbrev_number
;
2464 entry
= entry
->next
)
2469 if (!do_loc
&& do_printing
)
2474 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2475 die_offset
, abbrev_number
);
2479 if (!do_loc
&& do_printing
)
2480 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2485 need_base_address
= 0;
2487 case DW_TAG_compile_unit
:
2488 need_base_address
= 1;
2490 case DW_TAG_entry_point
:
2491 case DW_TAG_subprogram
:
2492 need_base_address
= 0;
2493 /* Assuming that there is no DW_AT_frame_base. */
2494 have_frame_base
= 0;
2498 for (attr
= entry
->first_attr
;
2499 attr
&& attr
->attribute
;
2504 if (! do_loc
&& do_printing
)
2505 /* Show the offset from where the tag was extracted. */
2506 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2508 arg
= debug_information
;
2509 if (debug_information
)
2512 tags
= read_and_display_attr (attr
->attribute
,
2517 compunit
.cu_pointer_size
,
2519 compunit
.cu_version
,
2521 do_loc
|| ! do_printing
,
2526 if (entry
->children
)
2531 /* Set num_debug_info_entries here so that it can be used to check if
2532 we need to process .debug_loc and .debug_ranges sections. */
2533 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2534 && num_debug_info_entries
== 0
2536 num_debug_info_entries
= num_units
;
2544 /* Locate and scan the .debug_info section in the file and record the pointer
2545 sizes and offsets for the compilation units in it. Usually an executable
2546 will have just one pointer size, but this is not guaranteed, and so we try
2547 not to make any assumptions. Returns zero upon failure, or the number of
2548 compilation units upon success. */
2551 load_debug_info (void * file
)
2553 /* Reset the last pointer size so that we can issue correct error
2554 messages if we are displaying the contents of more than one section. */
2555 last_pointer_size
= 0;
2556 warned_about_missing_comp_units
= FALSE
;
2558 /* If we have already tried and failed to load the .debug_info
2559 section then do not bother to repeat the task. */
2560 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2563 /* If we already have the information there is nothing else to do. */
2564 if (num_debug_info_entries
> 0)
2565 return num_debug_info_entries
;
2567 /* If this is a DWARF package file, load the CU and TU indexes. */
2568 load_cu_tu_indexes (file
);
2570 if (load_debug_section (info
, file
)
2571 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2572 return num_debug_info_entries
;
2573 else if (load_debug_section (info_dwo
, file
)
2574 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2576 return num_debug_info_entries
;
2578 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2582 /* Read a DWARF .debug_line section header starting at DATA.
2583 Upon success returns an updated DATA pointer and the LINFO
2584 structure and the END_OF_SEQUENCE pointer will be filled in.
2585 Otherwise returns NULL. */
2587 static unsigned char *
2588 read_debug_line_header (struct dwarf_section
* section
,
2589 unsigned char * data
,
2590 unsigned char * end
,
2591 DWARF2_Internal_LineInfo
* linfo
,
2592 unsigned char ** end_of_sequence
)
2594 unsigned char *hdrptr
;
2595 unsigned int offset_size
;
2596 unsigned int initial_length_size
;
2598 /* Extract information from the Line Number Program Header.
2599 (section 6.2.4 in the Dwarf3 doc). */
2602 /* Get and check the length of the block. */
2603 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2605 if (linfo
->li_length
== 0xffffffff)
2607 /* This section is 64-bit DWARF 3. */
2608 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2610 initial_length_size
= 12;
2615 initial_length_size
= 4;
2618 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2620 /* If the length is just a bias against the initial_length_size then
2621 this means that the field has a relocation against it which has not
2622 been applied. (Ie we are dealing with an object file, not a linked
2623 binary). Do not complain but instead assume that the rest of the
2624 section applies to this particular header. */
2625 if (linfo
->li_length
== - initial_length_size
)
2627 linfo
->li_length
= section
->size
- initial_length_size
;
2631 warn (_("The line info appears to be corrupt - "
2632 "the section is too small\n"));
2637 /* Get and check the version number. */
2638 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2640 if (linfo
->li_version
!= 2
2641 && linfo
->li_version
!= 3
2642 && linfo
->li_version
!= 4)
2644 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2648 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2649 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2651 if (linfo
->li_version
>= 4)
2653 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2655 if (linfo
->li_max_ops_per_insn
== 0)
2657 warn (_("Invalid maximum operations per insn.\n"));
2662 linfo
->li_max_ops_per_insn
= 1;
2664 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2665 SAFE_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2666 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2667 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2669 /* Sign extend the line base field. */
2670 linfo
->li_line_base
<<= 24;
2671 linfo
->li_line_base
>>= 24;
2673 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2678 display_debug_lines_raw (struct dwarf_section
*section
,
2679 unsigned char *data
,
2682 unsigned char *start
= section
->start
;
2684 printf (_("Raw dump of debug contents of section %s:\n\n"),
2689 static DWARF2_Internal_LineInfo saved_linfo
;
2690 DWARF2_Internal_LineInfo linfo
;
2691 unsigned char *standard_opcodes
;
2692 unsigned char *end_of_sequence
;
2693 unsigned int last_dir_entry
= 0;
2696 if (const_strneq (section
->name
, ".debug_line.")
2697 /* Note: the following does not apply to .debug_line.dwo sections.
2698 These are full debug_line sections. */
2699 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2701 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2702 section containing just the Line Number Statements. They are
2703 created by the assembler and intended to be used alongside gcc's
2704 -ffunction-sections command line option. When the linker's
2705 garbage collection decides to discard a .text.<foo> section it
2706 can then also discard the line number information in .debug_line.<foo>.
2708 Since the section is a fragment it does not have the details
2709 needed to fill out a LineInfo structure, so instead we use the
2710 details from the last full debug_line section that we processed. */
2711 end_of_sequence
= end
;
2712 standard_opcodes
= NULL
;
2713 linfo
= saved_linfo
;
2714 reset_state_machine (linfo
.li_default_is_stmt
);
2718 unsigned char * hdrptr
;
2720 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2721 & end_of_sequence
)) == NULL
)
2724 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2725 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2726 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2727 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2728 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2729 if (linfo
.li_version
>= 4)
2730 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2731 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2732 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2733 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2734 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2736 reset_state_machine (linfo
.li_default_is_stmt
);
2738 /* Display the contents of the Opcodes table. */
2739 standard_opcodes
= hdrptr
;
2741 printf (_("\n Opcodes:\n"));
2743 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2744 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2746 /* Display the contents of the Directory table. */
2747 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2750 printf (_("\n The Directory Table is empty.\n"));
2753 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2754 (long)(data
- start
));
2758 printf (" %d\t%s\n", ++last_dir_entry
, data
);
2760 data
+= strnlen ((char *) data
, end
- data
) + 1;
2764 /* Skip the NUL at the end of the table. */
2767 /* Display the contents of the File Name table. */
2769 printf (_("\n The File Name Table is empty.\n"));
2772 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2773 (long)(data
- start
));
2774 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2778 unsigned char *name
;
2779 unsigned int bytes_read
;
2781 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2783 data
+= strnlen ((char *) data
, end
- data
) + 1;
2786 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2789 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2792 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2794 printf ("%s\n", name
);
2798 warn (_("Corrupt file name table entry\n"));
2804 /* Skip the NUL at the end of the table. */
2807 saved_linfo
= linfo
;
2810 /* Now display the statements. */
2811 if (data
>= end_of_sequence
)
2812 printf (_(" No Line Number Statements.\n"));
2815 printf (_(" Line Number Statements:\n"));
2817 while (data
< end_of_sequence
)
2819 unsigned char op_code
;
2820 dwarf_signed_vma adv
;
2822 unsigned int bytes_read
;
2824 printf (" [0x%08lx]", (long)(data
- start
));
2828 if (op_code
>= linfo
.li_opcode_base
)
2830 op_code
-= linfo
.li_opcode_base
;
2831 uladv
= (op_code
/ linfo
.li_line_range
);
2832 if (linfo
.li_max_ops_per_insn
== 1)
2834 uladv
*= linfo
.li_min_insn_length
;
2835 state_machine_regs
.address
+= uladv
;
2836 printf (_(" Special opcode %d: "
2837 "advance Address by %s to 0x%s"),
2838 op_code
, dwarf_vmatoa ("u", uladv
),
2839 dwarf_vmatoa ("x", state_machine_regs
.address
));
2843 state_machine_regs
.address
2844 += ((state_machine_regs
.op_index
+ uladv
)
2845 / linfo
.li_max_ops_per_insn
)
2846 * linfo
.li_min_insn_length
;
2847 state_machine_regs
.op_index
2848 = (state_machine_regs
.op_index
+ uladv
)
2849 % linfo
.li_max_ops_per_insn
;
2850 printf (_(" Special opcode %d: "
2851 "advance Address by %s to 0x%s[%d]"),
2852 op_code
, dwarf_vmatoa ("u", uladv
),
2853 dwarf_vmatoa ("x", state_machine_regs
.address
),
2854 state_machine_regs
.op_index
);
2856 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2857 state_machine_regs
.line
+= adv
;
2858 printf (_(" and Line by %s to %d\n"),
2859 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
2861 else switch (op_code
)
2863 case DW_LNS_extended_op
:
2864 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
2868 printf (_(" Copy\n"));
2871 case DW_LNS_advance_pc
:
2872 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2874 if (linfo
.li_max_ops_per_insn
== 1)
2876 uladv
*= linfo
.li_min_insn_length
;
2877 state_machine_regs
.address
+= uladv
;
2878 printf (_(" Advance PC by %s to 0x%s\n"),
2879 dwarf_vmatoa ("u", uladv
),
2880 dwarf_vmatoa ("x", state_machine_regs
.address
));
2884 state_machine_regs
.address
2885 += ((state_machine_regs
.op_index
+ uladv
)
2886 / linfo
.li_max_ops_per_insn
)
2887 * linfo
.li_min_insn_length
;
2888 state_machine_regs
.op_index
2889 = (state_machine_regs
.op_index
+ uladv
)
2890 % linfo
.li_max_ops_per_insn
;
2891 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
2892 dwarf_vmatoa ("u", uladv
),
2893 dwarf_vmatoa ("x", state_machine_regs
.address
),
2894 state_machine_regs
.op_index
);
2898 case DW_LNS_advance_line
:
2899 adv
= read_sleb128 (data
, & bytes_read
, end
);
2901 state_machine_regs
.line
+= adv
;
2902 printf (_(" Advance Line by %s to %d\n"),
2903 dwarf_vmatoa ("d", adv
),
2904 state_machine_regs
.line
);
2907 case DW_LNS_set_file
:
2908 adv
= read_uleb128 (data
, & bytes_read
, end
);
2910 printf (_(" Set File Name to entry %s in the File Name Table\n"),
2911 dwarf_vmatoa ("d", adv
));
2912 state_machine_regs
.file
= adv
;
2915 case DW_LNS_set_column
:
2916 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2918 printf (_(" Set column to %s\n"),
2919 dwarf_vmatoa ("u", uladv
));
2920 state_machine_regs
.column
= uladv
;
2923 case DW_LNS_negate_stmt
:
2924 adv
= state_machine_regs
.is_stmt
;
2926 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
2927 state_machine_regs
.is_stmt
= adv
;
2930 case DW_LNS_set_basic_block
:
2931 printf (_(" Set basic block\n"));
2932 state_machine_regs
.basic_block
= 1;
2935 case DW_LNS_const_add_pc
:
2936 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2937 if (linfo
.li_max_ops_per_insn
)
2939 uladv
*= linfo
.li_min_insn_length
;
2940 state_machine_regs
.address
+= uladv
;
2941 printf (_(" Advance PC by constant %s to 0x%s\n"),
2942 dwarf_vmatoa ("u", uladv
),
2943 dwarf_vmatoa ("x", state_machine_regs
.address
));
2947 state_machine_regs
.address
2948 += ((state_machine_regs
.op_index
+ uladv
)
2949 / linfo
.li_max_ops_per_insn
)
2950 * linfo
.li_min_insn_length
;
2951 state_machine_regs
.op_index
2952 = (state_machine_regs
.op_index
+ uladv
)
2953 % linfo
.li_max_ops_per_insn
;
2954 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
2955 dwarf_vmatoa ("u", uladv
),
2956 dwarf_vmatoa ("x", state_machine_regs
.address
),
2957 state_machine_regs
.op_index
);
2961 case DW_LNS_fixed_advance_pc
:
2962 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
2963 state_machine_regs
.address
+= uladv
;
2964 state_machine_regs
.op_index
= 0;
2965 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
2966 dwarf_vmatoa ("u", uladv
),
2967 dwarf_vmatoa ("x", state_machine_regs
.address
));
2970 case DW_LNS_set_prologue_end
:
2971 printf (_(" Set prologue_end to true\n"));
2974 case DW_LNS_set_epilogue_begin
:
2975 printf (_(" Set epilogue_begin to true\n"));
2978 case DW_LNS_set_isa
:
2979 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2981 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
2985 printf (_(" Unknown opcode %d with operands: "), op_code
);
2987 if (standard_opcodes
!= NULL
)
2988 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2990 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
2992 i
== 1 ? "" : ", ");
3008 unsigned char *name
;
3009 unsigned int directory_index
;
3010 unsigned int modification_date
;
3011 unsigned int length
;
3014 /* Output a decoded representation of the .debug_line section. */
3017 display_debug_lines_decoded (struct dwarf_section
*section
,
3018 unsigned char *data
,
3021 static DWARF2_Internal_LineInfo saved_linfo
;
3023 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3028 /* This loop amounts to one iteration per compilation unit. */
3029 DWARF2_Internal_LineInfo linfo
;
3030 unsigned char *standard_opcodes
;
3031 unsigned char *end_of_sequence
;
3033 File_Entry
*file_table
= NULL
;
3034 unsigned int n_files
= 0;
3035 unsigned char **directory_table
= NULL
;
3036 unsigned int n_directories
= 0;
3038 if (const_strneq (section
->name
, ".debug_line.")
3039 /* Note: the following does not apply to .debug_line.dwo sections.
3040 These are full debug_line sections. */
3041 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3043 /* See comment in display_debug_lines_raw(). */
3044 end_of_sequence
= end
;
3045 standard_opcodes
= NULL
;
3046 linfo
= saved_linfo
;
3047 reset_state_machine (linfo
.li_default_is_stmt
);
3051 unsigned char *hdrptr
;
3053 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3054 & end_of_sequence
)) == NULL
)
3057 reset_state_machine (linfo
.li_default_is_stmt
);
3059 /* Save a pointer to the contents of the Opcodes table. */
3060 standard_opcodes
= hdrptr
;
3062 /* Traverse the Directory table just to count entries. */
3063 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3066 unsigned char *ptr_directory_table
= data
;
3070 data
+= strnlen ((char *) data
, end
- data
) + 1;
3074 /* Go through the directory table again to save the directories. */
3075 directory_table
= (unsigned char **)
3076 xmalloc (n_directories
* sizeof (unsigned char *));
3079 while (*ptr_directory_table
!= 0)
3081 directory_table
[i
] = ptr_directory_table
;
3082 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3083 ptr_directory_table
- end
) + 1;
3087 /* Skip the NUL at the end of the table. */
3090 /* Traverse the File Name table just to count the entries. */
3093 unsigned char *ptr_file_name_table
= data
;
3097 unsigned int bytes_read
;
3099 /* Skip Name, directory index, last modification time and length
3101 data
+= strnlen ((char *) data
, end
- data
) + 1;
3102 read_uleb128 (data
, & bytes_read
, end
);
3104 read_uleb128 (data
, & bytes_read
, end
);
3106 read_uleb128 (data
, & bytes_read
, end
);
3112 /* Go through the file table again to save the strings. */
3113 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3116 while (*ptr_file_name_table
!= 0)
3118 unsigned int bytes_read
;
3120 file_table
[i
].name
= ptr_file_name_table
;
3121 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3122 end
- ptr_file_name_table
) + 1;
3124 /* We are not interested in directory, time or size. */
3125 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3127 ptr_file_name_table
+= bytes_read
;
3128 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3130 ptr_file_name_table
+= bytes_read
;
3131 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3132 ptr_file_name_table
+= bytes_read
;
3137 /* Print the Compilation Unit's name and a header. */
3138 if (directory_table
== NULL
)
3140 printf (_("CU: %s:\n"), file_table
[0].name
);
3141 printf (_("File name Line number Starting address\n"));
3145 unsigned int ix
= file_table
[0].directory_index
;
3146 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3148 if (do_wide
|| strlen (directory
) < 76)
3149 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3151 printf ("%s:\n", file_table
[0].name
);
3153 printf (_("File name Line number Starting address\n"));
3157 /* Skip the NUL at the end of the table. */
3160 saved_linfo
= linfo
;
3163 /* This loop iterates through the Dwarf Line Number Program. */
3164 while (data
< end_of_sequence
)
3166 unsigned char op_code
;
3168 unsigned long int uladv
;
3169 unsigned int bytes_read
;
3170 int is_special_opcode
= 0;
3174 if (op_code
>= linfo
.li_opcode_base
)
3176 op_code
-= linfo
.li_opcode_base
;
3177 uladv
= (op_code
/ linfo
.li_line_range
);
3178 if (linfo
.li_max_ops_per_insn
== 1)
3180 uladv
*= linfo
.li_min_insn_length
;
3181 state_machine_regs
.address
+= uladv
;
3185 state_machine_regs
.address
3186 += ((state_machine_regs
.op_index
+ uladv
)
3187 / linfo
.li_max_ops_per_insn
)
3188 * linfo
.li_min_insn_length
;
3189 state_machine_regs
.op_index
3190 = (state_machine_regs
.op_index
+ uladv
)
3191 % linfo
.li_max_ops_per_insn
;
3194 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3195 state_machine_regs
.line
+= adv
;
3196 is_special_opcode
= 1;
3198 else switch (op_code
)
3200 case DW_LNS_extended_op
:
3202 unsigned int ext_op_code_len
;
3203 unsigned char ext_op_code
;
3204 unsigned char *op_code_data
= data
;
3206 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3208 op_code_data
+= bytes_read
;
3210 if (ext_op_code_len
== 0)
3212 warn (_("badly formed extended line op encountered!\n"));
3215 ext_op_code_len
+= bytes_read
;
3216 ext_op_code
= *op_code_data
++;
3218 switch (ext_op_code
)
3220 case DW_LNE_end_sequence
:
3221 reset_state_machine (linfo
.li_default_is_stmt
);
3223 case DW_LNE_set_address
:
3224 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3226 ext_op_code_len
- bytes_read
- 1,
3228 state_machine_regs
.op_index
= 0;
3230 case DW_LNE_define_file
:
3232 file_table
= (File_Entry
*) xrealloc
3233 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3235 ++state_machine_regs
.last_file_entry
;
3236 /* Source file name. */
3237 file_table
[n_files
].name
= op_code_data
;
3238 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3239 /* Directory index. */
3240 file_table
[n_files
].directory_index
=
3241 read_uleb128 (op_code_data
, & bytes_read
,
3243 op_code_data
+= bytes_read
;
3244 /* Last modification time. */
3245 file_table
[n_files
].modification_date
=
3246 read_uleb128 (op_code_data
, & bytes_read
,
3248 op_code_data
+= bytes_read
;
3250 file_table
[n_files
].length
=
3251 read_uleb128 (op_code_data
, & bytes_read
,
3257 case DW_LNE_set_discriminator
:
3258 case DW_LNE_HP_set_sequence
:
3259 /* Simply ignored. */
3263 printf (_("UNKNOWN (%u): length %d\n"),
3264 ext_op_code
, ext_op_code_len
- bytes_read
);
3267 data
+= ext_op_code_len
;
3273 case DW_LNS_advance_pc
:
3274 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3276 if (linfo
.li_max_ops_per_insn
== 1)
3278 uladv
*= linfo
.li_min_insn_length
;
3279 state_machine_regs
.address
+= uladv
;
3283 state_machine_regs
.address
3284 += ((state_machine_regs
.op_index
+ uladv
)
3285 / linfo
.li_max_ops_per_insn
)
3286 * linfo
.li_min_insn_length
;
3287 state_machine_regs
.op_index
3288 = (state_machine_regs
.op_index
+ uladv
)
3289 % linfo
.li_max_ops_per_insn
;
3293 case DW_LNS_advance_line
:
3294 adv
= read_sleb128 (data
, & bytes_read
, end
);
3296 state_machine_regs
.line
+= adv
;
3299 case DW_LNS_set_file
:
3300 adv
= read_uleb128 (data
, & bytes_read
, end
);
3302 state_machine_regs
.file
= adv
;
3304 if (file_table
== NULL
)
3305 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3306 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3307 /* If directory index is 0, that means current directory. */
3308 printf ("\n./%s:[++]\n",
3309 file_table
[state_machine_regs
.file
- 1].name
);
3310 else if (directory_table
== NULL
)
3311 printf (_("\n [Use directory table entry %d]\n"),
3312 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3314 /* The directory index starts counting at 1. */
3315 printf ("\n%s/%s:\n",
3316 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3317 file_table
[state_machine_regs
.file
- 1].name
);
3320 case DW_LNS_set_column
:
3321 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3323 state_machine_regs
.column
= uladv
;
3326 case DW_LNS_negate_stmt
:
3327 adv
= state_machine_regs
.is_stmt
;
3329 state_machine_regs
.is_stmt
= adv
;
3332 case DW_LNS_set_basic_block
:
3333 state_machine_regs
.basic_block
= 1;
3336 case DW_LNS_const_add_pc
:
3337 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3338 if (linfo
.li_max_ops_per_insn
== 1)
3340 uladv
*= linfo
.li_min_insn_length
;
3341 state_machine_regs
.address
+= uladv
;
3345 state_machine_regs
.address
3346 += ((state_machine_regs
.op_index
+ uladv
)
3347 / linfo
.li_max_ops_per_insn
)
3348 * linfo
.li_min_insn_length
;
3349 state_machine_regs
.op_index
3350 = (state_machine_regs
.op_index
+ uladv
)
3351 % linfo
.li_max_ops_per_insn
;
3355 case DW_LNS_fixed_advance_pc
:
3356 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3357 state_machine_regs
.address
+= uladv
;
3358 state_machine_regs
.op_index
= 0;
3361 case DW_LNS_set_prologue_end
:
3364 case DW_LNS_set_epilogue_begin
:
3367 case DW_LNS_set_isa
:
3368 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3370 printf (_(" Set ISA to %lu\n"), uladv
);
3374 printf (_(" Unknown opcode %d with operands: "), op_code
);
3376 if (standard_opcodes
!= NULL
)
3377 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3379 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3381 i
== 1 ? "" : ", ");
3388 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3389 to the DWARF address/line matrix. */
3390 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3391 || (op_code
== DW_LNS_copy
))
3393 const unsigned int MAX_FILENAME_LENGTH
= 35;
3395 char *newFileName
= NULL
;
3396 size_t fileNameLength
;
3399 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3401 fileName
= "<unknown>";
3403 fileNameLength
= strlen (fileName
);
3405 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3407 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3408 /* Truncate file name */
3409 strncpy (newFileName
,
3410 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3411 MAX_FILENAME_LENGTH
+ 1);
3415 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3416 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3419 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3421 if (linfo
.li_max_ops_per_insn
== 1)
3422 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3423 newFileName
, state_machine_regs
.line
,
3424 state_machine_regs
.address
);
3426 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3427 newFileName
, state_machine_regs
.line
,
3428 state_machine_regs
.address
,
3429 state_machine_regs
.op_index
);
3433 if (linfo
.li_max_ops_per_insn
== 1)
3434 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3435 newFileName
, state_machine_regs
.line
,
3436 state_machine_regs
.address
);
3438 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3439 newFileName
, state_machine_regs
.line
,
3440 state_machine_regs
.address
,
3441 state_machine_regs
.op_index
);
3444 if (op_code
== DW_LNE_end_sequence
)
3458 if (directory_table
)
3460 free (directory_table
);
3461 directory_table
= NULL
;
3472 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3474 unsigned char *data
= section
->start
;
3475 unsigned char *end
= data
+ section
->size
;
3477 int retValDecoded
= 1;
3479 if (do_debug_lines
== 0)
3480 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3482 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3483 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3485 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3486 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3488 if (!retValRaw
|| !retValDecoded
)
3495 find_debug_info_for_offset (unsigned long offset
)
3499 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3502 for (i
= 0; i
< num_debug_info_entries
; i
++)
3503 if (debug_information
[i
].cu_offset
== offset
)
3504 return debug_information
+ i
;
3510 display_debug_pubnames (struct dwarf_section
*section
,
3511 void *file ATTRIBUTE_UNUSED
)
3513 DWARF2_Internal_PubNames names
;
3514 unsigned char *start
= section
->start
;
3515 unsigned char *end
= start
+ section
->size
;
3517 /* It does not matter if this load fails,
3518 we test for that later on. */
3519 load_debug_info (file
);
3521 printf (_("Contents of the %s section:\n\n"), section
->name
);
3525 unsigned char *data
;
3526 unsigned long offset
;
3527 unsigned int offset_size
, initial_length_size
;
3531 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3532 if (names
.pn_length
== 0xffffffff)
3534 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3536 initial_length_size
= 12;
3541 initial_length_size
= 4;
3544 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3545 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3547 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3548 && num_debug_info_entries
> 0
3549 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3550 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3551 (unsigned long) names
.pn_offset
, section
->name
);
3553 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3555 start
+= names
.pn_length
+ initial_length_size
;
3557 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3559 static int warned
= 0;
3563 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3570 printf (_(" Length: %ld\n"),
3571 (long) names
.pn_length
);
3572 printf (_(" Version: %d\n"),
3574 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3575 (unsigned long) names
.pn_offset
);
3576 printf (_(" Size of area in .debug_info section: %ld\n"),
3577 (long) names
.pn_size
);
3579 printf (_("\n Offset\tName\n"));
3583 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3587 data
+= offset_size
;
3588 printf (" %-6lx\t%s\n", offset
, data
);
3589 data
+= strnlen ((char *) data
, end
- data
) + 1;
3592 while (offset
!= 0);
3600 display_debug_macinfo (struct dwarf_section
*section
,
3601 void *file ATTRIBUTE_UNUSED
)
3603 unsigned char *start
= section
->start
;
3604 unsigned char *end
= start
+ section
->size
;
3605 unsigned char *curr
= start
;
3606 unsigned int bytes_read
;
3607 enum dwarf_macinfo_record_type op
;
3609 printf (_("Contents of the %s section:\n\n"), section
->name
);
3613 unsigned int lineno
;
3614 const unsigned char *string
;
3616 op
= (enum dwarf_macinfo_record_type
) *curr
;
3621 case DW_MACINFO_start_file
:
3623 unsigned int filenum
;
3625 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3627 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3630 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3635 case DW_MACINFO_end_file
:
3636 printf (_(" DW_MACINFO_end_file\n"));
3639 case DW_MACINFO_define
:
3640 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3643 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3644 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3648 case DW_MACINFO_undef
:
3649 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3652 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3653 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3657 case DW_MACINFO_vendor_ext
:
3659 unsigned int constant
;
3661 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3664 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3665 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3675 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3676 filename and dirname corresponding to file name table entry with index
3677 FILEIDX. Return NULL on failure. */
3679 static unsigned char *
3680 get_line_filename_and_dirname (dwarf_vma line_offset
,
3682 unsigned char **dir_name
)
3684 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3685 unsigned char *hdrptr
, *dirtable
, *file_name
;
3686 unsigned int offset_size
, initial_length_size
;
3687 unsigned int version
, opcode_base
, bytes_read
;
3688 dwarf_vma length
, diridx
;
3689 const unsigned char * end
;
3692 if (section
->start
== NULL
3693 || line_offset
>= section
->size
3697 hdrptr
= section
->start
+ line_offset
;
3698 end
= section
->start
+ section
->size
;
3700 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3701 if (length
== 0xffffffff)
3703 /* This section is 64-bit DWARF 3. */
3704 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3706 initial_length_size
= 12;
3711 initial_length_size
= 4;
3713 if (length
+ initial_length_size
> section
->size
)
3716 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3717 if (version
!= 2 && version
!= 3 && version
!= 4)
3719 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3721 hdrptr
++; /* Skip max_ops_per_insn. */
3722 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3724 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3725 if (opcode_base
== 0)
3728 hdrptr
+= opcode_base
- 1;
3730 /* Skip over dirname table. */
3731 while (*hdrptr
!= '\0')
3732 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3733 hdrptr
++; /* Skip the NUL at the end of the table. */
3734 /* Now skip over preceding filename table entries. */
3735 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3737 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3738 read_uleb128 (hdrptr
, &bytes_read
, end
);
3739 hdrptr
+= bytes_read
;
3740 read_uleb128 (hdrptr
, &bytes_read
, end
);
3741 hdrptr
+= bytes_read
;
3742 read_uleb128 (hdrptr
, &bytes_read
, end
);
3743 hdrptr
+= bytes_read
;
3745 if (hdrptr
== end
|| *hdrptr
== '\0')
3748 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3749 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
3752 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
3753 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
3754 if (*dirtable
== '\0')
3756 *dir_name
= dirtable
;
3761 display_debug_macro (struct dwarf_section
*section
,
3764 unsigned char *start
= section
->start
;
3765 unsigned char *end
= start
+ section
->size
;
3766 unsigned char *curr
= start
;
3767 unsigned char *extended_op_buf
[256];
3768 unsigned int bytes_read
;
3770 load_debug_section (str
, file
);
3771 load_debug_section (line
, file
);
3773 printf (_("Contents of the %s section:\n\n"), section
->name
);
3777 unsigned int lineno
, version
, flags
;
3778 unsigned int offset_size
= 4;
3779 const unsigned char *string
;
3780 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
3781 unsigned char **extended_ops
= NULL
;
3783 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
3786 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3791 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
3794 printf (_(" Offset: 0x%lx\n"),
3795 (unsigned long) sec_offset
);
3796 printf (_(" Version: %d\n"), version
);
3797 printf (_(" Offset size: %d\n"), offset_size
);
3800 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
3801 printf (_(" Offset into .debug_line: 0x%lx\n"),
3802 (unsigned long) line_offset
);
3806 unsigned int i
, count
, op
;
3809 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
3811 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
3812 extended_ops
= extended_op_buf
;
3815 printf (_(" Extension opcode arguments:\n"));
3816 for (i
= 0; i
< count
; i
++)
3818 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3819 extended_ops
[op
] = curr
;
3820 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
3823 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
3826 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
3827 for (n
= 0; n
< nargs
; n
++)
3831 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
3832 printf ("%s%s", get_FORM_name (form
),
3833 n
== nargs
- 1 ? "\n" : ", ");
3843 case DW_FORM_block1
:
3844 case DW_FORM_block2
:
3845 case DW_FORM_block4
:
3847 case DW_FORM_string
:
3849 case DW_FORM_sec_offset
:
3852 error (_("Invalid extension opcode form %s\n"),
3853 get_FORM_name (form
));
3869 error (_(".debug_macro section not zero terminated\n"));
3873 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3879 case DW_MACRO_GNU_start_file
:
3881 unsigned int filenum
;
3882 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
3884 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3886 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
3889 if ((flags
& 2) == 0)
3890 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3893 = get_line_filename_and_dirname (line_offset
, filenum
,
3895 if (file_name
== NULL
)
3896 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3899 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3901 dir_name
!= NULL
? (const char *) dir_name
: "",
3902 dir_name
!= NULL
? "/" : "", file_name
);
3906 case DW_MACRO_GNU_end_file
:
3907 printf (_(" DW_MACRO_GNU_end_file\n"));
3910 case DW_MACRO_GNU_define
:
3911 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3914 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3915 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3919 case DW_MACRO_GNU_undef
:
3920 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3923 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3924 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3928 case DW_MACRO_GNU_define_indirect
:
3929 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3931 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3932 string
= fetch_indirect_string (offset
);
3933 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3937 case DW_MACRO_GNU_undef_indirect
:
3938 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3940 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3941 string
= fetch_indirect_string (offset
);
3942 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
3946 case DW_MACRO_GNU_transparent_include
:
3947 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3948 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
3949 (unsigned long) offset
);
3952 case DW_MACRO_GNU_define_indirect_alt
:
3953 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3955 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3956 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
3957 lineno
, (unsigned long) offset
);
3960 case DW_MACRO_GNU_undef_indirect_alt
:
3961 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3963 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3964 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
3965 lineno
, (unsigned long) offset
);
3968 case DW_MACRO_GNU_transparent_include_alt
:
3969 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3970 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
3971 (unsigned long) offset
);
3975 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
3977 error (_(" Unknown macro opcode %02x seen\n"), op
);
3982 /* Skip over unhandled opcodes. */
3984 unsigned char *desc
= extended_ops
[op
];
3985 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
3989 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
3992 printf (_(" DW_MACRO_GNU_%02x -"), op
);
3993 for (n
= 0; n
< nargs
; n
++)
3997 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
3999 = read_and_display_attr_value (0, val
,
4000 curr
, end
, 0, 0, offset_size
,
4001 version
, NULL
, 0, NULL
,
4019 display_debug_abbrev (struct dwarf_section
*section
,
4020 void *file ATTRIBUTE_UNUSED
)
4022 abbrev_entry
*entry
;
4023 unsigned char *start
= section
->start
;
4024 unsigned char *end
= start
+ section
->size
;
4026 printf (_("Contents of the %s section:\n\n"), section
->name
);
4030 unsigned char *last
;
4035 start
= process_abbrev_section (start
, end
);
4037 if (first_abbrev
== NULL
)
4040 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4042 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4046 printf (" %ld %s [%s]\n",
4048 get_TAG_name (entry
->tag
),
4049 entry
->children
? _("has children") : _("no children"));
4051 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4052 printf (" %-18s %s\n",
4053 get_AT_name (attr
->attribute
),
4054 get_FORM_name (attr
->form
));
4064 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4067 display_loc_list (struct dwarf_section
*section
,
4068 unsigned char **start_ptr
,
4069 int debug_info_entry
,
4070 unsigned long offset
,
4071 unsigned long base_address
,
4074 unsigned char *start
= *start_ptr
;
4075 unsigned char *section_end
= section
->start
+ section
->size
;
4076 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4077 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4078 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4079 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4083 unsigned short length
;
4084 int need_frame_base
;
4088 if (start
+ 2 * pointer_size
> section_end
)
4090 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4095 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4097 /* Note: we use sign extension here in order to be sure that we can detect
4098 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4099 address will not affect the values that we display since we always show
4100 hex values, and always the bottom 32-bits. */
4101 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4102 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4104 if (begin
== 0 && end
== 0)
4106 printf (_("<End of list>\n"));
4110 /* Check base address specifiers. */
4111 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4114 print_dwarf_vma (begin
, pointer_size
);
4115 print_dwarf_vma (end
, pointer_size
);
4116 printf (_("(base address)\n"));
4120 if (start
+ 2 > section_end
)
4122 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4127 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4129 if (start
+ length
> section_end
)
4131 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4136 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4137 print_dwarf_vma (end
+ base_address
, pointer_size
);
4140 need_frame_base
= decode_location_expression (start
,
4145 cu_offset
, section
);
4148 if (need_frame_base
&& !has_frame_base
)
4149 printf (_(" [without DW_AT_frame_base]"));
4152 fputs (_(" (start == end)"), stdout
);
4153 else if (begin
> end
)
4154 fputs (_(" (start > end)"), stdout
);
4164 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4165 right-adjusted in a field of length LEN, and followed by a space. */
4168 print_addr_index (unsigned int idx
, unsigned int len
)
4170 static char buf
[15];
4171 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4172 printf ("%*s ", len
, buf
);
4175 /* Display a location list from a .dwo section. It uses address indexes rather
4176 than embedded addresses. This code closely follows display_loc_list, but the
4177 two are sufficiently different that combining things is very ugly. */
4180 display_loc_list_dwo (struct dwarf_section
*section
,
4181 unsigned char **start_ptr
,
4182 int debug_info_entry
,
4183 unsigned long offset
,
4186 unsigned char *start
= *start_ptr
;
4187 unsigned char *section_end
= section
->start
+ section
->size
;
4188 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4189 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4190 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4191 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4193 unsigned short length
;
4194 int need_frame_base
;
4196 unsigned int bytes_read
;
4200 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4202 if (start
>= section_end
)
4204 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4209 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4212 case 0: /* A terminating entry. */
4214 printf (_("<End of list>\n"));
4216 case 1: /* A base-address entry. */
4217 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4218 start
+= bytes_read
;
4219 print_addr_index (idx
, 8);
4221 printf (_("(base address selection entry)\n"));
4223 case 2: /* A start/end entry. */
4224 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4225 start
+= bytes_read
;
4226 print_addr_index (idx
, 8);
4227 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4228 start
+= bytes_read
;
4229 print_addr_index (idx
, 8);
4231 case 3: /* A start/length entry. */
4232 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4233 start
+= bytes_read
;
4234 print_addr_index (idx
, 8);
4235 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4236 printf ("%08x ", idx
);
4238 case 4: /* An offset pair entry. */
4239 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4240 printf ("%08x ", idx
);
4241 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4242 printf ("%08x ", idx
);
4245 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4250 if (start
+ 2 > section_end
)
4252 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4257 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4258 if (start
+ length
> section_end
)
4260 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4266 need_frame_base
= decode_location_expression (start
,
4271 cu_offset
, section
);
4274 if (need_frame_base
&& !has_frame_base
)
4275 printf (_(" [without DW_AT_frame_base]"));
4285 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4287 static dwarf_vma
*loc_offsets
;
4290 loc_offsets_compar (const void *ap
, const void *bp
)
4292 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4293 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4295 return (a
> b
) - (b
> a
);
4299 display_debug_loc (struct dwarf_section
*section
, void *file
)
4301 unsigned char *start
= section
->start
;
4302 unsigned long bytes
;
4303 unsigned char *section_begin
= start
;
4304 unsigned int num_loc_list
= 0;
4305 unsigned long last_offset
= 0;
4306 unsigned int first
= 0;
4310 int seen_first_offset
= 0;
4311 int locs_sorted
= 1;
4312 unsigned char *next
;
4313 unsigned int *array
= NULL
;
4314 const char *suffix
= strrchr (section
->name
, '.');
4317 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4320 bytes
= section
->size
;
4324 printf (_("\nThe %s section is empty.\n"), section
->name
);
4328 if (load_debug_info (file
) == 0)
4330 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4335 /* Check the order of location list in .debug_info section. If
4336 offsets of location lists are in the ascending order, we can
4337 use `debug_information' directly. */
4338 for (i
= 0; i
< num_debug_info_entries
; i
++)
4342 num
= debug_information
[i
].num_loc_offsets
;
4343 if (num
> num_loc_list
)
4346 /* Check if we can use `debug_information' directly. */
4347 if (locs_sorted
&& num
!= 0)
4349 if (!seen_first_offset
)
4351 /* This is the first location list. */
4352 last_offset
= debug_information
[i
].loc_offsets
[0];
4354 seen_first_offset
= 1;
4360 for (; j
< num
; j
++)
4363 debug_information
[i
].loc_offsets
[j
])
4368 last_offset
= debug_information
[i
].loc_offsets
[j
];
4373 if (!seen_first_offset
)
4374 error (_("No location lists in .debug_info section!\n"));
4376 /* DWARF sections under Mach-O have non-zero addresses. */
4377 if (debug_information
[first
].num_loc_offsets
> 0
4378 && debug_information
[first
].loc_offsets
[0] != section
->address
)
4379 warn (_("Location lists in %s section start at 0x%s\n"),
4381 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4384 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4385 printf (_("Contents of the %s section:\n\n"), section
->name
);
4386 printf (_(" Offset Begin End Expression\n"));
4388 seen_first_offset
= 0;
4389 for (i
= first
; i
< num_debug_info_entries
; i
++)
4391 unsigned long offset
;
4392 unsigned long base_address
;
4397 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4399 loc_offsets
= debug_information
[i
].loc_offsets
;
4400 qsort (array
, debug_information
[i
].num_loc_offsets
,
4401 sizeof (*array
), loc_offsets_compar
);
4404 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4406 j
= locs_sorted
? k
: array
[k
];
4408 && debug_information
[i
].loc_offsets
[locs_sorted
4409 ? k
- 1 : array
[k
- 1]]
4410 == debug_information
[i
].loc_offsets
[j
])
4412 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4413 /* DWARF sections under Mach-O have non-zero addresses. */
4414 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
4415 next
= section_begin
+ offset
;
4416 base_address
= debug_information
[i
].base_address
;
4418 if (!seen_first_offset
)
4419 seen_first_offset
= 1;
4423 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4424 (unsigned long) (start
- section_begin
),
4425 (unsigned long) (next
- section_begin
));
4426 else if (start
> next
)
4427 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4428 (unsigned long) (start
- section_begin
),
4429 (unsigned long) (next
- section_begin
));
4433 if (offset
>= bytes
)
4435 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4441 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4443 display_loc_list (section
, &start
, i
, offset
, base_address
,
4448 if (start
< section
->start
+ section
->size
)
4449 warn (_("There are %ld unused bytes at the end of section %s\n"),
4450 (long) (section
->start
+ section
->size
- start
), section
->name
);
4457 display_debug_str (struct dwarf_section
*section
,
4458 void *file ATTRIBUTE_UNUSED
)
4460 unsigned char *start
= section
->start
;
4461 unsigned long bytes
= section
->size
;
4462 dwarf_vma addr
= section
->address
;
4466 printf (_("\nThe %s section is empty.\n"), section
->name
);
4470 printf (_("Contents of the %s section:\n\n"), section
->name
);
4478 lbytes
= (bytes
> 16 ? 16 : bytes
);
4480 printf (" 0x%8.8lx ", (unsigned long) addr
);
4482 for (j
= 0; j
< 16; j
++)
4485 printf ("%2.2x", start
[j
]);
4493 for (j
= 0; j
< lbytes
; j
++)
4496 if (k
>= ' ' && k
< 0x80)
4515 display_debug_info (struct dwarf_section
*section
, void *file
)
4517 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4521 display_debug_types (struct dwarf_section
*section
, void *file
)
4523 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4527 display_trace_info (struct dwarf_section
*section
, void *file
)
4529 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4533 display_debug_aranges (struct dwarf_section
*section
,
4534 void *file ATTRIBUTE_UNUSED
)
4536 unsigned char *start
= section
->start
;
4537 unsigned char *end
= start
+ section
->size
;
4539 printf (_("Contents of the %s section:\n\n"), section
->name
);
4541 /* It does not matter if this load fails,
4542 we test for that later on. */
4543 load_debug_info (file
);
4547 unsigned char *hdrptr
;
4548 DWARF2_Internal_ARange arange
;
4549 unsigned char *addr_ranges
;
4552 unsigned char address_size
;
4554 unsigned int offset_size
;
4555 unsigned int initial_length_size
;
4559 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4560 if (arange
.ar_length
== 0xffffffff)
4562 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4564 initial_length_size
= 12;
4569 initial_length_size
= 4;
4572 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4573 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4575 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4576 && num_debug_info_entries
> 0
4577 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4578 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4579 (unsigned long) arange
.ar_info_offset
, section
->name
);
4581 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4582 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4584 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4586 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4590 printf (_(" Length: %ld\n"),
4591 (long) arange
.ar_length
);
4592 printf (_(" Version: %d\n"), arange
.ar_version
);
4593 printf (_(" Offset into .debug_info: 0x%lx\n"),
4594 (unsigned long) arange
.ar_info_offset
);
4595 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4596 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4598 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4600 if (address_size
== 0)
4602 error (_("Invalid address size in %s section!\n"),
4607 /* The DWARF spec does not require that the address size be a power
4608 of two, but we do. This will have to change if we ever encounter
4609 an uneven architecture. */
4610 if ((address_size
& (address_size
- 1)) != 0)
4612 warn (_("Pointer size + Segment size is not a power of two.\n"));
4616 if (address_size
> 4)
4617 printf (_("\n Address Length\n"));
4619 printf (_("\n Address Length\n"));
4621 addr_ranges
= hdrptr
;
4623 /* Must pad to an alignment boundary that is twice the address size. */
4624 excess
= (hdrptr
- start
) % (2 * address_size
);
4626 addr_ranges
+= (2 * address_size
) - excess
;
4628 start
+= arange
.ar_length
+ initial_length_size
;
4630 while (addr_ranges
+ 2 * address_size
<= start
)
4632 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4633 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4636 print_dwarf_vma (address
, address_size
);
4637 print_dwarf_vma (length
, address_size
);
4647 /* Comparison function for qsort. */
4649 comp_addr_base (const void * v0
, const void * v1
)
4651 debug_info
* info0
= (debug_info
*) v0
;
4652 debug_info
* info1
= (debug_info
*) v1
;
4653 return info0
->addr_base
- info1
->addr_base
;
4656 /* Display the debug_addr section. */
4658 display_debug_addr (struct dwarf_section
*section
,
4661 debug_info
**debug_addr_info
;
4662 unsigned char *entry
;
4667 if (section
->size
== 0)
4669 printf (_("\nThe %s section is empty.\n"), section
->name
);
4673 if (load_debug_info (file
) == 0)
4675 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4680 printf (_("Contents of the %s section:\n\n"), section
->name
);
4682 debug_addr_info
= (debug_info
**) xmalloc ((num_debug_info_entries
+ 1)
4683 * sizeof (debug_info
*));
4686 for (i
= 0; i
< num_debug_info_entries
; i
++)
4688 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4689 debug_addr_info
[count
++] = &debug_information
[i
];
4692 /* Add a sentinel to make iteration convenient. */
4693 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
4694 debug_addr_info
[count
]->addr_base
= section
->size
;
4696 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
4697 for (i
= 0; i
< count
; i
++)
4700 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
4702 printf (_(" For compilation unit at offset 0x%s:\n"),
4703 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
4705 printf (_("\tIndex\tAddress\n"));
4706 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
4707 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
4711 dwarf_vma base
= byte_get (entry
, address_size
);
4712 printf (_("\t%d:\t"), idx
);
4713 print_dwarf_vma (base
, address_size
);
4715 entry
+= address_size
;
4721 free (debug_addr_info
);
4725 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4727 display_debug_str_offsets (struct dwarf_section
*section
,
4728 void *file ATTRIBUTE_UNUSED
)
4730 if (section
->size
== 0)
4732 printf (_("\nThe %s section is empty.\n"), section
->name
);
4735 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
4736 what the offset size is for this section. */
4740 /* Each debug_information[x].range_lists[y] gets this representation for
4741 sorting purposes. */
4745 /* The debug_information[x].range_lists[y] value. */
4746 unsigned long ranges_offset
;
4748 /* Original debug_information to find parameters of the data. */
4749 debug_info
*debug_info_p
;
4752 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4755 range_entry_compar (const void *ap
, const void *bp
)
4757 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
4758 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
4759 const unsigned long a
= a_re
->ranges_offset
;
4760 const unsigned long b
= b_re
->ranges_offset
;
4762 return (a
> b
) - (b
> a
);
4766 display_debug_ranges (struct dwarf_section
*section
,
4767 void *file ATTRIBUTE_UNUSED
)
4769 unsigned char *start
= section
->start
;
4770 unsigned char *last_start
= start
;
4771 unsigned long bytes
= section
->size
;
4772 unsigned char *section_begin
= start
;
4773 unsigned char *finish
= start
+ bytes
;
4774 unsigned int num_range_list
, i
;
4775 struct range_entry
*range_entries
, *range_entry_fill
;
4779 printf (_("\nThe %s section is empty.\n"), section
->name
);
4783 if (load_debug_info (file
) == 0)
4785 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4791 for (i
= 0; i
< num_debug_info_entries
; i
++)
4792 num_range_list
+= debug_information
[i
].num_range_lists
;
4794 if (num_range_list
== 0)
4796 /* This can happen when the file was compiled with -gsplit-debug
4797 which removes references to range lists from the primary .o file. */
4798 printf (_("No range lists in .debug_info section.\n"));
4802 range_entries
= (struct range_entry
*)
4803 xmalloc (sizeof (*range_entries
) * num_range_list
);
4804 range_entry_fill
= range_entries
;
4806 for (i
= 0; i
< num_debug_info_entries
; i
++)
4808 debug_info
*debug_info_p
= &debug_information
[i
];
4811 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
4813 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
4814 range_entry_fill
->debug_info_p
= debug_info_p
;
4819 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
4820 range_entry_compar
);
4822 /* DWARF sections under Mach-O have non-zero addresses. */
4823 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= section
->address
)
4824 warn (_("Range lists in %s section start at 0x%lx\n"),
4825 section
->name
, range_entries
[0].ranges_offset
);
4827 printf (_("Contents of the %s section:\n\n"), section
->name
);
4828 printf (_(" Offset Begin End\n"));
4830 for (i
= 0; i
< num_range_list
; i
++)
4832 struct range_entry
*range_entry
= &range_entries
[i
];
4833 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
4834 unsigned int pointer_size
;
4835 unsigned long offset
;
4836 unsigned char *next
;
4837 unsigned long base_address
;
4839 pointer_size
= debug_info_p
->pointer_size
;
4841 /* DWARF sections under Mach-O have non-zero addresses. */
4842 offset
= range_entry
->ranges_offset
- section
->address
;
4843 next
= section_begin
+ offset
;
4844 base_address
= debug_info_p
->base_address
;
4846 if (dwarf_check
!= 0 && i
> 0)
4849 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4850 (unsigned long) (start
- section_begin
),
4851 (unsigned long) (next
- section_begin
), section
->name
);
4852 else if (start
> next
)
4854 if (next
== last_start
)
4856 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4857 (unsigned long) (start
- section_begin
),
4858 (unsigned long) (next
- section_begin
), section
->name
);
4864 while (start
< finish
)
4869 /* Note: we use sign extension here in order to be sure that
4870 we can detect the -1 escape value. Sign extension into the
4871 top 32 bits of a 32-bit address will not affect the values
4872 that we display since we always show hex values, and always
4873 the bottom 32-bits. */
4874 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
4875 if (start
>= finish
)
4877 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
4879 printf (" %8.8lx ", offset
);
4881 if (begin
== 0 && end
== 0)
4883 printf (_("<End of list>\n"));
4887 /* Check base address specifiers. */
4888 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4891 print_dwarf_vma (begin
, pointer_size
);
4892 print_dwarf_vma (end
, pointer_size
);
4893 printf ("(base address)\n");
4897 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4898 print_dwarf_vma (end
+ base_address
, pointer_size
);
4901 fputs (_("(start == end)"), stdout
);
4902 else if (begin
> end
)
4903 fputs (_("(start > end)"), stdout
);
4910 free (range_entries
);
4915 typedef struct Frame_Chunk
4917 struct Frame_Chunk
*next
;
4918 unsigned char *chunk_start
;
4920 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
4921 short int *col_type
;
4924 unsigned int code_factor
;
4931 unsigned char fde_encoding
;
4932 unsigned char cfa_exp
;
4933 unsigned char ptr_size
;
4934 unsigned char segment_size
;
4938 static const char *const *dwarf_regnames
;
4939 static unsigned int dwarf_regnames_count
;
4941 /* A marker for a col_type that means this column was never referenced
4942 in the frame info. */
4943 #define DW_CFA_unreferenced (-1)
4945 /* Return 0 if not more space is needed, 1 if more space is needed,
4946 -1 for invalid reg. */
4949 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
4951 int prev
= fc
->ncols
;
4953 if (reg
< (unsigned int) fc
->ncols
)
4956 if (dwarf_regnames_count
4957 && reg
> dwarf_regnames_count
)
4960 fc
->ncols
= reg
+ 1;
4961 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
4962 sizeof (short int));
4963 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
4965 while (prev
< fc
->ncols
)
4967 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
4968 fc
->col_offset
[prev
] = 0;
4974 static const char *const dwarf_regnames_i386
[] =
4976 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
4977 "esp", "ebp", "esi", "edi", /* 4 - 7 */
4978 "eip", "eflags", NULL
, /* 8 - 10 */
4979 "st0", "st1", "st2", "st3", /* 11 - 14 */
4980 "st4", "st5", "st6", "st7", /* 15 - 18 */
4981 NULL
, NULL
, /* 19 - 20 */
4982 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
4983 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
4984 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
4985 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
4986 "fcw", "fsw", "mxcsr", /* 37 - 39 */
4987 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
4988 "tr", "ldtr", /* 48 - 49 */
4989 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
4990 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
4991 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
4992 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
4993 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
4994 NULL
, NULL
, NULL
, /* 90 - 92 */
4995 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
4999 init_dwarf_regnames_i386 (void)
5001 dwarf_regnames
= dwarf_regnames_i386
;
5002 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5005 static const char *const dwarf_regnames_x86_64
[] =
5007 "rax", "rdx", "rcx", "rbx",
5008 "rsi", "rdi", "rbp", "rsp",
5009 "r8", "r9", "r10", "r11",
5010 "r12", "r13", "r14", "r15",
5012 "xmm0", "xmm1", "xmm2", "xmm3",
5013 "xmm4", "xmm5", "xmm6", "xmm7",
5014 "xmm8", "xmm9", "xmm10", "xmm11",
5015 "xmm12", "xmm13", "xmm14", "xmm15",
5016 "st0", "st1", "st2", "st3",
5017 "st4", "st5", "st6", "st7",
5018 "mm0", "mm1", "mm2", "mm3",
5019 "mm4", "mm5", "mm6", "mm7",
5021 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5022 "fs.base", "gs.base", NULL
, NULL
,
5024 "mxcsr", "fcw", "fsw",
5025 "xmm16", "xmm17", "xmm18", "xmm19",
5026 "xmm20", "xmm21", "xmm22", "xmm23",
5027 "xmm24", "xmm25", "xmm26", "xmm27",
5028 "xmm28", "xmm29", "xmm30", "xmm31",
5029 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5030 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5031 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5032 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5033 NULL
, NULL
, NULL
, /* 115 - 117 */
5034 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5038 init_dwarf_regnames_x86_64 (void)
5040 dwarf_regnames
= dwarf_regnames_x86_64
;
5041 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5045 init_dwarf_regnames (unsigned int e_machine
)
5051 init_dwarf_regnames_i386 ();
5057 init_dwarf_regnames_x86_64 ();
5066 regname (unsigned int regno
, int row
)
5068 static char reg
[64];
5070 && regno
< dwarf_regnames_count
5071 && dwarf_regnames
[regno
] != NULL
)
5074 return dwarf_regnames
[regno
];
5075 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5076 dwarf_regnames
[regno
]);
5079 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5084 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
5089 if (*max_regs
< fc
->ncols
)
5090 *max_regs
= fc
->ncols
;
5092 if (*need_col_headers
)
5094 static const char *sloc
= " LOC";
5096 *need_col_headers
= 0;
5098 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5100 for (r
= 0; r
< *max_regs
; r
++)
5101 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5106 printf ("%-5s ", regname (r
, 1));
5112 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5114 strcpy (tmp
, "exp");
5116 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5117 printf ("%-8s ", tmp
);
5119 for (r
= 0; r
< fc
->ncols
; r
++)
5121 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5123 switch (fc
->col_type
[r
])
5125 case DW_CFA_undefined
:
5128 case DW_CFA_same_value
:
5132 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5134 case DW_CFA_val_offset
:
5135 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5137 case DW_CFA_register
:
5138 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5140 case DW_CFA_expression
:
5141 strcpy (tmp
, "exp");
5143 case DW_CFA_val_expression
:
5144 strcpy (tmp
, "vexp");
5147 strcpy (tmp
, "n/a");
5150 printf ("%-5s ", tmp
);
5156 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end);
5157 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5158 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5161 display_debug_frames (struct dwarf_section
*section
,
5162 void *file ATTRIBUTE_UNUSED
)
5164 unsigned char *start
= section
->start
;
5165 unsigned char *end
= start
+ section
->size
;
5166 unsigned char *section_start
= start
;
5167 Frame_Chunk
*chunks
= 0;
5168 Frame_Chunk
*remembered_state
= 0;
5170 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5171 unsigned int length_return
;
5173 const char *bad_reg
= _("bad register: ");
5174 int saved_eh_addr_size
= eh_addr_size
;
5176 printf (_("Contents of the %s section:\n"), section
->name
);
5180 unsigned char *saved_start
;
5181 unsigned char *block_end
;
5186 int need_col_headers
= 1;
5187 unsigned char *augmentation_data
= NULL
;
5188 unsigned long augmentation_data_len
= 0;
5189 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5190 unsigned int offset_size
;
5191 unsigned int initial_length_size
;
5193 saved_start
= start
;
5195 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5198 printf ("\n%08lx ZERO terminator\n\n",
5199 (unsigned long)(saved_start
- section_start
));
5203 if (length
== 0xffffffff)
5205 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5207 initial_length_size
= 12;
5212 initial_length_size
= 4;
5215 block_end
= saved_start
+ length
+ initial_length_size
;
5216 if (block_end
> end
)
5218 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5219 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5220 (unsigned long) (saved_start
- section_start
));
5224 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5226 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5227 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5231 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5232 memset (fc
, 0, sizeof (Frame_Chunk
));
5236 fc
->chunk_start
= saved_start
;
5238 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5239 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5240 frame_need_space (fc
, max_regs
- 1);
5244 fc
->augmentation
= (char *) start
;
5245 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
5247 if (strcmp (fc
->augmentation
, "eh") == 0)
5248 start
+= eh_addr_size
;
5252 GET (fc
->ptr_size
, 1);
5253 GET (fc
->segment_size
, 1);
5254 eh_addr_size
= fc
->ptr_size
;
5258 fc
->ptr_size
= eh_addr_size
;
5259 fc
->segment_size
= 0;
5261 fc
->code_factor
= LEB ();
5262 fc
->data_factor
= SLEB ();
5272 if (fc
->augmentation
[0] == 'z')
5274 augmentation_data_len
= LEB ();
5275 augmentation_data
= start
;
5276 start
+= augmentation_data_len
;
5280 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5281 print_dwarf_vma (length
, fc
->ptr_size
);
5282 print_dwarf_vma (cie_id
, offset_size
);
5284 if (do_debug_frames_interp
)
5286 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5287 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5292 printf (" Version: %d\n", version
);
5293 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5296 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5297 printf (" Segment Size: %u\n", fc
->segment_size
);
5299 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5300 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5301 printf (" Return address column: %d\n", fc
->ra
);
5303 if (augmentation_data_len
)
5306 printf (" Augmentation data: ");
5307 for (i
= 0; i
< augmentation_data_len
; ++i
)
5308 printf (" %02x", augmentation_data
[i
]);
5314 if (augmentation_data_len
)
5316 unsigned char *p
, *q
;
5317 p
= (unsigned char *) fc
->augmentation
+ 1;
5318 q
= augmentation_data
;
5325 q
+= 1 + size_of_encoded_value (*q
);
5327 fc
->fde_encoding
= *q
++;
5335 if (fc
->fde_encoding
)
5336 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5339 frame_need_space (fc
, fc
->ra
);
5343 unsigned char *look_for
;
5344 static Frame_Chunk fde_fc
;
5345 unsigned long segment_selector
;
5348 memset (fc
, 0, sizeof (Frame_Chunk
));
5350 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
5352 for (cie
= chunks
; cie
; cie
= cie
->next
)
5353 if (cie
->chunk_start
== look_for
)
5358 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5359 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5360 (unsigned long) (saved_start
- section_start
));
5362 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5363 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5364 frame_need_space (fc
, max_regs
- 1);
5366 fc
->augmentation
= "";
5367 fc
->fde_encoding
= 0;
5368 fc
->ptr_size
= eh_addr_size
;
5369 fc
->segment_size
= 0;
5373 fc
->ncols
= cie
->ncols
;
5374 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5375 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5376 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5377 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5378 fc
->augmentation
= cie
->augmentation
;
5379 fc
->ptr_size
= cie
->ptr_size
;
5380 eh_addr_size
= cie
->ptr_size
;
5381 fc
->segment_size
= cie
->segment_size
;
5382 fc
->code_factor
= cie
->code_factor
;
5383 fc
->data_factor
= cie
->data_factor
;
5384 fc
->cfa_reg
= cie
->cfa_reg
;
5385 fc
->cfa_offset
= cie
->cfa_offset
;
5387 frame_need_space (fc
, max_regs
- 1);
5388 fc
->fde_encoding
= cie
->fde_encoding
;
5391 if (fc
->fde_encoding
)
5392 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5394 segment_selector
= 0;
5395 if (fc
->segment_size
)
5397 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5399 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
, section
);
5400 start
+= encoded_ptr_size
;
5402 /* FIXME: It appears that sometimes the final pc_range value is
5403 encoded in less than encoded_ptr_size bytes. See the x86_64
5404 run of the "objcopy on compressed debug sections" test for an
5406 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5408 if (cie
->augmentation
[0] == 'z')
5410 augmentation_data_len
= LEB ();
5411 augmentation_data
= start
;
5412 start
+= augmentation_data_len
;
5415 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5416 (unsigned long)(saved_start
- section_start
),
5417 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
5418 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5419 (unsigned long)(cie
->chunk_start
- section_start
));
5421 if (fc
->segment_size
)
5422 printf ("%04lx:", segment_selector
);
5425 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
5426 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
5428 if (! do_debug_frames_interp
&& augmentation_data_len
)
5432 printf (" Augmentation data: ");
5433 for (i
= 0; i
< augmentation_data_len
; ++i
)
5434 printf (" %02x", augmentation_data
[i
]);
5440 /* At this point, fc is the current chunk, cie (if any) is set, and
5441 we're about to interpret instructions for the chunk. */
5442 /* ??? At present we need to do this always, since this sizes the
5443 fc->col_type and fc->col_offset arrays, which we write into always.
5444 We should probably split the interpreted and non-interpreted bits
5445 into two different routines, since there's so much that doesn't
5446 really overlap between them. */
5447 if (1 || do_debug_frames_interp
)
5449 /* Start by making a pass over the chunk, allocating storage
5450 and taking note of what registers are used. */
5451 unsigned char *tmp
= start
;
5453 while (start
< block_end
)
5456 unsigned long reg
, temp
;
5463 /* Warning: if you add any more cases to this switch, be
5464 sure to add them to the corresponding switch below. */
5467 case DW_CFA_advance_loc
:
5471 if (frame_need_space (fc
, opa
) >= 0)
5472 fc
->col_type
[opa
] = DW_CFA_undefined
;
5474 case DW_CFA_restore
:
5475 if (frame_need_space (fc
, opa
) >= 0)
5476 fc
->col_type
[opa
] = DW_CFA_undefined
;
5478 case DW_CFA_set_loc
:
5479 start
+= encoded_ptr_size
;
5481 case DW_CFA_advance_loc1
:
5484 case DW_CFA_advance_loc2
:
5487 case DW_CFA_advance_loc4
:
5490 case DW_CFA_offset_extended
:
5491 case DW_CFA_val_offset
:
5492 reg
= LEB (); LEB ();
5493 if (frame_need_space (fc
, reg
) >= 0)
5494 fc
->col_type
[reg
] = DW_CFA_undefined
;
5496 case DW_CFA_restore_extended
:
5498 frame_need_space (fc
, reg
);
5499 if (frame_need_space (fc
, reg
) >= 0)
5500 fc
->col_type
[reg
] = DW_CFA_undefined
;
5502 case DW_CFA_undefined
:
5504 if (frame_need_space (fc
, reg
) >= 0)
5505 fc
->col_type
[reg
] = DW_CFA_undefined
;
5507 case DW_CFA_same_value
:
5509 if (frame_need_space (fc
, reg
) >= 0)
5510 fc
->col_type
[reg
] = DW_CFA_undefined
;
5512 case DW_CFA_register
:
5513 reg
= LEB (); LEB ();
5514 if (frame_need_space (fc
, reg
) >= 0)
5515 fc
->col_type
[reg
] = DW_CFA_undefined
;
5517 case DW_CFA_def_cfa
:
5520 case DW_CFA_def_cfa_register
:
5523 case DW_CFA_def_cfa_offset
:
5526 case DW_CFA_def_cfa_expression
:
5530 case DW_CFA_expression
:
5531 case DW_CFA_val_expression
:
5535 if (frame_need_space (fc
, reg
) >= 0)
5536 fc
->col_type
[reg
] = DW_CFA_undefined
;
5538 case DW_CFA_offset_extended_sf
:
5539 case DW_CFA_val_offset_sf
:
5540 reg
= LEB (); SLEB ();
5541 if (frame_need_space (fc
, reg
) >= 0)
5542 fc
->col_type
[reg
] = DW_CFA_undefined
;
5544 case DW_CFA_def_cfa_sf
:
5547 case DW_CFA_def_cfa_offset_sf
:
5550 case DW_CFA_MIPS_advance_loc8
:
5553 case DW_CFA_GNU_args_size
:
5556 case DW_CFA_GNU_negative_offset_extended
:
5557 reg
= LEB (); LEB ();
5558 if (frame_need_space (fc
, reg
) >= 0)
5559 fc
->col_type
[reg
] = DW_CFA_undefined
;
5568 /* Now we know what registers are used, make a second pass over
5569 the chunk, this time actually printing out the info. */
5571 while (start
< block_end
)
5574 unsigned long ul
, reg
, roffs
;
5578 const char *reg_prefix
= "";
5585 /* Warning: if you add any more cases to this switch, be
5586 sure to add them to the corresponding switch above. */
5589 case DW_CFA_advance_loc
:
5590 if (do_debug_frames_interp
)
5591 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5593 printf (" DW_CFA_advance_loc: %d to %s\n",
5594 opa
* fc
->code_factor
,
5595 dwarf_vmatoa_1 (NULL
,
5596 fc
->pc_begin
+ opa
* fc
->code_factor
,
5598 fc
->pc_begin
+= opa
* fc
->code_factor
;
5603 if (opa
>= (unsigned int) fc
->ncols
)
5604 reg_prefix
= bad_reg
;
5605 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5606 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
5607 reg_prefix
, regname (opa
, 0),
5608 roffs
* fc
->data_factor
);
5609 if (*reg_prefix
== '\0')
5611 fc
->col_type
[opa
] = DW_CFA_offset
;
5612 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
5616 case DW_CFA_restore
:
5617 if (opa
>= (unsigned int) cie
->ncols
5618 || opa
>= (unsigned int) fc
->ncols
)
5619 reg_prefix
= bad_reg
;
5620 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5621 printf (" DW_CFA_restore: %s%s\n",
5622 reg_prefix
, regname (opa
, 0));
5623 if (*reg_prefix
== '\0')
5625 fc
->col_type
[opa
] = cie
->col_type
[opa
];
5626 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
5627 if (do_debug_frames_interp
5628 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
5629 fc
->col_type
[opa
] = DW_CFA_undefined
;
5633 case DW_CFA_set_loc
:
5634 vma
= get_encoded_value (start
, fc
->fde_encoding
, section
);
5635 start
+= encoded_ptr_size
;
5636 if (do_debug_frames_interp
)
5637 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5639 printf (" DW_CFA_set_loc: %s\n",
5640 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
5644 case DW_CFA_advance_loc1
:
5645 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
5646 if (do_debug_frames_interp
)
5647 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5649 printf (" DW_CFA_advance_loc1: %ld to %s\n",
5650 (unsigned long) (ofs
* fc
->code_factor
),
5651 dwarf_vmatoa_1 (NULL
,
5652 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5654 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5657 case DW_CFA_advance_loc2
:
5658 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, end
);
5659 if (do_debug_frames_interp
)
5660 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5662 printf (" DW_CFA_advance_loc2: %ld to %s\n",
5663 (unsigned long) (ofs
* fc
->code_factor
),
5664 dwarf_vmatoa_1 (NULL
,
5665 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5667 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5670 case DW_CFA_advance_loc4
:
5671 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, end
);
5672 if (do_debug_frames_interp
)
5673 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5675 printf (" DW_CFA_advance_loc4: %ld to %s\n",
5676 (unsigned long) (ofs
* fc
->code_factor
),
5677 dwarf_vmatoa_1 (NULL
,
5678 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5680 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5683 case DW_CFA_offset_extended
:
5686 if (reg
>= (unsigned int) fc
->ncols
)
5687 reg_prefix
= bad_reg
;
5688 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5689 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5690 reg_prefix
, regname (reg
, 0),
5691 roffs
* fc
->data_factor
);
5692 if (*reg_prefix
== '\0')
5694 fc
->col_type
[reg
] = DW_CFA_offset
;
5695 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
5699 case DW_CFA_val_offset
:
5702 if (reg
>= (unsigned int) fc
->ncols
)
5703 reg_prefix
= bad_reg
;
5704 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5705 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
5706 reg_prefix
, regname (reg
, 0),
5707 roffs
* fc
->data_factor
);
5708 if (*reg_prefix
== '\0')
5710 fc
->col_type
[reg
] = DW_CFA_val_offset
;
5711 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
5715 case DW_CFA_restore_extended
:
5717 if (reg
>= (unsigned int) cie
->ncols
5718 || reg
>= (unsigned int) fc
->ncols
)
5719 reg_prefix
= bad_reg
;
5720 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5721 printf (" DW_CFA_restore_extended: %s%s\n",
5722 reg_prefix
, regname (reg
, 0));
5723 if (*reg_prefix
== '\0')
5725 fc
->col_type
[reg
] = cie
->col_type
[reg
];
5726 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
5730 case DW_CFA_undefined
:
5732 if (reg
>= (unsigned int) fc
->ncols
)
5733 reg_prefix
= bad_reg
;
5734 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5735 printf (" DW_CFA_undefined: %s%s\n",
5736 reg_prefix
, regname (reg
, 0));
5737 if (*reg_prefix
== '\0')
5739 fc
->col_type
[reg
] = DW_CFA_undefined
;
5740 fc
->col_offset
[reg
] = 0;
5744 case DW_CFA_same_value
:
5746 if (reg
>= (unsigned int) fc
->ncols
)
5747 reg_prefix
= bad_reg
;
5748 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5749 printf (" DW_CFA_same_value: %s%s\n",
5750 reg_prefix
, regname (reg
, 0));
5751 if (*reg_prefix
== '\0')
5753 fc
->col_type
[reg
] = DW_CFA_same_value
;
5754 fc
->col_offset
[reg
] = 0;
5758 case DW_CFA_register
:
5761 if (reg
>= (unsigned int) fc
->ncols
)
5762 reg_prefix
= bad_reg
;
5763 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5765 printf (" DW_CFA_register: %s%s in ",
5766 reg_prefix
, regname (reg
, 0));
5767 puts (regname (roffs
, 0));
5769 if (*reg_prefix
== '\0')
5771 fc
->col_type
[reg
] = DW_CFA_register
;
5772 fc
->col_offset
[reg
] = roffs
;
5776 case DW_CFA_remember_state
:
5777 if (! do_debug_frames_interp
)
5778 printf (" DW_CFA_remember_state\n");
5779 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5780 rs
->ncols
= fc
->ncols
;
5781 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
5782 sizeof (short int));
5783 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (int));
5784 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
5785 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
5786 rs
->next
= remembered_state
;
5787 remembered_state
= rs
;
5790 case DW_CFA_restore_state
:
5791 if (! do_debug_frames_interp
)
5792 printf (" DW_CFA_restore_state\n");
5793 rs
= remembered_state
;
5796 remembered_state
= rs
->next
;
5797 frame_need_space (fc
, rs
->ncols
- 1);
5798 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
5799 memcpy (fc
->col_offset
, rs
->col_offset
,
5800 rs
->ncols
* sizeof (int));
5801 free (rs
->col_type
);
5802 free (rs
->col_offset
);
5805 else if (do_debug_frames_interp
)
5806 printf ("Mismatched DW_CFA_restore_state\n");
5809 case DW_CFA_def_cfa
:
5810 fc
->cfa_reg
= LEB ();
5811 fc
->cfa_offset
= LEB ();
5813 if (! do_debug_frames_interp
)
5814 printf (" DW_CFA_def_cfa: %s ofs %d\n",
5815 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
5818 case DW_CFA_def_cfa_register
:
5819 fc
->cfa_reg
= LEB ();
5821 if (! do_debug_frames_interp
)
5822 printf (" DW_CFA_def_cfa_register: %s\n",
5823 regname (fc
->cfa_reg
, 0));
5826 case DW_CFA_def_cfa_offset
:
5827 fc
->cfa_offset
= LEB ();
5828 if (! do_debug_frames_interp
)
5829 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
5833 if (! do_debug_frames_interp
)
5834 printf (" DW_CFA_nop\n");
5837 case DW_CFA_def_cfa_expression
:
5839 if (! do_debug_frames_interp
)
5841 printf (" DW_CFA_def_cfa_expression (");
5842 decode_location_expression (start
, eh_addr_size
, 0, -1,
5850 case DW_CFA_expression
:
5853 if (reg
>= (unsigned int) fc
->ncols
)
5854 reg_prefix
= bad_reg
;
5855 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5857 printf (" DW_CFA_expression: %s%s (",
5858 reg_prefix
, regname (reg
, 0));
5859 decode_location_expression (start
, eh_addr_size
, 0, -1,
5863 if (*reg_prefix
== '\0')
5864 fc
->col_type
[reg
] = DW_CFA_expression
;
5868 case DW_CFA_val_expression
:
5871 if (reg
>= (unsigned int) fc
->ncols
)
5872 reg_prefix
= bad_reg
;
5873 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5875 printf (" DW_CFA_val_expression: %s%s (",
5876 reg_prefix
, regname (reg
, 0));
5877 decode_location_expression (start
, eh_addr_size
, 0, -1,
5881 if (*reg_prefix
== '\0')
5882 fc
->col_type
[reg
] = DW_CFA_val_expression
;
5886 case DW_CFA_offset_extended_sf
:
5889 if (frame_need_space (fc
, reg
) < 0)
5890 reg_prefix
= bad_reg
;
5891 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5892 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5893 reg_prefix
, regname (reg
, 0),
5894 l
* fc
->data_factor
);
5895 if (*reg_prefix
== '\0')
5897 fc
->col_type
[reg
] = DW_CFA_offset
;
5898 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
5902 case DW_CFA_val_offset_sf
:
5905 if (frame_need_space (fc
, reg
) < 0)
5906 reg_prefix
= bad_reg
;
5907 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5908 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5909 reg_prefix
, regname (reg
, 0),
5910 l
* fc
->data_factor
);
5911 if (*reg_prefix
== '\0')
5913 fc
->col_type
[reg
] = DW_CFA_val_offset
;
5914 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
5918 case DW_CFA_def_cfa_sf
:
5919 fc
->cfa_reg
= LEB ();
5920 fc
->cfa_offset
= SLEB ();
5921 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
5923 if (! do_debug_frames_interp
)
5924 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
5925 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
5928 case DW_CFA_def_cfa_offset_sf
:
5929 fc
->cfa_offset
= SLEB ();
5930 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
5931 if (! do_debug_frames_interp
)
5932 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
5935 case DW_CFA_MIPS_advance_loc8
:
5936 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, end
);
5937 if (do_debug_frames_interp
)
5938 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5940 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
5941 (unsigned long) (ofs
* fc
->code_factor
),
5942 dwarf_vmatoa_1 (NULL
,
5943 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5945 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5948 case DW_CFA_GNU_window_save
:
5949 if (! do_debug_frames_interp
)
5950 printf (" DW_CFA_GNU_window_save\n");
5953 case DW_CFA_GNU_args_size
:
5955 if (! do_debug_frames_interp
)
5956 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
5959 case DW_CFA_GNU_negative_offset_extended
:
5962 if (frame_need_space (fc
, reg
) < 0)
5963 reg_prefix
= bad_reg
;
5964 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5965 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5966 reg_prefix
, regname (reg
, 0),
5967 l
* fc
->data_factor
);
5968 if (*reg_prefix
== '\0')
5970 fc
->col_type
[reg
] = DW_CFA_offset
;
5971 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
5976 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
5977 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
5979 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
5984 if (do_debug_frames_interp
)
5985 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5988 eh_addr_size
= saved_eh_addr_size
;
6001 display_gdb_index (struct dwarf_section
*section
,
6002 void *file ATTRIBUTE_UNUSED
)
6004 unsigned char *start
= section
->start
;
6006 uint32_t cu_list_offset
, tu_list_offset
;
6007 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6008 unsigned int cu_list_elements
, tu_list_elements
;
6009 unsigned int address_table_size
, symbol_table_slots
;
6010 unsigned char *cu_list
, *tu_list
;
6011 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6014 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6016 printf (_("Contents of the %s section:\n"), section
->name
);
6018 if (section
->size
< 6 * sizeof (uint32_t))
6020 warn (_("Truncated header in the %s section.\n"), section
->name
);
6024 version
= byte_get_little_endian (start
, 4);
6025 printf (_("Version %ld\n"), (long) version
);
6027 /* Prior versions are obsolete, and future versions may not be
6028 backwards compatible. */
6029 if (version
< 3 || version
> 8)
6031 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6035 warn (_("The address table data in version 3 may be wrong.\n"));
6037 warn (_("Version 4 does not support case insensitive lookups.\n"));
6039 warn (_("Version 5 does not include inlined functions.\n"));
6041 warn (_("Version 6 does not include symbol attributes.\n"));
6042 /* Version 7 indices generated by Gold have bad type unit references,
6043 PR binutils/15021. But we don't know if the index was generated by
6044 Gold or not, so to avoid worrying users with gdb-generated indices
6045 we say nothing for version 7 here. */
6047 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6048 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6049 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6050 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6051 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6053 if (cu_list_offset
> section
->size
6054 || tu_list_offset
> section
->size
6055 || address_table_offset
> section
->size
6056 || symbol_table_offset
> section
->size
6057 || constant_pool_offset
> section
->size
)
6059 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6063 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6064 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6065 address_table_size
= symbol_table_offset
- address_table_offset
;
6066 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6068 cu_list
= start
+ cu_list_offset
;
6069 tu_list
= start
+ tu_list_offset
;
6070 address_table
= start
+ address_table_offset
;
6071 symbol_table
= start
+ symbol_table_offset
;
6072 constant_pool
= start
+ constant_pool_offset
;
6074 printf (_("\nCU table:\n"));
6075 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6077 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6078 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6080 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6081 (unsigned long) cu_offset
,
6082 (unsigned long) (cu_offset
+ cu_length
- 1));
6085 printf (_("\nTU table:\n"));
6086 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6088 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6089 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6090 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6092 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6093 (unsigned long) tu_offset
,
6094 (unsigned long) type_offset
);
6095 print_dwarf_vma (signature
, 8);
6099 printf (_("\nAddress table:\n"));
6100 for (i
= 0; i
< address_table_size
; i
+= 2 * 8 + 4)
6102 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6103 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6104 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6106 print_dwarf_vma (low
, 8);
6107 print_dwarf_vma (high
, 8);
6108 printf (_("%lu\n"), (unsigned long) cu_index
);
6111 printf (_("\nSymbol table:\n"));
6112 for (i
= 0; i
< symbol_table_slots
; ++i
)
6114 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6115 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6116 uint32_t num_cus
, cu
;
6118 if (name_offset
!= 0
6119 || cu_vector_offset
!= 0)
6123 printf ("[%3u] %s:", i
, constant_pool
+ name_offset
);
6124 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
6127 for (j
= 0; j
< num_cus
; ++j
)
6130 gdb_index_symbol_kind kind
;
6132 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6133 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6134 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6135 cu
= GDB_INDEX_CU_VALUE (cu
);
6136 /* Convert to TU number if it's for a type unit. */
6137 if (cu
>= cu_list_elements
/ 2)
6138 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6139 (unsigned long) (cu
- cu_list_elements
/ 2));
6141 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6145 case GDB_INDEX_SYMBOL_KIND_NONE
:
6146 printf (_(" [no symbol information]"));
6148 case GDB_INDEX_SYMBOL_KIND_TYPE
:
6150 ? _(" [static type]")
6151 : _(" [global type]"));
6153 case GDB_INDEX_SYMBOL_KIND_VARIABLE
:
6155 ? _(" [static variable]")
6156 : _(" [global variable]"));
6158 case GDB_INDEX_SYMBOL_KIND_FUNCTION
:
6160 ? _(" [static function]")
6161 : _(" [global function]"));
6163 case GDB_INDEX_SYMBOL_KIND_OTHER
:
6165 ? _(" [static other]")
6166 : _(" [global other]"));
6170 ? _(" [static unknown: %d]")
6171 : _(" [global unknown: %d]"),
6186 /* Pre-allocate enough space for the CU/TU sets needed. */
6189 prealloc_cu_tu_list (unsigned int nshndx
)
6191 if (shndx_pool
== NULL
)
6193 shndx_pool_size
= nshndx
;
6194 shndx_pool_used
= 0;
6195 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6196 sizeof (unsigned int));
6200 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6201 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6202 sizeof (unsigned int));
6207 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6209 if (shndx_pool_used
>= shndx_pool_size
)
6211 error (_("Internal error: out of space in the shndx pool.\n"));
6214 shndx_pool
[shndx_pool_used
++] = shndx
;
6218 end_cu_tu_entry (void)
6220 if (shndx_pool_used
>= shndx_pool_size
)
6222 error (_("Internal error: out of space in the shndx pool.\n"));
6225 shndx_pool
[shndx_pool_used
++] = 0;
6228 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6231 get_DW_SECT_short_name (unsigned int dw_sect
)
6233 static char buf
[16];
6241 case DW_SECT_ABBREV
:
6247 case DW_SECT_STR_OFFSETS
:
6249 case DW_SECT_MACINFO
:
6257 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6261 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6262 These sections are extensions for Fission.
6263 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6266 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6268 unsigned char *phdr
= section
->start
;
6269 unsigned char *limit
= phdr
+ section
->size
;
6270 unsigned char *phash
;
6271 unsigned char *pindex
;
6272 unsigned char *ppool
;
6273 unsigned int version
;
6274 unsigned int ncols
= 0;
6276 unsigned int nslots
;
6279 dwarf_vma signature_high
;
6280 dwarf_vma signature_low
;
6283 version
= byte_get (phdr
, 4);
6285 ncols
= byte_get (phdr
+ 4, 4);
6286 nused
= byte_get (phdr
+ 8, 4);
6287 nslots
= byte_get (phdr
+ 12, 4);
6289 pindex
= phash
+ nslots
* 8;
6290 ppool
= pindex
+ nslots
* 4;
6294 printf (_("Contents of the %s section:\n\n"), section
->name
);
6295 printf (_(" Version: %d\n"), version
);
6297 printf (_(" Number of columns: %d\n"), ncols
);
6298 printf (_(" Number of used entries: %d\n"), nused
);
6299 printf (_(" Number of slots: %d\n\n"), nslots
);
6304 warn (_("Section %s too small for %d hash table entries\n"),
6305 section
->name
, nslots
);
6312 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6313 for (i
= 0; i
< nslots
; i
++)
6315 unsigned char *shndx_list
;
6318 byte_get_64 (phash
, &signature_high
, &signature_low
);
6319 if (signature_high
!= 0 || signature_low
!= 0)
6321 j
= byte_get (pindex
, 4);
6322 shndx_list
= ppool
+ j
* 4;
6324 printf (_(" [%3d] Signature: 0x%s Sections: "),
6325 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6326 buf
, sizeof (buf
)));
6329 if (shndx_list
>= limit
)
6331 warn (_("Section %s too small for shndx pool\n"),
6335 shndx
= byte_get (shndx_list
, 4);
6339 printf (" %d", shndx
);
6341 add_shndx_to_cu_tu_entry (shndx
);
6353 else if (version
== 2)
6356 unsigned int dw_sect
;
6357 unsigned char *ph
= phash
;
6358 unsigned char *pi
= pindex
;
6359 unsigned char *poffsets
= ppool
+ ncols
* 4;
6360 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
6361 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
6362 bfd_boolean is_tu_index
;
6363 struct cu_tu_set
*this_set
= NULL
;
6365 unsigned char *prow
;
6367 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
6371 warn (_("Section %s too small for offset and size tables\n"),
6378 printf (_(" Offset table\n"));
6379 printf (" slot %-16s ",
6380 is_tu_index
? _("signature") : _("dwo_id"));
6387 tu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6393 cu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6399 for (j
= 0; j
< ncols
; j
++)
6401 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6402 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
6406 for (i
= 0; i
< nslots
; i
++)
6408 byte_get_64 (ph
, &signature_high
, &signature_low
);
6409 row
= byte_get (pi
, 4);
6413 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
6414 prow
= poffsets
+ (row
- 1) * ncols
* 4;
6416 printf (_(" [%3d] 0x%s"),
6417 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6418 buf
, sizeof (buf
)));
6419 for (j
= 0; j
< ncols
; j
++)
6421 val
= byte_get (prow
+ j
* 4, 4);
6423 printf (" %8d", val
);
6426 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6427 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
6442 printf (_(" Size table\n"));
6443 printf (" slot %-16s ",
6444 is_tu_index
? _("signature") : _("dwo_id"));
6446 for (j
= 0; j
< ncols
; j
++)
6448 val
= byte_get (ppool
+ j
* 4, 4);
6450 printf (" %8s", get_DW_SECT_short_name (val
));
6454 for (i
= 0; i
< nslots
; i
++)
6456 byte_get_64 (ph
, &signature_high
, &signature_low
);
6457 row
= byte_get (pi
, 4);
6460 prow
= psizes
+ (row
- 1) * ncols
* 4;
6462 printf (_(" [%3d] 0x%s"),
6463 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6464 buf
, sizeof (buf
)));
6465 for (j
= 0; j
< ncols
; j
++)
6467 val
= byte_get (prow
+ j
* 4, 4);
6469 printf (" %8d", val
);
6472 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6473 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
6483 else if (do_display
)
6484 printf (_(" Unsupported version\n"));
6492 /* Load the CU and TU indexes if present. This will build a list of
6493 section sets that we can use to associate a .debug_info.dwo section
6494 with its associated .debug_abbrev.dwo section in a .dwp file. */
6497 load_cu_tu_indexes (void *file
)
6499 /* If we have already loaded (or tried to load) the CU and TU indexes
6500 then do not bother to repeat the task. */
6501 if (cu_tu_indexes_read
)
6504 if (load_debug_section (dwp_cu_index
, file
))
6505 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
6507 if (load_debug_section (dwp_tu_index
, file
))
6508 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
6510 cu_tu_indexes_read
= 1;
6513 /* Find the set of sections that includes section SHNDX. */
6516 find_cu_tu_set (void *file
, unsigned int shndx
)
6520 load_cu_tu_indexes (file
);
6522 /* Find SHNDX in the shndx pool. */
6523 for (i
= 0; i
< shndx_pool_used
; i
++)
6524 if (shndx_pool
[i
] == shndx
)
6527 if (i
>= shndx_pool_used
)
6530 /* Now backup to find the first entry in the set. */
6531 while (i
> 0 && shndx_pool
[i
- 1] != 0)
6534 return shndx_pool
+ i
;
6537 /* Display a .debug_cu_index or .debug_tu_index section. */
6540 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
6542 return process_cu_tu_index (section
, 1);
6546 display_debug_not_supported (struct dwarf_section
*section
,
6547 void *file ATTRIBUTE_UNUSED
)
6549 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6556 cmalloc (size_t nmemb
, size_t size
)
6558 /* Check for overflow. */
6559 if (nmemb
>= ~(size_t) 0 / size
)
6562 return malloc (nmemb
* size
);
6566 xcmalloc (size_t nmemb
, size_t size
)
6568 /* Check for overflow. */
6569 if (nmemb
>= ~(size_t) 0 / size
)
6572 return xmalloc (nmemb
* size
);
6576 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
6578 /* Check for overflow. */
6579 if (nmemb
>= ~(size_t) 0 / size
)
6582 return xrealloc (ptr
, nmemb
* size
);
6586 free_debug_memory (void)
6592 for (i
= 0; i
< max
; i
++)
6593 free_debug_section ((enum dwarf_section_display_enum
) i
);
6595 if (debug_information
!= NULL
)
6597 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
6599 for (i
= 0; i
< num_debug_info_entries
; i
++)
6601 if (!debug_information
[i
].max_loc_offsets
)
6603 free (debug_information
[i
].loc_offsets
);
6604 free (debug_information
[i
].have_frame_base
);
6606 if (!debug_information
[i
].max_range_lists
)
6607 free (debug_information
[i
].range_lists
);
6611 free (debug_information
);
6612 debug_information
= NULL
;
6613 num_debug_info_entries
= 0;
6618 dwarf_select_sections_by_names (const char *names
)
6622 const char * option
;
6626 debug_dump_long_opts
;
6628 static const debug_dump_long_opts opts_table
[] =
6630 /* Please keep this table alpha- sorted. */
6631 { "Ranges", & do_debug_ranges
, 1 },
6632 { "abbrev", & do_debug_abbrevs
, 1 },
6633 { "addr", & do_debug_addr
, 1 },
6634 { "aranges", & do_debug_aranges
, 1 },
6635 { "cu_index", & do_debug_cu_index
, 1 },
6636 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
6637 { "frames", & do_debug_frames
, 1 },
6638 { "frames-interp", & do_debug_frames_interp
, 1 },
6639 /* The special .gdb_index section. */
6640 { "gdb_index", & do_gdb_index
, 1 },
6641 { "info", & do_debug_info
, 1 },
6642 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
6643 { "loc", & do_debug_loc
, 1 },
6644 { "macro", & do_debug_macinfo
, 1 },
6645 { "pubnames", & do_debug_pubnames
, 1 },
6646 { "pubtypes", & do_debug_pubtypes
, 1 },
6647 /* This entry is for compatability
6648 with earlier versions of readelf. */
6649 { "ranges", & do_debug_aranges
, 1 },
6650 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
6651 { "str", & do_debug_str
, 1 },
6652 /* These trace_* sections are used by Itanium VMS. */
6653 { "trace_abbrev", & do_trace_abbrevs
, 1 },
6654 { "trace_aranges", & do_trace_aranges
, 1 },
6655 { "trace_info", & do_trace_info
, 1 },
6664 const debug_dump_long_opts
* entry
;
6666 for (entry
= opts_table
; entry
->option
; entry
++)
6668 size_t len
= strlen (entry
->option
);
6670 if (strncmp (p
, entry
->option
, len
) == 0
6671 && (p
[len
] == ',' || p
[len
] == '\0'))
6673 * entry
->variable
|= entry
->val
;
6675 /* The --debug-dump=frames-interp option also
6676 enables the --debug-dump=frames option. */
6677 if (do_debug_frames_interp
)
6678 do_debug_frames
= 1;
6685 if (entry
->option
== NULL
)
6687 warn (_("Unrecognized debug option '%s'\n"), p
);
6688 p
= strchr (p
, ',');
6699 dwarf_select_sections_by_letters (const char *letters
)
6701 unsigned int lindex
= 0;
6703 while (letters
[lindex
])
6704 switch (letters
[lindex
++])
6711 do_debug_abbrevs
= 1;
6715 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
6719 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
6723 do_debug_pubnames
= 1;
6727 do_debug_pubtypes
= 1;
6731 do_debug_aranges
= 1;
6735 do_debug_ranges
= 1;
6739 do_debug_frames_interp
= 1;
6741 do_debug_frames
= 1;
6745 do_debug_macinfo
= 1;
6757 warn (_("Unrecognized debug option '%s'\n"), optarg
);
6763 dwarf_select_sections_all (void)
6766 do_debug_abbrevs
= 1;
6767 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
6768 do_debug_pubnames
= 1;
6769 do_debug_pubtypes
= 1;
6770 do_debug_aranges
= 1;
6771 do_debug_ranges
= 1;
6772 do_debug_frames
= 1;
6773 do_debug_macinfo
= 1;
6778 do_trace_abbrevs
= 1;
6779 do_trace_aranges
= 1;
6781 do_debug_cu_index
= 1;
6784 struct dwarf_section_display debug_displays
[] =
6786 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0 },
6787 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
6788 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0 },
6789 display_debug_aranges
, &do_debug_aranges
, 1 },
6790 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0 },
6791 display_debug_frames
, &do_debug_frames
, 1 },
6792 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
},
6793 display_debug_info
, &do_debug_info
, 1 },
6794 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0 },
6795 display_debug_lines
, &do_debug_lines
, 1 },
6796 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0 },
6797 display_debug_pubnames
, &do_debug_pubnames
, 0 },
6798 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0 },
6799 display_debug_frames
, &do_debug_frames
, 1 },
6800 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0 },
6801 display_debug_macinfo
, &do_debug_macinfo
, 0 },
6802 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0 },
6803 display_debug_macro
, &do_debug_macinfo
, 1 },
6804 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0 },
6805 display_debug_str
, &do_debug_str
, 0 },
6806 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0 },
6807 display_debug_loc
, &do_debug_loc
, 1 },
6808 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0 },
6809 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
6810 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0 },
6811 display_debug_ranges
, &do_debug_ranges
, 1 },
6812 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0 },
6813 display_debug_not_supported
, NULL
, 0 },
6814 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0 },
6815 display_debug_not_supported
, NULL
, 0 },
6816 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
},
6817 display_debug_types
, &do_debug_info
, 1 },
6818 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0 },
6819 display_debug_not_supported
, NULL
, 0 },
6820 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0 },
6821 display_gdb_index
, &do_gdb_index
, 0 },
6822 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
},
6823 display_trace_info
, &do_trace_info
, 1 },
6824 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0 },
6825 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
6826 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0 },
6827 display_debug_aranges
, &do_trace_aranges
, 0 },
6828 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
6829 display_debug_info
, &do_debug_info
, 1 },
6830 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0 },
6831 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
6832 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
6833 display_debug_types
, &do_debug_info
, 1 },
6834 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0 },
6835 display_debug_lines
, &do_debug_lines
, 1 },
6836 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0 },
6837 display_debug_loc
, &do_debug_loc
, 1 },
6838 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0 },
6839 display_debug_macro
, &do_debug_macinfo
, 1 },
6840 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0 },
6841 display_debug_macinfo
, &do_debug_macinfo
, 0 },
6842 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0 },
6843 display_debug_str
, &do_debug_str
, 1 },
6844 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0 },
6845 display_debug_str_offsets
, NULL
, 0 },
6846 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0 },
6847 display_debug_str_offsets
, NULL
, 0 },
6848 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0 },
6849 display_debug_addr
, &do_debug_addr
, 1 },
6850 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0 },
6851 display_cu_index
, &do_debug_cu_index
, 0 },
6852 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0 },
6853 display_cu_index
, &do_debug_cu_index
, 0 },