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 /* Print a dwarf_vma value (typically an address, offset or length) in
143 hexadecimal format, followed by a space. The length of the value (and
144 hence the precision displayed) is determined by the byte_size parameter. */
147 print_dwarf_vma (dwarf_vma val
, unsigned byte_size
)
149 static char buff
[18];
152 /* Printf does not have a way of specifiying a maximum field width for an
153 integer value, so we print the full value into a buffer and then select
154 the precision we need. */
155 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
157 snprintf (buff
, sizeof (buff
), "%16.16llx ", val
);
159 snprintf (buff
, sizeof (buff
), "%016I64x ", val
);
162 snprintf (buff
, sizeof (buff
), "%16.16lx ", val
);
167 if (byte_size
> 0 && byte_size
<= 8)
168 offset
= 16 - 2 * byte_size
;
170 error (_("Wrong size in print_dwarf_vma"));
173 fputs (buff
+ offset
, stdout
);
176 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
178 #define DWARF_VMA_FMT "ll"
180 #define DWARF_VMA_FMT "I64"
183 #define DWARF_VMA_FMT "l"
187 dwarf_vmatoa (const char *fmtch
, dwarf_vma value
)
189 /* As dwarf_vmatoa is used more then once in a printf call
190 for output, we are cycling through an fixed array of pointers
191 for return address. */
192 static int buf_pos
= 0;
193 static struct dwarf_vmatoa_buf
200 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
202 ret
= buf
[buf_pos
++].place
;
203 buf_pos
%= ARRAY_SIZE (buf
);
205 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
210 /* Format a 64-bit value, given as two 32-bit values, in hex.
211 For reentrancy, this uses a buffer provided by the caller. */
214 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
215 unsigned int buf_len
)
220 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
223 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
224 snprintf (buf
+ len
, buf_len
- len
,
225 "%08" DWARF_VMA_FMT
"x", lvalue
);
231 /* Read in a LEB128 encoded value starting at address DATA.
232 If SIGN is true, return a signed LEB128 value.
233 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
234 No bytes will be read at address END or beyond. */
237 read_leb128 (unsigned char *data
,
238 unsigned int *length_return
,
240 const unsigned char * const end
)
242 dwarf_vma result
= 0;
243 unsigned int num_read
= 0;
244 unsigned int shift
= 0;
245 unsigned char byte
= 0;
252 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
255 if ((byte
& 0x80) == 0)
259 if (length_return
!= NULL
)
260 *length_return
= num_read
;
262 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
263 result
|= -1L << shift
;
268 /* Create a signed version to avoid painful typecasts. */
269 static inline dwarf_signed_vma
270 read_sleb128 (unsigned char * data
,
271 unsigned int * length_return
,
272 const unsigned char * const end
)
274 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
277 static inline dwarf_vma
278 read_uleb128 (unsigned char * data
,
279 unsigned int * length_return
,
280 const unsigned char * const end
)
282 return read_leb128 (data
, length_return
, FALSE
, end
);
285 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
288 unsigned int amount = (AMOUNT); \
289 if (((PTR) + amount) >= (END)) \
292 amount = (END) - (PTR); \
297 VAL = byte_get ((PTR), amount); \
303 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
306 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
311 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
314 unsigned int amount = (AMOUNT); \
315 if (((PTR) + amount) >= (END)) \
318 amount = (END) - (PTR); \
323 VAL = byte_get_signed ((PTR), amount); \
329 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
332 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
337 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
340 if (((PTR) + 8) < (END)) \
342 byte_get_64 ((PTR), (HIGH), (LOW)); \
347 * (LOW) = * (HIGH) = 0; \
352 typedef struct State_Machine_Registers
360 unsigned char op_index
;
361 unsigned char end_sequence
;
362 /* This variable hold the number of the last entry seen
363 in the File Table. */
364 unsigned int last_file_entry
;
367 static SMR state_machine_regs
;
370 reset_state_machine (int is_stmt
)
372 state_machine_regs
.address
= 0;
373 state_machine_regs
.op_index
= 0;
374 state_machine_regs
.file
= 1;
375 state_machine_regs
.line
= 1;
376 state_machine_regs
.column
= 0;
377 state_machine_regs
.is_stmt
= is_stmt
;
378 state_machine_regs
.basic_block
= 0;
379 state_machine_regs
.end_sequence
= 0;
380 state_machine_regs
.last_file_entry
= 0;
383 /* Handled an extend line op.
384 Returns the number of bytes read. */
387 process_extended_line_op (unsigned char * data
,
391 unsigned char op_code
;
392 unsigned int bytes_read
;
395 unsigned char *orig_data
= data
;
398 len
= read_uleb128 (data
, & bytes_read
, end
);
401 if (len
== 0 || data
== end
)
403 warn (_("badly formed extended line op encountered!\n"));
410 printf (_(" Extended opcode %d: "), op_code
);
414 case DW_LNE_end_sequence
:
415 printf (_("End of Sequence\n\n"));
416 reset_state_machine (is_stmt
);
419 case DW_LNE_set_address
:
420 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
421 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
422 state_machine_regs
.address
= adr
;
423 state_machine_regs
.op_index
= 0;
426 case DW_LNE_define_file
:
427 printf (_("define new File Table entry\n"));
428 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
429 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
432 data
+= strnlen ((char *) data
, end
- data
) + 1;
433 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
435 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
437 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
439 printf ("%s\n\n", name
);
441 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
442 warn (_("DW_LNE_define_file: Bad opcode length\n"));
445 case DW_LNE_set_discriminator
:
446 printf (_("set Discriminator to %s\n"),
447 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
451 case DW_LNE_HP_negate_is_UV_update
:
452 printf ("DW_LNE_HP_negate_is_UV_update\n");
454 case DW_LNE_HP_push_context
:
455 printf ("DW_LNE_HP_push_context\n");
457 case DW_LNE_HP_pop_context
:
458 printf ("DW_LNE_HP_pop_context\n");
460 case DW_LNE_HP_set_file_line_column
:
461 printf ("DW_LNE_HP_set_file_line_column\n");
463 case DW_LNE_HP_set_routine_name
:
464 printf ("DW_LNE_HP_set_routine_name\n");
466 case DW_LNE_HP_set_sequence
:
467 printf ("DW_LNE_HP_set_sequence\n");
469 case DW_LNE_HP_negate_post_semantics
:
470 printf ("DW_LNE_HP_negate_post_semantics\n");
472 case DW_LNE_HP_negate_function_exit
:
473 printf ("DW_LNE_HP_negate_function_exit\n");
475 case DW_LNE_HP_negate_front_end_logical
:
476 printf ("DW_LNE_HP_negate_front_end_logical\n");
478 case DW_LNE_HP_define_proc
:
479 printf ("DW_LNE_HP_define_proc\n");
481 case DW_LNE_HP_source_file_correlation
:
483 unsigned char *edata
= data
+ len
- bytes_read
- 1;
485 printf ("DW_LNE_HP_source_file_correlation\n");
491 opc
= read_uleb128 (data
, & bytes_read
, edata
);
496 case DW_LNE_HP_SFC_formfeed
:
497 printf (" DW_LNE_HP_SFC_formfeed\n");
499 case DW_LNE_HP_SFC_set_listing_line
:
500 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
502 read_uleb128 (data
, & bytes_read
, edata
)));
505 case DW_LNE_HP_SFC_associate
:
506 printf (" DW_LNE_HP_SFC_associate ");
509 read_uleb128 (data
, & bytes_read
, edata
)));
513 read_uleb128 (data
, & bytes_read
, edata
)));
517 read_uleb128 (data
, & bytes_read
, edata
)));
521 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
531 unsigned int rlen
= len
- bytes_read
- 1;
533 if (op_code
>= DW_LNE_lo_user
534 /* The test against DW_LNW_hi_user is redundant due to
535 the limited range of the unsigned char data type used
537 /*&& op_code <= DW_LNE_hi_user*/)
538 printf (_("user defined: "));
540 printf (_("UNKNOWN: "));
541 printf (_("length %d ["), rlen
);
543 printf (" %02x", *data
++);
552 static const unsigned char *
553 fetch_indirect_string (dwarf_vma offset
)
555 struct dwarf_section
*section
= &debug_displays
[str
].section
;
557 if (section
->start
== NULL
)
558 return (const unsigned char *) _("<no .debug_str section>");
560 /* DWARF sections under Mach-O have non-zero addresses. */
561 offset
-= section
->address
;
562 if (offset
> section
->size
)
564 warn (_("DW_FORM_strp offset too big: %s\n"),
565 dwarf_vmatoa ("x", offset
));
566 return (const unsigned char *) _("<offset is too big>");
569 return (const unsigned char *) section
->start
+ offset
;
573 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
574 dwarf_vma offset_size
, int dwo
)
576 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
577 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
578 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
579 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
580 dwarf_vma index_offset
= idx
* offset_size
;
581 dwarf_vma str_offset
;
583 if (index_section
->start
== NULL
)
584 return (dwo
? _("<no .debug_str_offsets.dwo section>")
585 : _("<no .debug_str_offsets section>"));
587 /* DWARF sections under Mach-O have non-zero addresses. */
588 index_offset
-= index_section
->address
;
589 if (this_set
!= NULL
)
590 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
591 if (index_offset
> index_section
->size
)
593 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
594 dwarf_vmatoa ("x", index_offset
));
595 return _("<index offset is too big>");
598 if (str_section
->start
== NULL
)
599 return (dwo
? _("<no .debug_str.dwo section>")
600 : _("<no .debug_str section>"));
602 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
603 str_offset
-= str_section
->address
;
604 if (str_offset
> str_section
->size
)
606 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
607 dwarf_vmatoa ("x", str_offset
));
608 return _("<indirect index offset is too big>");
611 return (const char *) str_section
->start
+ str_offset
;
615 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
617 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
619 if (section
->start
== NULL
)
620 return (_("<no .debug_addr section>"));
622 if (offset
+ bytes
> section
->size
)
624 warn (_("Offset into section %s too big: %s\n"),
625 section
->name
, dwarf_vmatoa ("x", offset
));
626 return "<offset too big>";
629 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
633 /* FIXME: There are better and more efficient ways to handle
634 these structures. For now though, I just want something that
635 is simple to implement. */
636 typedef struct abbrev_attr
638 unsigned long attribute
;
640 struct abbrev_attr
*next
;
644 typedef struct abbrev_entry
649 struct abbrev_attr
*first_attr
;
650 struct abbrev_attr
*last_attr
;
651 struct abbrev_entry
*next
;
655 static abbrev_entry
*first_abbrev
= NULL
;
656 static abbrev_entry
*last_abbrev
= NULL
;
663 for (abbrv
= first_abbrev
; abbrv
;)
665 abbrev_entry
*next_abbrev
= abbrv
->next
;
668 for (attr
= abbrv
->first_attr
; attr
;)
670 abbrev_attr
*next_attr
= attr
->next
;
680 last_abbrev
= first_abbrev
= NULL
;
684 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
688 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
693 entry
->entry
= number
;
695 entry
->children
= children
;
696 entry
->first_attr
= NULL
;
697 entry
->last_attr
= NULL
;
700 if (first_abbrev
== NULL
)
701 first_abbrev
= entry
;
703 last_abbrev
->next
= entry
;
709 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
713 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
718 attr
->attribute
= attribute
;
722 if (last_abbrev
->first_attr
== NULL
)
723 last_abbrev
->first_attr
= attr
;
725 last_abbrev
->last_attr
->next
= attr
;
727 last_abbrev
->last_attr
= attr
;
730 /* Processes the (partial) contents of a .debug_abbrev section.
731 Returns NULL if the end of the section was encountered.
732 Returns the address after the last byte read if the end of
733 an abbreviation set was found. */
735 static unsigned char *
736 process_abbrev_section (unsigned char *start
, unsigned char *end
)
738 if (first_abbrev
!= NULL
)
743 unsigned int bytes_read
;
746 unsigned long attribute
;
749 entry
= read_uleb128 (start
, & bytes_read
, end
);
752 /* A single zero is supposed to end the section according
753 to the standard. If there's more, then signal that to
760 tag
= read_uleb128 (start
, & bytes_read
, end
);
767 add_abbrev (entry
, tag
, children
);
773 attribute
= read_uleb128 (start
, & bytes_read
, end
);
778 form
= read_uleb128 (start
, & bytes_read
, end
);
783 add_abbrev_attr (attribute
, form
);
785 while (attribute
!= 0);
788 /* Report the missing single zero which ends the section. */
789 error (_(".debug_abbrev section not zero terminated\n"));
795 get_TAG_name (unsigned long tag
)
797 const char *name
= get_DW_TAG_name ((unsigned int)tag
);
801 static char buffer
[100];
803 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
811 get_FORM_name (unsigned long form
)
816 return "DW_FORM value: 0";
818 name
= get_DW_FORM_name (form
);
821 static char buffer
[100];
823 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
830 static unsigned char *
831 display_block (unsigned char *data
,
833 const unsigned char * const end
)
837 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length
));
839 maxlen
= (dwarf_vma
) (end
- data
);
840 length
= length
> maxlen
? maxlen
: length
;
843 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
849 decode_location_expression (unsigned char * data
,
850 unsigned int pointer_size
,
851 unsigned int offset_size
,
855 struct dwarf_section
* section
)
858 unsigned int bytes_read
;
860 dwarf_signed_vma svalue
;
861 unsigned char *end
= data
+ length
;
862 int need_frame_base
= 0;
871 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
872 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
875 printf ("DW_OP_deref");
878 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
879 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
882 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
883 printf ("DW_OP_const1s: %ld", (long) svalue
);
886 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
887 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
890 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
891 printf ("DW_OP_const2s: %ld", (long) svalue
);
894 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
895 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
898 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
899 printf ("DW_OP_const4s: %ld", (long) svalue
);
902 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
903 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
904 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
905 printf ("%lu", (unsigned long) uvalue
);
908 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
909 printf ("DW_OP_const8s: %ld ", (long) svalue
);
910 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
911 printf ("%ld", (long) svalue
);
914 printf ("DW_OP_constu: %s",
915 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
919 printf ("DW_OP_consts: %s",
920 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
924 printf ("DW_OP_dup");
927 printf ("DW_OP_drop");
930 printf ("DW_OP_over");
933 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
934 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
937 printf ("DW_OP_swap");
940 printf ("DW_OP_rot");
943 printf ("DW_OP_xderef");
946 printf ("DW_OP_abs");
949 printf ("DW_OP_and");
952 printf ("DW_OP_div");
955 printf ("DW_OP_minus");
958 printf ("DW_OP_mod");
961 printf ("DW_OP_mul");
964 printf ("DW_OP_neg");
967 printf ("DW_OP_not");
973 printf ("DW_OP_plus");
975 case DW_OP_plus_uconst
:
976 printf ("DW_OP_plus_uconst: %s",
977 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
981 printf ("DW_OP_shl");
984 printf ("DW_OP_shr");
987 printf ("DW_OP_shra");
990 printf ("DW_OP_xor");
993 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
994 printf ("DW_OP_bra: %ld", (long) svalue
);
1000 printf ("DW_OP_ge");
1003 printf ("DW_OP_gt");
1006 printf ("DW_OP_le");
1009 printf ("DW_OP_lt");
1012 printf ("DW_OP_ne");
1015 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1016 printf ("DW_OP_skip: %ld", (long) svalue
);
1051 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1086 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1087 regname (op
- DW_OP_reg0
, 1));
1122 printf ("DW_OP_breg%d (%s): %s",
1124 regname (op
- DW_OP_breg0
, 1),
1125 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1130 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1132 printf ("DW_OP_regx: %s (%s)",
1133 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1136 need_frame_base
= 1;
1137 printf ("DW_OP_fbreg: %s",
1138 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1142 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1144 printf ("DW_OP_bregx: %s (%s) %s",
1145 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1146 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1150 printf ("DW_OP_piece: %s",
1151 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1154 case DW_OP_deref_size
:
1155 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1156 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1158 case DW_OP_xderef_size
:
1159 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1160 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1163 printf ("DW_OP_nop");
1166 /* DWARF 3 extensions. */
1167 case DW_OP_push_object_address
:
1168 printf ("DW_OP_push_object_address");
1171 /* XXX: Strictly speaking for 64-bit DWARF3 files
1172 this ought to be an 8-byte wide computation. */
1173 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1174 printf ("DW_OP_call2: <0x%s>",
1175 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1178 /* XXX: Strictly speaking for 64-bit DWARF3 files
1179 this ought to be an 8-byte wide computation. */
1180 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1181 printf ("DW_OP_call4: <0x%s>",
1182 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1184 case DW_OP_call_ref
:
1185 /* XXX: Strictly speaking for 64-bit DWARF3 files
1186 this ought to be an 8-byte wide computation. */
1187 if (dwarf_version
== -1)
1189 printf (_("(DW_OP_call_ref in frame info)"));
1190 /* No way to tell where the next op is, so just bail. */
1191 return need_frame_base
;
1193 if (dwarf_version
== 2)
1195 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1199 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1201 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1203 case DW_OP_form_tls_address
:
1204 printf ("DW_OP_form_tls_address");
1206 case DW_OP_call_frame_cfa
:
1207 printf ("DW_OP_call_frame_cfa");
1209 case DW_OP_bit_piece
:
1210 printf ("DW_OP_bit_piece: ");
1211 printf (_("size: %s "),
1212 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1214 printf (_("offset: %s "),
1215 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1219 /* DWARF 4 extensions. */
1220 case DW_OP_stack_value
:
1221 printf ("DW_OP_stack_value");
1224 case DW_OP_implicit_value
:
1225 printf ("DW_OP_implicit_value");
1226 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1228 display_block (data
, uvalue
, end
);
1232 /* GNU extensions. */
1233 case DW_OP_GNU_push_tls_address
:
1234 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1236 case DW_OP_GNU_uninit
:
1237 printf ("DW_OP_GNU_uninit");
1238 /* FIXME: Is there data associated with this OP ? */
1240 case DW_OP_GNU_encoded_addr
:
1246 addr
= get_encoded_value (data
, encoding
, section
);
1247 data
+= size_of_encoded_value (encoding
);
1249 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1250 print_dwarf_vma (addr
, pointer_size
);
1253 case DW_OP_GNU_implicit_pointer
:
1254 /* XXX: Strictly speaking for 64-bit DWARF3 files
1255 this ought to be an 8-byte wide computation. */
1256 if (dwarf_version
== -1)
1258 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1259 /* No way to tell where the next op is, so just bail. */
1260 return need_frame_base
;
1262 if (dwarf_version
== 2)
1264 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1268 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1270 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1271 dwarf_vmatoa ("x", uvalue
),
1272 dwarf_vmatoa ("d", read_sleb128 (data
,
1273 &bytes_read
, end
)));
1276 case DW_OP_GNU_entry_value
:
1277 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1279 printf ("DW_OP_GNU_entry_value: (");
1280 if (decode_location_expression (data
, pointer_size
, offset_size
,
1281 dwarf_version
, uvalue
,
1282 cu_offset
, section
))
1283 need_frame_base
= 1;
1287 case DW_OP_GNU_const_type
:
1288 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1290 printf ("DW_OP_GNU_const_type: <0x%s> ",
1291 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1292 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1293 display_block (data
, uvalue
, end
);
1296 case DW_OP_GNU_regval_type
:
1297 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1299 printf ("DW_OP_GNU_regval_type: %s (%s)",
1300 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1301 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1303 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1305 case DW_OP_GNU_deref_type
:
1306 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1307 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue
);
1308 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1310 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1312 case DW_OP_GNU_convert
:
1313 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1315 printf ("DW_OP_GNU_convert <0x%s>",
1316 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1318 case DW_OP_GNU_reinterpret
:
1319 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1321 printf ("DW_OP_GNU_reinterpret <0x%s>",
1322 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1324 case DW_OP_GNU_parameter_ref
:
1325 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1326 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1327 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1329 case DW_OP_GNU_addr_index
:
1330 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1332 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1334 case DW_OP_GNU_const_index
:
1335 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1337 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1340 /* HP extensions. */
1341 case DW_OP_HP_is_value
:
1342 printf ("DW_OP_HP_is_value");
1343 /* FIXME: Is there data associated with this OP ? */
1345 case DW_OP_HP_fltconst4
:
1346 printf ("DW_OP_HP_fltconst4");
1347 /* FIXME: Is there data associated with this OP ? */
1349 case DW_OP_HP_fltconst8
:
1350 printf ("DW_OP_HP_fltconst8");
1351 /* FIXME: Is there data associated with this OP ? */
1353 case DW_OP_HP_mod_range
:
1354 printf ("DW_OP_HP_mod_range");
1355 /* FIXME: Is there data associated with this OP ? */
1357 case DW_OP_HP_unmod_range
:
1358 printf ("DW_OP_HP_unmod_range");
1359 /* FIXME: Is there data associated with this OP ? */
1362 printf ("DW_OP_HP_tls");
1363 /* FIXME: Is there data associated with this OP ? */
1366 /* PGI (STMicroelectronics) extensions. */
1367 case DW_OP_PGI_omp_thread_num
:
1368 /* Pushes the thread number for the current thread as it would be
1369 returned by the standard OpenMP library function:
1370 omp_get_thread_num(). The "current thread" is the thread for
1371 which the expression is being evaluated. */
1372 printf ("DW_OP_PGI_omp_thread_num");
1376 if (op
>= DW_OP_lo_user
1377 && op
<= DW_OP_hi_user
)
1378 printf (_("(User defined location op)"));
1380 printf (_("(Unknown location op)"));
1381 /* No way to tell where the next op is, so just bail. */
1382 return need_frame_base
;
1385 /* Separate the ops. */
1390 return need_frame_base
;
1393 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1394 This is used for DWARF package files. */
1396 static struct cu_tu_set
*
1397 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1399 struct cu_tu_set
*p
;
1401 unsigned int dw_sect
;
1407 dw_sect
= DW_SECT_TYPES
;
1413 dw_sect
= DW_SECT_INFO
;
1417 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1425 static unsigned char *
1426 read_and_display_attr_value (unsigned long attribute
,
1428 unsigned char * data
,
1429 unsigned char * end
,
1430 dwarf_vma cu_offset
,
1431 dwarf_vma pointer_size
,
1432 dwarf_vma offset_size
,
1434 debug_info
* debug_info_p
,
1436 struct dwarf_section
* section
,
1437 struct cu_tu_set
* this_set
)
1439 dwarf_vma uvalue
= 0;
1440 unsigned char *block_start
= NULL
;
1441 unsigned char * orig_data
= data
;
1442 unsigned int bytes_read
;
1446 warn (_("corrupt attribute\n"));
1455 case DW_FORM_ref_addr
:
1456 if (dwarf_version
== 2)
1457 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1458 else if (dwarf_version
== 3 || dwarf_version
== 4)
1459 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1461 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1466 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1470 case DW_FORM_sec_offset
:
1471 case DW_FORM_GNU_ref_alt
:
1472 case DW_FORM_GNU_strp_alt
:
1473 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1476 case DW_FORM_flag_present
:
1483 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1488 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1493 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1497 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1501 case DW_FORM_GNU_str_index
:
1502 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1506 case DW_FORM_ref_udata
:
1508 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1512 case DW_FORM_indirect
:
1513 form
= read_uleb128 (data
, & bytes_read
, end
);
1516 printf (" %s", get_FORM_name (form
));
1517 return read_and_display_attr_value (attribute
, form
, data
, end
,
1518 cu_offset
, pointer_size
,
1519 offset_size
, dwarf_version
,
1520 debug_info_p
, do_loc
,
1522 case DW_FORM_GNU_addr_index
:
1523 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1530 case DW_FORM_ref_addr
:
1532 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue
));
1535 case DW_FORM_GNU_ref_alt
:
1537 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue
));
1543 case DW_FORM_ref_udata
:
1545 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1550 case DW_FORM_sec_offset
:
1552 printf (" 0x%s", dwarf_vmatoa ("x", uvalue
));
1555 case DW_FORM_flag_present
:
1562 printf (" %s", dwarf_vmatoa ("d", uvalue
));
1569 dwarf_vma high_bits
;
1572 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1575 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
1578 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1579 && num_debug_info_entries
== 0)
1581 if (sizeof (uvalue
) == 8)
1582 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1584 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1590 case DW_FORM_string
:
1592 printf (" %.*s", (int) (end
- data
), data
);
1593 data
+= strnlen ((char *) data
, end
- data
) + 1;
1597 case DW_FORM_exprloc
:
1598 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1599 block_start
= data
+ bytes_read
;
1601 data
= block_start
+ uvalue
;
1603 data
= display_block (block_start
, uvalue
, end
);
1606 case DW_FORM_block1
:
1607 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1608 block_start
= data
+ 1;
1610 data
= block_start
+ uvalue
;
1612 data
= display_block (block_start
, uvalue
, end
);
1615 case DW_FORM_block2
:
1616 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1617 block_start
= data
+ 2;
1619 data
= block_start
+ uvalue
;
1621 data
= display_block (block_start
, uvalue
, end
);
1624 case DW_FORM_block4
:
1625 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1626 block_start
= data
+ 4;
1628 data
= block_start
+ uvalue
;
1630 data
= display_block (block_start
, uvalue
, end
);
1635 printf (_(" (indirect string, offset: 0x%s): %s"),
1636 dwarf_vmatoa ("x", uvalue
),
1637 fetch_indirect_string (uvalue
));
1640 case DW_FORM_GNU_str_index
:
1643 const char *suffix
= strrchr (section
->name
, '.');
1644 int dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? 1 : 0;
1646 printf (_(" (indexed string: 0x%s): %s"),
1647 dwarf_vmatoa ("x", uvalue
),
1648 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
1652 case DW_FORM_GNU_strp_alt
:
1654 printf (_(" (alt indirect string, offset: 0x%s)"),
1655 dwarf_vmatoa ("x", uvalue
));
1658 case DW_FORM_indirect
:
1659 /* Handled above. */
1662 case DW_FORM_ref_sig8
:
1665 dwarf_vma high_bits
;
1668 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1669 printf (" signature: 0x%s",
1670 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
1675 case DW_FORM_GNU_addr_index
:
1677 printf (_(" (addr_index: 0x%s): %s"),
1678 dwarf_vmatoa ("x", uvalue
),
1679 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
1683 warn (_("Unrecognized form: %lu\n"), form
);
1687 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1688 && num_debug_info_entries
== 0
1689 && debug_info_p
!= NULL
)
1693 case DW_AT_frame_base
:
1694 have_frame_base
= 1;
1695 case DW_AT_location
:
1696 case DW_AT_string_length
:
1697 case DW_AT_return_addr
:
1698 case DW_AT_data_member_location
:
1699 case DW_AT_vtable_elem_location
:
1701 case DW_AT_static_link
:
1702 case DW_AT_use_location
:
1703 case DW_AT_GNU_call_site_value
:
1704 case DW_AT_GNU_call_site_data_value
:
1705 case DW_AT_GNU_call_site_target
:
1706 case DW_AT_GNU_call_site_target_clobbered
:
1707 if ((dwarf_version
< 4
1708 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1709 || form
== DW_FORM_sec_offset
)
1711 /* Process location list. */
1712 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1713 unsigned int num
= debug_info_p
->num_loc_offsets
;
1715 if (lmax
== 0 || num
>= lmax
)
1718 debug_info_p
->loc_offsets
= (dwarf_vma
*)
1719 xcrealloc (debug_info_p
->loc_offsets
,
1720 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1721 debug_info_p
->have_frame_base
= (int *)
1722 xcrealloc (debug_info_p
->have_frame_base
,
1723 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1724 debug_info_p
->max_loc_offsets
= lmax
;
1726 if (this_set
!= NULL
)
1727 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
1728 debug_info_p
->loc_offsets
[num
] = uvalue
;
1729 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1730 debug_info_p
->num_loc_offsets
++;
1735 if (need_base_address
)
1736 debug_info_p
->base_address
= uvalue
;
1739 case DW_AT_GNU_addr_base
:
1740 debug_info_p
->addr_base
= uvalue
;
1743 case DW_AT_GNU_ranges_base
:
1744 debug_info_p
->ranges_base
= uvalue
;
1748 if ((dwarf_version
< 4
1749 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1750 || form
== DW_FORM_sec_offset
)
1752 /* Process range list. */
1753 unsigned int lmax
= debug_info_p
->max_range_lists
;
1754 unsigned int num
= debug_info_p
->num_range_lists
;
1756 if (lmax
== 0 || num
>= lmax
)
1759 debug_info_p
->range_lists
= (dwarf_vma
*)
1760 xcrealloc (debug_info_p
->range_lists
,
1761 lmax
, sizeof (*debug_info_p
->range_lists
));
1762 debug_info_p
->max_range_lists
= lmax
;
1764 debug_info_p
->range_lists
[num
] = uvalue
;
1765 debug_info_p
->num_range_lists
++;
1774 if (do_loc
|| attribute
== 0)
1777 /* For some attributes we can display further information. */
1785 case DW_INL_not_inlined
:
1786 printf (_("(not inlined)"));
1788 case DW_INL_inlined
:
1789 printf (_("(inlined)"));
1791 case DW_INL_declared_not_inlined
:
1792 printf (_("(declared as inline but ignored)"));
1794 case DW_INL_declared_inlined
:
1795 printf (_("(declared as inline and inlined)"));
1798 printf (_(" (Unknown inline attribute value: %s)"),
1799 dwarf_vmatoa ("x", uvalue
));
1804 case DW_AT_language
:
1807 /* Ordered by the numeric value of these constants. */
1808 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1809 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1810 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1811 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1812 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1813 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1814 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1815 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1816 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1817 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1818 /* DWARF 2.1 values. */
1819 case DW_LANG_Java
: printf ("(Java)"); break;
1820 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1821 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1822 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1823 /* DWARF 3 values. */
1824 case DW_LANG_PLI
: printf ("(PLI)"); break;
1825 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1826 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1827 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1828 case DW_LANG_D
: printf ("(D)"); break;
1829 /* DWARF 4 values. */
1830 case DW_LANG_Python
: printf ("(Python)"); break;
1831 /* DWARF 5 values. */
1832 case DW_LANG_Go
: printf ("(Go)"); break;
1833 /* MIPS extension. */
1834 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1835 /* UPC extension. */
1836 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1838 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1839 printf (_("(implementation defined: %s)"),
1840 dwarf_vmatoa ("x", uvalue
));
1842 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
1847 case DW_AT_encoding
:
1850 case DW_ATE_void
: printf ("(void)"); break;
1851 case DW_ATE_address
: printf ("(machine address)"); break;
1852 case DW_ATE_boolean
: printf ("(boolean)"); break;
1853 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1854 case DW_ATE_float
: printf ("(float)"); break;
1855 case DW_ATE_signed
: printf ("(signed)"); break;
1856 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1857 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1858 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1859 /* DWARF 2.1 values: */
1860 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1861 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1862 /* DWARF 3 values: */
1863 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1864 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1865 case DW_ATE_edited
: printf ("(edited)"); break;
1866 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1867 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1868 /* HP extensions: */
1869 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1870 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1871 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1872 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1873 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1874 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1875 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1878 if (uvalue
>= DW_ATE_lo_user
1879 && uvalue
<= DW_ATE_hi_user
)
1880 printf (_("(user defined type)"));
1882 printf (_("(unknown type)"));
1887 case DW_AT_accessibility
:
1890 case DW_ACCESS_public
: printf ("(public)"); break;
1891 case DW_ACCESS_protected
: printf ("(protected)"); break;
1892 case DW_ACCESS_private
: printf ("(private)"); break;
1894 printf (_("(unknown accessibility)"));
1899 case DW_AT_visibility
:
1902 case DW_VIS_local
: printf ("(local)"); break;
1903 case DW_VIS_exported
: printf ("(exported)"); break;
1904 case DW_VIS_qualified
: printf ("(qualified)"); break;
1905 default: printf (_("(unknown visibility)")); break;
1909 case DW_AT_virtuality
:
1912 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1913 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1914 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1915 default: printf (_("(unknown virtuality)")); break;
1919 case DW_AT_identifier_case
:
1922 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1923 case DW_ID_up_case
: printf ("(up_case)"); break;
1924 case DW_ID_down_case
: printf ("(down_case)"); break;
1925 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1926 default: printf (_("(unknown case)")); break;
1930 case DW_AT_calling_convention
:
1933 case DW_CC_normal
: printf ("(normal)"); break;
1934 case DW_CC_program
: printf ("(program)"); break;
1935 case DW_CC_nocall
: printf ("(nocall)"); break;
1937 if (uvalue
>= DW_CC_lo_user
1938 && uvalue
<= DW_CC_hi_user
)
1939 printf (_("(user defined)"));
1941 printf (_("(unknown convention)"));
1945 case DW_AT_ordering
:
1948 case -1: printf (_("(undefined)")); break;
1949 case 0: printf ("(row major)"); break;
1950 case 1: printf ("(column major)"); break;
1954 case DW_AT_frame_base
:
1955 have_frame_base
= 1;
1956 case DW_AT_location
:
1957 case DW_AT_string_length
:
1958 case DW_AT_return_addr
:
1959 case DW_AT_data_member_location
:
1960 case DW_AT_vtable_elem_location
:
1962 case DW_AT_static_link
:
1963 case DW_AT_use_location
:
1964 case DW_AT_GNU_call_site_value
:
1965 case DW_AT_GNU_call_site_data_value
:
1966 case DW_AT_GNU_call_site_target
:
1967 case DW_AT_GNU_call_site_target_clobbered
:
1968 if ((dwarf_version
< 4
1969 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1970 || form
== DW_FORM_sec_offset
)
1971 printf (_("(location list)"));
1973 case DW_AT_allocated
:
1974 case DW_AT_associated
:
1975 case DW_AT_data_location
:
1977 case DW_AT_upper_bound
:
1978 case DW_AT_lower_bound
:
1981 int need_frame_base
;
1984 need_frame_base
= decode_location_expression (block_start
,
1989 cu_offset
, section
);
1991 if (need_frame_base
&& !have_frame_base
)
1992 printf (_(" [without DW_AT_frame_base]"));
1998 if (form
== DW_FORM_ref_sig8
1999 || form
== DW_FORM_GNU_ref_alt
)
2002 if (form
== DW_FORM_ref1
2003 || form
== DW_FORM_ref2
2004 || form
== DW_FORM_ref4
2005 || form
== DW_FORM_ref_udata
)
2006 uvalue
+= cu_offset
;
2008 if (uvalue
>= section
->size
)
2009 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2010 dwarf_vmatoa ("x", uvalue
),
2011 (unsigned long) (orig_data
- section
->start
));
2014 unsigned long abbrev_number
;
2015 abbrev_entry
* entry
;
2017 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2019 printf (_("[Abbrev Number: %ld"), abbrev_number
);
2020 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2021 use different abbrev table, and we don't track .debug_info chunks
2023 if (form
!= DW_FORM_ref_addr
)
2025 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2026 if (entry
->entry
== abbrev_number
)
2029 printf (" (%s)", get_TAG_name (entry
->tag
));
2044 get_AT_name (unsigned long attribute
)
2049 return "DW_AT value: 0";
2051 /* One value is shared by the MIPS and HP extensions: */
2052 if (attribute
== DW_AT_MIPS_fde
)
2053 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2055 name
= get_DW_AT_name (attribute
);
2059 static char buffer
[100];
2061 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2069 static unsigned char *
2070 read_and_display_attr (unsigned long attribute
,
2072 unsigned char * data
,
2073 unsigned char * end
,
2074 dwarf_vma cu_offset
,
2075 dwarf_vma pointer_size
,
2076 dwarf_vma offset_size
,
2078 debug_info
* debug_info_p
,
2080 struct dwarf_section
* section
,
2081 struct cu_tu_set
* this_set
)
2084 printf (" %-18s:", get_AT_name (attribute
));
2085 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2086 cu_offset
, pointer_size
, offset_size
,
2087 dwarf_version
, debug_info_p
,
2088 do_loc
, section
, this_set
);
2094 /* Process the contents of a .debug_info section. If do_loc is non-zero
2095 then we are scanning for location lists and we do not want to display
2096 anything to the user. If do_types is non-zero, we are processing
2097 a .debug_types section instead of a .debug_info section. */
2100 process_debug_info (struct dwarf_section
*section
,
2102 enum dwarf_section_display_enum abbrev_sec
,
2106 unsigned char *start
= section
->start
;
2107 unsigned char *end
= start
+ section
->size
;
2108 unsigned char *section_begin
;
2110 unsigned int num_units
= 0;
2112 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2113 && num_debug_info_entries
== 0
2118 /* First scan the section to get the number of comp units. */
2119 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2122 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2123 will be the length. For a 64-bit DWARF section, it'll be
2124 the escape code 0xffffffff followed by an 8 byte length. */
2125 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2127 if (length
== 0xffffffff)
2129 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2130 section_begin
+= length
+ 12;
2132 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2134 warn (_("Reserved length value (0x%s) found in section %s\n"),
2135 dwarf_vmatoa ("x", length
), section
->name
);
2139 section_begin
+= length
+ 4;
2141 /* Negative values are illegal, they may even cause infinite
2142 looping. This can happen if we can't accurately apply
2143 relocations to an object file. */
2144 if ((signed long) length
<= 0)
2146 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2147 dwarf_vmatoa ("x", length
), section
->name
);
2154 error (_("No comp units in %s section ?"), section
->name
);
2158 /* Then allocate an array to hold the information. */
2159 debug_information
= (debug_info
*) cmalloc (num_units
,
2160 sizeof (* debug_information
));
2161 if (debug_information
== NULL
)
2163 error (_("Not enough memory for a debug info array of %u entries"),
2171 if (dwarf_start_die
== 0)
2172 printf (_("Contents of the %s section:\n\n"), section
->name
);
2174 load_debug_section (str
, file
);
2175 load_debug_section (str_dwo
, file
);
2176 load_debug_section (str_index
, file
);
2177 load_debug_section (str_index_dwo
, file
);
2178 load_debug_section (debug_addr
, file
);
2181 load_debug_section (abbrev_sec
, file
);
2182 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2184 warn (_("Unable to locate %s section!\n"),
2185 debug_displays
[abbrev_sec
].section
.name
);
2189 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2191 DWARF2_Internal_CompUnit compunit
;
2192 unsigned char *hdrptr
;
2193 unsigned char *tags
;
2194 int level
, last_level
, saved_level
;
2195 dwarf_vma cu_offset
;
2197 int initial_length_size
;
2198 dwarf_vma signature_high
= 0;
2199 dwarf_vma signature_low
= 0;
2200 dwarf_vma type_offset
= 0;
2201 struct cu_tu_set
*this_set
;
2202 dwarf_vma abbrev_base
;
2207 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2209 if (compunit
.cu_length
== 0xffffffff)
2211 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2213 initial_length_size
= 12;
2218 initial_length_size
= 4;
2221 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2223 cu_offset
= start
- section_begin
;
2225 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2227 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2229 if (this_set
== NULL
)
2232 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2236 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2237 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2240 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2244 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2246 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2249 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2250 && num_debug_info_entries
== 0
2253 debug_information
[unit
].cu_offset
= cu_offset
;
2254 debug_information
[unit
].pointer_size
2255 = compunit
.cu_pointer_size
;
2256 debug_information
[unit
].offset_size
= offset_size
;
2257 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2258 debug_information
[unit
].base_address
= 0;
2259 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2260 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2261 debug_information
[unit
].loc_offsets
= NULL
;
2262 debug_information
[unit
].have_frame_base
= NULL
;
2263 debug_information
[unit
].max_loc_offsets
= 0;
2264 debug_information
[unit
].num_loc_offsets
= 0;
2265 debug_information
[unit
].range_lists
= NULL
;
2266 debug_information
[unit
].max_range_lists
= 0;
2267 debug_information
[unit
].num_range_lists
= 0;
2270 if (!do_loc
&& dwarf_start_die
== 0)
2272 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2273 dwarf_vmatoa ("x", cu_offset
));
2274 printf (_(" Length: 0x%s (%s)\n"),
2275 dwarf_vmatoa ("x", compunit
.cu_length
),
2276 offset_size
== 8 ? "64-bit" : "32-bit");
2277 printf (_(" Version: %d\n"), compunit
.cu_version
);
2278 printf (_(" Abbrev Offset: 0x%s\n"),
2279 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2280 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2285 printf (_(" Signature: 0x%s\n"),
2286 dwarf_vmatoa64 (signature_high
, signature_low
,
2287 buf
, sizeof (buf
)));
2288 printf (_(" Type Offset: 0x%s\n"),
2289 dwarf_vmatoa ("x", type_offset
));
2291 if (this_set
!= NULL
)
2293 dwarf_vma
*offsets
= this_set
->section_offsets
;
2294 size_t *sizes
= this_set
->section_sizes
;
2296 printf (_(" Section contributions:\n"));
2297 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2298 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2299 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2300 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2301 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2302 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2303 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2304 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2305 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2306 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2307 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2308 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2312 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2315 warn (_("Debug info is corrupted, length of CU at %s"
2316 " extends beyond end of section (length = %s)\n"),
2317 dwarf_vmatoa ("x", cu_offset
),
2318 dwarf_vmatoa ("x", compunit
.cu_length
));
2322 start
+= compunit
.cu_length
+ initial_length_size
;
2324 if (compunit
.cu_version
!= 2
2325 && compunit
.cu_version
!= 3
2326 && compunit
.cu_version
!= 4)
2328 warn (_("CU at offset %s contains corrupt or "
2329 "unsupported version number: %d.\n"),
2330 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2336 /* Process the abbrevs used by this compilation unit. DWARF
2337 sections under Mach-O have non-zero addresses. */
2338 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2339 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2340 (unsigned long) compunit
.cu_abbrev_offset
,
2341 (unsigned long) abbrev_size
);
2343 process_abbrev_section
2344 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2345 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2346 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2347 + abbrev_base
+ abbrev_size
));
2352 while (tags
< start
)
2354 unsigned int bytes_read
;
2355 unsigned long abbrev_number
;
2356 unsigned long die_offset
;
2357 abbrev_entry
*entry
;
2359 int do_printing
= 1;
2361 die_offset
= tags
- section_begin
;
2363 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2366 /* A null DIE marks the end of a list of siblings or it may also be
2367 a section padding. */
2368 if (abbrev_number
== 0)
2370 /* Check if it can be a section padding for the last CU. */
2371 if (level
== 0 && start
== end
)
2375 for (chk
= tags
; chk
< start
; chk
++)
2382 if (!do_loc
&& die_offset
>= dwarf_start_die
2383 && (dwarf_cutoff_level
== -1
2384 || level
< dwarf_cutoff_level
))
2385 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2391 static unsigned num_bogus_warns
= 0;
2393 if (num_bogus_warns
< 3)
2395 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2396 die_offset
, section
->name
);
2398 if (num_bogus_warns
== 3)
2399 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2402 if (dwarf_start_die
!= 0 && level
< saved_level
)
2409 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2413 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2414 saved_level
= level
;
2415 do_printing
= (dwarf_cutoff_level
== -1
2416 || level
< dwarf_cutoff_level
);
2418 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2419 level
, die_offset
, abbrev_number
);
2420 else if (dwarf_cutoff_level
== -1
2421 || last_level
< dwarf_cutoff_level
)
2422 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2427 /* Scan through the abbreviation list until we reach the
2429 for (entry
= first_abbrev
;
2430 entry
&& entry
->entry
!= abbrev_number
;
2431 entry
= entry
->next
)
2436 if (!do_loc
&& do_printing
)
2441 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2442 die_offset
, abbrev_number
);
2446 if (!do_loc
&& do_printing
)
2447 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2452 need_base_address
= 0;
2454 case DW_TAG_compile_unit
:
2455 need_base_address
= 1;
2457 case DW_TAG_entry_point
:
2458 case DW_TAG_subprogram
:
2459 need_base_address
= 0;
2460 /* Assuming that there is no DW_AT_frame_base. */
2461 have_frame_base
= 0;
2465 for (attr
= entry
->first_attr
;
2466 attr
&& attr
->attribute
;
2471 if (! do_loc
&& do_printing
)
2472 /* Show the offset from where the tag was extracted. */
2473 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2475 arg
= debug_information
;
2476 if (debug_information
)
2479 tags
= read_and_display_attr (attr
->attribute
,
2484 compunit
.cu_pointer_size
,
2486 compunit
.cu_version
,
2488 do_loc
|| ! do_printing
,
2493 if (entry
->children
)
2498 /* Set num_debug_info_entries here so that it can be used to check if
2499 we need to process .debug_loc and .debug_ranges sections. */
2500 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2501 && num_debug_info_entries
== 0
2503 num_debug_info_entries
= num_units
;
2511 /* Locate and scan the .debug_info section in the file and record the pointer
2512 sizes and offsets for the compilation units in it. Usually an executable
2513 will have just one pointer size, but this is not guaranteed, and so we try
2514 not to make any assumptions. Returns zero upon failure, or the number of
2515 compilation units upon success. */
2518 load_debug_info (void * file
)
2520 /* Reset the last pointer size so that we can issue correct error
2521 messages if we are displaying the contents of more than one section. */
2522 last_pointer_size
= 0;
2523 warned_about_missing_comp_units
= FALSE
;
2525 /* If we have already tried and failed to load the .debug_info
2526 section then do not bother to repeat the task. */
2527 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2530 /* If we already have the information there is nothing else to do. */
2531 if (num_debug_info_entries
> 0)
2532 return num_debug_info_entries
;
2534 /* If this is a DWARF package file, load the CU and TU indexes. */
2535 load_cu_tu_indexes (file
);
2537 if (load_debug_section (info
, file
)
2538 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2539 return num_debug_info_entries
;
2540 else if (load_debug_section (info_dwo
, file
)
2541 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2543 return num_debug_info_entries
;
2545 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2549 /* Read a DWARF .debug_line section header starting at DATA.
2550 Upon success returns an updated DATA pointer and the LINFO
2551 structure and the END_OF_SEQUENCE pointer will be filled in.
2552 Otherwise returns NULL. */
2554 static unsigned char *
2555 read_debug_line_header (struct dwarf_section
* section
,
2556 unsigned char * data
,
2557 unsigned char * end
,
2558 DWARF2_Internal_LineInfo
* linfo
,
2559 unsigned char ** end_of_sequence
)
2561 unsigned char *hdrptr
;
2562 unsigned int offset_size
;
2563 unsigned int initial_length_size
;
2565 /* Extract information from the Line Number Program Header.
2566 (section 6.2.4 in the Dwarf3 doc). */
2569 /* Get and check the length of the block. */
2570 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2572 if (linfo
->li_length
== 0xffffffff)
2574 /* This section is 64-bit DWARF 3. */
2575 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2577 initial_length_size
= 12;
2582 initial_length_size
= 4;
2585 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2587 /* If the length is just a bias against the initial_length_size then
2588 this means that the field has a relocation against it which has not
2589 been applied. (Ie we are dealing with an object file, not a linked
2590 binary). Do not complain but instead assume that the rest of the
2591 section applies to this particular header. */
2592 if (linfo
->li_length
== - initial_length_size
)
2594 linfo
->li_length
= section
->size
- initial_length_size
;
2598 warn (_("The line info appears to be corrupt - "
2599 "the section is too small\n"));
2604 /* Get and check the version number. */
2605 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2607 if (linfo
->li_version
!= 2
2608 && linfo
->li_version
!= 3
2609 && linfo
->li_version
!= 4)
2611 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2615 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2616 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2618 if (linfo
->li_version
>= 4)
2620 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2622 if (linfo
->li_max_ops_per_insn
== 0)
2624 warn (_("Invalid maximum operations per insn.\n"));
2629 linfo
->li_max_ops_per_insn
= 1;
2631 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2632 SAFE_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2633 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2634 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2636 /* Sign extend the line base field. */
2637 linfo
->li_line_base
<<= 24;
2638 linfo
->li_line_base
>>= 24;
2640 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2645 display_debug_lines_raw (struct dwarf_section
*section
,
2646 unsigned char *data
,
2649 unsigned char *start
= section
->start
;
2651 printf (_("Raw dump of debug contents of section %s:\n\n"),
2656 static DWARF2_Internal_LineInfo saved_linfo
;
2657 DWARF2_Internal_LineInfo linfo
;
2658 unsigned char *standard_opcodes
;
2659 unsigned char *end_of_sequence
;
2662 if (const_strneq (section
->name
, ".debug_line."))
2664 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2665 section containing just the Line Number Statements. They are
2666 created by the assembler and intended to be used alongside gcc's
2667 -ffunction-sections command line option. When the linker's
2668 garbage collection decides to discard a .text.<foo> section it
2669 can then also discard the line number information in .debug_line.<foo>.
2671 Since the section is a fragmnent it does not have the details
2672 needed to fill out a LineInfo structure, so instead we use the
2673 details from the last one we processed. */
2674 end_of_sequence
= end
;
2675 standard_opcodes
= NULL
;
2676 linfo
= saved_linfo
;
2677 reset_state_machine (linfo
.li_default_is_stmt
);
2681 unsigned char * hdrptr
;
2683 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2684 & end_of_sequence
)) == NULL
)
2687 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2688 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2689 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2690 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2691 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2692 if (linfo
.li_version
>= 4)
2693 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2694 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2695 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2696 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2697 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2699 reset_state_machine (linfo
.li_default_is_stmt
);
2701 /* Display the contents of the Opcodes table. */
2702 standard_opcodes
= hdrptr
;
2704 printf (_("\n Opcodes:\n"));
2706 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2707 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2709 /* Display the contents of the Directory table. */
2710 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2713 printf (_("\n The Directory Table is empty.\n"));
2716 printf (_("\n The Directory Table:\n"));
2720 printf (" %s\n", data
);
2722 data
+= strnlen ((char *) data
, end
- data
) + 1;
2726 /* Skip the NUL at the end of the table. */
2729 /* Display the contents of the File Name table. */
2731 printf (_("\n The File Name Table is empty.\n"));
2734 printf (_("\n The File Name Table:\n"));
2735 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2739 unsigned char *name
;
2740 unsigned int bytes_read
;
2742 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2744 data
+= strnlen ((char *) data
, end
- data
) + 1;
2747 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2750 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2753 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2755 printf ("%s\n", name
);
2759 warn (_("Corrupt file name table entry\n"));
2765 /* Skip the NUL at the end of the table. */
2768 saved_linfo
= linfo
;
2771 /* Now display the statements. */
2772 if (data
>= end_of_sequence
)
2773 printf (_(" No Line Number Statements.\n"));
2776 printf (_(" Line Number Statements:\n"));
2778 while (data
< end_of_sequence
)
2780 unsigned char op_code
;
2781 dwarf_signed_vma adv
;
2783 unsigned int bytes_read
;
2787 if (op_code
>= linfo
.li_opcode_base
)
2789 op_code
-= linfo
.li_opcode_base
;
2790 uladv
= (op_code
/ linfo
.li_line_range
);
2791 if (linfo
.li_max_ops_per_insn
== 1)
2793 uladv
*= linfo
.li_min_insn_length
;
2794 state_machine_regs
.address
+= uladv
;
2795 printf (_(" Special opcode %d: "
2796 "advance Address by %s to 0x%s"),
2797 op_code
, dwarf_vmatoa ("u", uladv
),
2798 dwarf_vmatoa ("x", state_machine_regs
.address
));
2802 state_machine_regs
.address
2803 += ((state_machine_regs
.op_index
+ uladv
)
2804 / linfo
.li_max_ops_per_insn
)
2805 * linfo
.li_min_insn_length
;
2806 state_machine_regs
.op_index
2807 = (state_machine_regs
.op_index
+ uladv
)
2808 % linfo
.li_max_ops_per_insn
;
2809 printf (_(" Special opcode %d: "
2810 "advance Address by %s to 0x%s[%d]"),
2811 op_code
, dwarf_vmatoa ("u", uladv
),
2812 dwarf_vmatoa ("x", state_machine_regs
.address
),
2813 state_machine_regs
.op_index
);
2815 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2816 state_machine_regs
.line
+= adv
;
2817 printf (_(" and Line by %s to %d\n"),
2818 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
2820 else switch (op_code
)
2822 case DW_LNS_extended_op
:
2823 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
2827 printf (_(" Copy\n"));
2830 case DW_LNS_advance_pc
:
2831 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2833 if (linfo
.li_max_ops_per_insn
== 1)
2835 uladv
*= linfo
.li_min_insn_length
;
2836 state_machine_regs
.address
+= uladv
;
2837 printf (_(" Advance PC by %s to 0x%s\n"),
2838 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 (_(" Advance PC by %s to 0x%s[%d]\n"),
2851 dwarf_vmatoa ("u", uladv
),
2852 dwarf_vmatoa ("x", state_machine_regs
.address
),
2853 state_machine_regs
.op_index
);
2857 case DW_LNS_advance_line
:
2858 adv
= read_sleb128 (data
, & bytes_read
, end
);
2860 state_machine_regs
.line
+= adv
;
2861 printf (_(" Advance Line by %s to %d\n"),
2862 dwarf_vmatoa ("d", adv
),
2863 state_machine_regs
.line
);
2866 case DW_LNS_set_file
:
2867 adv
= read_uleb128 (data
, & bytes_read
, end
);
2869 printf (_(" Set File Name to entry %s in the File Name Table\n"),
2870 dwarf_vmatoa ("d", adv
));
2871 state_machine_regs
.file
= adv
;
2874 case DW_LNS_set_column
:
2875 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2877 printf (_(" Set column to %s\n"),
2878 dwarf_vmatoa ("u", uladv
));
2879 state_machine_regs
.column
= uladv
;
2882 case DW_LNS_negate_stmt
:
2883 adv
= state_machine_regs
.is_stmt
;
2885 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
2886 state_machine_regs
.is_stmt
= adv
;
2889 case DW_LNS_set_basic_block
:
2890 printf (_(" Set basic block\n"));
2891 state_machine_regs
.basic_block
= 1;
2894 case DW_LNS_const_add_pc
:
2895 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2896 if (linfo
.li_max_ops_per_insn
)
2898 uladv
*= linfo
.li_min_insn_length
;
2899 state_machine_regs
.address
+= uladv
;
2900 printf (_(" Advance PC by constant %s to 0x%s\n"),
2901 dwarf_vmatoa ("u", uladv
),
2902 dwarf_vmatoa ("x", state_machine_regs
.address
));
2906 state_machine_regs
.address
2907 += ((state_machine_regs
.op_index
+ uladv
)
2908 / linfo
.li_max_ops_per_insn
)
2909 * linfo
.li_min_insn_length
;
2910 state_machine_regs
.op_index
2911 = (state_machine_regs
.op_index
+ uladv
)
2912 % linfo
.li_max_ops_per_insn
;
2913 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
2914 dwarf_vmatoa ("u", uladv
),
2915 dwarf_vmatoa ("x", state_machine_regs
.address
),
2916 state_machine_regs
.op_index
);
2920 case DW_LNS_fixed_advance_pc
:
2921 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
2922 state_machine_regs
.address
+= uladv
;
2923 state_machine_regs
.op_index
= 0;
2924 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
2925 dwarf_vmatoa ("u", uladv
),
2926 dwarf_vmatoa ("x", state_machine_regs
.address
));
2929 case DW_LNS_set_prologue_end
:
2930 printf (_(" Set prologue_end to true\n"));
2933 case DW_LNS_set_epilogue_begin
:
2934 printf (_(" Set epilogue_begin to true\n"));
2937 case DW_LNS_set_isa
:
2938 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2940 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
2944 printf (_(" Unknown opcode %d with operands: "), op_code
);
2946 if (standard_opcodes
!= NULL
)
2947 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2949 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
2951 i
== 1 ? "" : ", ");
2967 unsigned char *name
;
2968 unsigned int directory_index
;
2969 unsigned int modification_date
;
2970 unsigned int length
;
2973 /* Output a decoded representation of the .debug_line section. */
2976 display_debug_lines_decoded (struct dwarf_section
*section
,
2977 unsigned char *data
,
2980 static DWARF2_Internal_LineInfo saved_linfo
;
2982 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2987 /* This loop amounts to one iteration per compilation unit. */
2988 DWARF2_Internal_LineInfo linfo
;
2989 unsigned char *standard_opcodes
;
2990 unsigned char *end_of_sequence
;
2992 File_Entry
*file_table
= NULL
;
2993 unsigned int n_files
= 0;
2994 unsigned char **directory_table
= NULL
;
2995 unsigned int n_directories
= 0;
2997 if (const_strneq (section
->name
, ".debug_line."))
2999 /* Sections named .debug_line.<foo> are fragments of a .debug_line
3000 section containing just the Line Number Statements. They are
3001 created by the assembler and intended to be used alongside gcc's
3002 -ffunction-sections command line option. When the linker's
3003 garbage collection decides to discard a .text.<foo> section it
3004 can then also discard the line number information in .debug_line.<foo>.
3006 Since the section is a fragmnent it does not have the details
3007 needed to fill out a LineInfo structure, so instead we use the
3008 details from the last one we processed. */
3009 end_of_sequence
= end
;
3010 standard_opcodes
= NULL
;
3011 linfo
= saved_linfo
;
3012 reset_state_machine (linfo
.li_default_is_stmt
);
3016 unsigned char *hdrptr
;
3018 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3019 & end_of_sequence
)) == NULL
)
3022 reset_state_machine (linfo
.li_default_is_stmt
);
3024 /* Save a pointer to the contents of the Opcodes table. */
3025 standard_opcodes
= hdrptr
;
3027 /* Traverse the Directory table just to count entries. */
3028 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3031 unsigned char *ptr_directory_table
= data
;
3035 data
+= strnlen ((char *) data
, end
- data
) + 1;
3039 /* Go through the directory table again to save the directories. */
3040 directory_table
= (unsigned char **)
3041 xmalloc (n_directories
* sizeof (unsigned char *));
3044 while (*ptr_directory_table
!= 0)
3046 directory_table
[i
] = ptr_directory_table
;
3047 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3048 ptr_directory_table
- end
) + 1;
3052 /* Skip the NUL at the end of the table. */
3055 /* Traverse the File Name table just to count the entries. */
3058 unsigned char *ptr_file_name_table
= data
;
3062 unsigned int bytes_read
;
3064 /* Skip Name, directory index, last modification time and length
3066 data
+= strnlen ((char *) data
, end
- data
) + 1;
3067 read_uleb128 (data
, & bytes_read
, end
);
3069 read_uleb128 (data
, & bytes_read
, end
);
3071 read_uleb128 (data
, & bytes_read
, end
);
3077 /* Go through the file table again to save the strings. */
3078 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3081 while (*ptr_file_name_table
!= 0)
3083 unsigned int bytes_read
;
3085 file_table
[i
].name
= ptr_file_name_table
;
3086 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3087 end
- ptr_file_name_table
) + 1;
3089 /* We are not interested in directory, time or size. */
3090 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3092 ptr_file_name_table
+= bytes_read
;
3093 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3095 ptr_file_name_table
+= bytes_read
;
3096 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3097 ptr_file_name_table
+= bytes_read
;
3102 /* Print the Compilation Unit's name and a header. */
3103 if (directory_table
== NULL
)
3105 printf (_("CU: %s:\n"), file_table
[0].name
);
3106 printf (_("File name Line number Starting address\n"));
3110 unsigned int ix
= file_table
[0].directory_index
;
3111 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3113 if (do_wide
|| strlen (directory
) < 76)
3114 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3116 printf ("%s:\n", file_table
[0].name
);
3118 printf (_("File name Line number Starting address\n"));
3122 /* Skip the NUL at the end of the table. */
3125 saved_linfo
= linfo
;
3128 /* This loop iterates through the Dwarf Line Number Program. */
3129 while (data
< end_of_sequence
)
3131 unsigned char op_code
;
3133 unsigned long int uladv
;
3134 unsigned int bytes_read
;
3135 int is_special_opcode
= 0;
3139 if (op_code
>= linfo
.li_opcode_base
)
3141 op_code
-= linfo
.li_opcode_base
;
3142 uladv
= (op_code
/ linfo
.li_line_range
);
3143 if (linfo
.li_max_ops_per_insn
== 1)
3145 uladv
*= linfo
.li_min_insn_length
;
3146 state_machine_regs
.address
+= uladv
;
3150 state_machine_regs
.address
3151 += ((state_machine_regs
.op_index
+ uladv
)
3152 / linfo
.li_max_ops_per_insn
)
3153 * linfo
.li_min_insn_length
;
3154 state_machine_regs
.op_index
3155 = (state_machine_regs
.op_index
+ uladv
)
3156 % linfo
.li_max_ops_per_insn
;
3159 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3160 state_machine_regs
.line
+= adv
;
3161 is_special_opcode
= 1;
3163 else switch (op_code
)
3165 case DW_LNS_extended_op
:
3167 unsigned int ext_op_code_len
;
3168 unsigned char ext_op_code
;
3169 unsigned char *op_code_data
= data
;
3171 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3173 op_code_data
+= bytes_read
;
3175 if (ext_op_code_len
== 0)
3177 warn (_("badly formed extended line op encountered!\n"));
3180 ext_op_code_len
+= bytes_read
;
3181 ext_op_code
= *op_code_data
++;
3183 switch (ext_op_code
)
3185 case DW_LNE_end_sequence
:
3186 reset_state_machine (linfo
.li_default_is_stmt
);
3188 case DW_LNE_set_address
:
3189 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3190 op_code_data
, ext_op_code_len
- bytes_read
- 1,
3192 state_machine_regs
.op_index
= 0;
3194 case DW_LNE_define_file
:
3196 file_table
= (File_Entry
*) xrealloc
3197 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3199 ++state_machine_regs
.last_file_entry
;
3200 /* Source file name. */
3201 file_table
[n_files
].name
= op_code_data
;
3202 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3203 /* Directory index. */
3204 file_table
[n_files
].directory_index
=
3205 read_uleb128 (op_code_data
, & bytes_read
,
3207 op_code_data
+= bytes_read
;
3208 /* Last modification time. */
3209 file_table
[n_files
].modification_date
=
3210 read_uleb128 (op_code_data
, & bytes_read
,
3212 op_code_data
+= bytes_read
;
3214 file_table
[n_files
].length
=
3215 read_uleb128 (op_code_data
, & bytes_read
,
3221 case DW_LNE_set_discriminator
:
3222 case DW_LNE_HP_set_sequence
:
3223 /* Simply ignored. */
3227 printf (_("UNKNOWN (%u): length %d\n"),
3228 ext_op_code
, ext_op_code_len
- bytes_read
);
3231 data
+= ext_op_code_len
;
3237 case DW_LNS_advance_pc
:
3238 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3240 if (linfo
.li_max_ops_per_insn
== 1)
3242 uladv
*= linfo
.li_min_insn_length
;
3243 state_machine_regs
.address
+= uladv
;
3247 state_machine_regs
.address
3248 += ((state_machine_regs
.op_index
+ uladv
)
3249 / linfo
.li_max_ops_per_insn
)
3250 * linfo
.li_min_insn_length
;
3251 state_machine_regs
.op_index
3252 = (state_machine_regs
.op_index
+ uladv
)
3253 % linfo
.li_max_ops_per_insn
;
3257 case DW_LNS_advance_line
:
3258 adv
= read_sleb128 (data
, & bytes_read
, end
);
3260 state_machine_regs
.line
+= adv
;
3263 case DW_LNS_set_file
:
3264 adv
= read_uleb128 (data
, & bytes_read
, end
);
3266 state_machine_regs
.file
= adv
;
3268 if (file_table
== NULL
)
3269 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3270 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3271 /* If directory index is 0, that means current directory. */
3272 printf ("\n./%s:[++]\n",
3273 file_table
[state_machine_regs
.file
- 1].name
);
3274 else if (directory_table
== NULL
)
3275 printf (_("\n [Use directory table entry %d]\n"),
3276 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3278 /* The directory index starts counting at 1. */
3279 printf ("\n%s/%s:\n",
3280 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3281 file_table
[state_machine_regs
.file
- 1].name
);
3284 case DW_LNS_set_column
:
3285 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3287 state_machine_regs
.column
= uladv
;
3290 case DW_LNS_negate_stmt
:
3291 adv
= state_machine_regs
.is_stmt
;
3293 state_machine_regs
.is_stmt
= adv
;
3296 case DW_LNS_set_basic_block
:
3297 state_machine_regs
.basic_block
= 1;
3300 case DW_LNS_const_add_pc
:
3301 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3302 if (linfo
.li_max_ops_per_insn
== 1)
3304 uladv
*= linfo
.li_min_insn_length
;
3305 state_machine_regs
.address
+= uladv
;
3309 state_machine_regs
.address
3310 += ((state_machine_regs
.op_index
+ uladv
)
3311 / linfo
.li_max_ops_per_insn
)
3312 * linfo
.li_min_insn_length
;
3313 state_machine_regs
.op_index
3314 = (state_machine_regs
.op_index
+ uladv
)
3315 % linfo
.li_max_ops_per_insn
;
3319 case DW_LNS_fixed_advance_pc
:
3320 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3321 state_machine_regs
.address
+= uladv
;
3322 state_machine_regs
.op_index
= 0;
3325 case DW_LNS_set_prologue_end
:
3328 case DW_LNS_set_epilogue_begin
:
3331 case DW_LNS_set_isa
:
3332 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3334 printf (_(" Set ISA to %lu\n"), uladv
);
3338 printf (_(" Unknown opcode %d with operands: "), op_code
);
3340 if (standard_opcodes
!= NULL
)
3341 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3343 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3345 i
== 1 ? "" : ", ");
3352 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3353 to the DWARF address/line matrix. */
3354 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3355 || (op_code
== DW_LNS_copy
))
3357 const unsigned int MAX_FILENAME_LENGTH
= 35;
3359 char *newFileName
= NULL
;
3360 size_t fileNameLength
;
3363 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3365 fileName
= "<unknown>";
3367 fileNameLength
= strlen (fileName
);
3369 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3371 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3372 /* Truncate file name */
3373 strncpy (newFileName
,
3374 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3375 MAX_FILENAME_LENGTH
+ 1);
3379 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3380 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3383 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3385 if (linfo
.li_max_ops_per_insn
== 1)
3386 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3387 newFileName
, state_machine_regs
.line
,
3388 state_machine_regs
.address
);
3390 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3391 newFileName
, state_machine_regs
.line
,
3392 state_machine_regs
.address
,
3393 state_machine_regs
.op_index
);
3397 if (linfo
.li_max_ops_per_insn
== 1)
3398 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3399 newFileName
, state_machine_regs
.line
,
3400 state_machine_regs
.address
);
3402 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3403 newFileName
, state_machine_regs
.line
,
3404 state_machine_regs
.address
,
3405 state_machine_regs
.op_index
);
3408 if (op_code
== DW_LNE_end_sequence
)
3422 if (directory_table
)
3424 free (directory_table
);
3425 directory_table
= NULL
;
3436 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3438 unsigned char *data
= section
->start
;
3439 unsigned char *end
= data
+ section
->size
;
3441 int retValDecoded
= 1;
3443 if (do_debug_lines
== 0)
3444 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3446 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3447 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3449 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3450 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3452 if (!retValRaw
|| !retValDecoded
)
3459 find_debug_info_for_offset (unsigned long offset
)
3463 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3466 for (i
= 0; i
< num_debug_info_entries
; i
++)
3467 if (debug_information
[i
].cu_offset
== offset
)
3468 return debug_information
+ i
;
3474 display_debug_pubnames (struct dwarf_section
*section
,
3475 void *file ATTRIBUTE_UNUSED
)
3477 DWARF2_Internal_PubNames names
;
3478 unsigned char *start
= section
->start
;
3479 unsigned char *end
= start
+ section
->size
;
3481 /* It does not matter if this load fails,
3482 we test for that later on. */
3483 load_debug_info (file
);
3485 printf (_("Contents of the %s section:\n\n"), section
->name
);
3489 unsigned char *data
;
3490 unsigned long offset
;
3491 int offset_size
, initial_length_size
;
3495 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3496 if (names
.pn_length
== 0xffffffff)
3498 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3500 initial_length_size
= 12;
3505 initial_length_size
= 4;
3508 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3509 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3511 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3512 && num_debug_info_entries
> 0
3513 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3514 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3515 (unsigned long) names
.pn_offset
, section
->name
);
3517 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3519 start
+= names
.pn_length
+ initial_length_size
;
3521 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3523 static int warned
= 0;
3527 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3534 printf (_(" Length: %ld\n"),
3535 (long) names
.pn_length
);
3536 printf (_(" Version: %d\n"),
3538 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3539 (unsigned long) names
.pn_offset
);
3540 printf (_(" Size of area in .debug_info section: %ld\n"),
3541 (long) names
.pn_size
);
3543 printf (_("\n Offset\tName\n"));
3547 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3551 data
+= offset_size
;
3552 printf (" %-6lx\t%s\n", offset
, data
);
3553 data
+= strnlen ((char *) data
, end
- data
) + 1;
3556 while (offset
!= 0);
3564 display_debug_macinfo (struct dwarf_section
*section
,
3565 void *file ATTRIBUTE_UNUSED
)
3567 unsigned char *start
= section
->start
;
3568 unsigned char *end
= start
+ section
->size
;
3569 unsigned char *curr
= start
;
3570 unsigned int bytes_read
;
3571 enum dwarf_macinfo_record_type op
;
3573 printf (_("Contents of the %s section:\n\n"), section
->name
);
3577 unsigned int lineno
;
3578 const unsigned char *string
;
3580 op
= (enum dwarf_macinfo_record_type
) *curr
;
3585 case DW_MACINFO_start_file
:
3587 unsigned int filenum
;
3589 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3591 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3594 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3599 case DW_MACINFO_end_file
:
3600 printf (_(" DW_MACINFO_end_file\n"));
3603 case DW_MACINFO_define
:
3604 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3607 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3608 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3612 case DW_MACINFO_undef
:
3613 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3616 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3617 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3621 case DW_MACINFO_vendor_ext
:
3623 unsigned int constant
;
3625 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3628 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3629 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3639 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3640 filename and dirname corresponding to file name table entry with index
3641 FILEIDX. Return NULL on failure. */
3643 static unsigned char *
3644 get_line_filename_and_dirname (dwarf_vma line_offset
,
3646 unsigned char **dir_name
)
3648 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3649 unsigned char *hdrptr
, *dirtable
, *file_name
;
3650 unsigned int offset_size
, initial_length_size
;
3651 unsigned int version
, opcode_base
, bytes_read
;
3652 dwarf_vma length
, diridx
;
3653 const unsigned char * end
;
3656 if (section
->start
== NULL
3657 || line_offset
>= section
->size
3661 hdrptr
= section
->start
+ line_offset
;
3662 end
= section
->start
+ section
->size
;
3664 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3665 if (length
== 0xffffffff)
3667 /* This section is 64-bit DWARF 3. */
3668 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3670 initial_length_size
= 12;
3675 initial_length_size
= 4;
3677 if (length
+ initial_length_size
> section
->size
)
3680 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3681 if (version
!= 2 && version
!= 3 && version
!= 4)
3683 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3685 hdrptr
++; /* Skip max_ops_per_insn. */
3686 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3688 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3689 if (opcode_base
== 0)
3692 hdrptr
+= opcode_base
- 1;
3694 /* Skip over dirname table. */
3695 while (*hdrptr
!= '\0')
3696 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3697 hdrptr
++; /* Skip the NUL at the end of the table. */
3698 /* Now skip over preceding filename table entries. */
3699 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3701 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3702 read_uleb128 (hdrptr
, &bytes_read
, end
);
3703 hdrptr
+= bytes_read
;
3704 read_uleb128 (hdrptr
, &bytes_read
, end
);
3705 hdrptr
+= bytes_read
;
3706 read_uleb128 (hdrptr
, &bytes_read
, end
);
3707 hdrptr
+= bytes_read
;
3709 if (hdrptr
== end
|| *hdrptr
== '\0')
3712 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3713 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
3716 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
3717 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
3718 if (*dirtable
== '\0')
3720 *dir_name
= dirtable
;
3725 display_debug_macro (struct dwarf_section
*section
,
3728 unsigned char *start
= section
->start
;
3729 unsigned char *end
= start
+ section
->size
;
3730 unsigned char *curr
= start
;
3731 unsigned char *extended_op_buf
[256];
3732 unsigned int bytes_read
;
3734 load_debug_section (str
, file
);
3735 load_debug_section (line
, file
);
3737 printf (_("Contents of the %s section:\n\n"), section
->name
);
3741 unsigned int lineno
, version
, flags
;
3742 unsigned int offset_size
= 4;
3743 const unsigned char *string
;
3744 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
3745 unsigned char **extended_ops
= NULL
;
3747 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
3750 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3755 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
3758 printf (_(" Offset: 0x%lx\n"),
3759 (unsigned long) sec_offset
);
3760 printf (_(" Version: %d\n"), version
);
3761 printf (_(" Offset size: %d\n"), offset_size
);
3764 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
3765 printf (_(" Offset into .debug_line: 0x%lx\n"),
3766 (unsigned long) line_offset
);
3770 unsigned int i
, count
, op
;
3773 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
3775 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
3776 extended_ops
= extended_op_buf
;
3779 printf (_(" Extension opcode arguments:\n"));
3780 for (i
= 0; i
< count
; i
++)
3782 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3783 extended_ops
[op
] = curr
;
3784 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
3787 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
3790 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
3791 for (n
= 0; n
< nargs
; n
++)
3795 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
3796 printf ("%s%s", get_FORM_name (form
),
3797 n
== nargs
- 1 ? "\n" : ", ");
3807 case DW_FORM_block1
:
3808 case DW_FORM_block2
:
3809 case DW_FORM_block4
:
3811 case DW_FORM_string
:
3813 case DW_FORM_sec_offset
:
3816 error (_("Invalid extension opcode form %s\n"),
3817 get_FORM_name (form
));
3833 error (_(".debug_macro section not zero terminated\n"));
3837 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3843 case DW_MACRO_GNU_start_file
:
3845 unsigned int filenum
;
3846 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
3848 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3850 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
3853 if ((flags
& 2) == 0)
3854 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3857 = get_line_filename_and_dirname (line_offset
, filenum
,
3859 if (file_name
== NULL
)
3860 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3863 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3865 dir_name
!= NULL
? (const char *) dir_name
: "",
3866 dir_name
!= NULL
? "/" : "", file_name
);
3870 case DW_MACRO_GNU_end_file
:
3871 printf (_(" DW_MACRO_GNU_end_file\n"));
3874 case DW_MACRO_GNU_define
:
3875 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3878 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3879 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3883 case DW_MACRO_GNU_undef
:
3884 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3887 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3888 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3892 case DW_MACRO_GNU_define_indirect
:
3893 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3895 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3896 string
= fetch_indirect_string (offset
);
3897 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3901 case DW_MACRO_GNU_undef_indirect
:
3902 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3904 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3905 string
= fetch_indirect_string (offset
);
3906 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
3910 case DW_MACRO_GNU_transparent_include
:
3911 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3912 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
3913 (unsigned long) offset
);
3916 case DW_MACRO_GNU_define_indirect_alt
:
3917 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3919 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3920 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
3921 lineno
, (unsigned long) offset
);
3924 case DW_MACRO_GNU_undef_indirect_alt
:
3925 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3927 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3928 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
3929 lineno
, (unsigned long) offset
);
3932 case DW_MACRO_GNU_transparent_include_alt
:
3933 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3934 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
3935 (unsigned long) offset
);
3939 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
3941 error (_(" Unknown macro opcode %02x seen\n"), op
);
3946 /* Skip over unhandled opcodes. */
3948 unsigned char *desc
= extended_ops
[op
];
3949 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
3953 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
3956 printf (_(" DW_MACRO_GNU_%02x -"), op
);
3957 for (n
= 0; n
< nargs
; n
++)
3961 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
3963 = read_and_display_attr_value (0, val
,
3964 curr
, end
, 0, 0, offset_size
,
3965 version
, NULL
, 0, NULL
,
3983 display_debug_abbrev (struct dwarf_section
*section
,
3984 void *file ATTRIBUTE_UNUSED
)
3986 abbrev_entry
*entry
;
3987 unsigned char *start
= section
->start
;
3988 unsigned char *end
= start
+ section
->size
;
3990 printf (_("Contents of the %s section:\n\n"), section
->name
);
3994 unsigned char *last
;
3999 start
= process_abbrev_section (start
, end
);
4001 if (first_abbrev
== NULL
)
4004 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4006 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4010 printf (" %ld %s [%s]\n",
4012 get_TAG_name (entry
->tag
),
4013 entry
->children
? _("has children") : _("no children"));
4015 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4016 printf (" %-18s %s\n",
4017 get_AT_name (attr
->attribute
),
4018 get_FORM_name (attr
->form
));
4028 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4031 display_loc_list (struct dwarf_section
*section
,
4032 unsigned char **start_ptr
,
4033 int debug_info_entry
,
4034 unsigned long offset
,
4035 unsigned long base_address
,
4038 unsigned char *start
= *start_ptr
;
4039 unsigned char *section_end
= section
->start
+ section
->size
;
4040 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4041 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4042 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4043 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4047 unsigned short length
;
4048 int need_frame_base
;
4052 if (start
+ 2 * pointer_size
> section_end
)
4054 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4059 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4061 /* Note: we use sign extension here in order to be sure that we can detect
4062 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4063 address will not affect the values that we display since we always show
4064 hex values, and always the bottom 32-bits. */
4065 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4066 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4068 if (begin
== 0 && end
== 0)
4070 printf (_("<End of list>\n"));
4074 /* Check base address specifiers. */
4075 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4078 print_dwarf_vma (begin
, pointer_size
);
4079 print_dwarf_vma (end
, pointer_size
);
4080 printf (_("(base address)\n"));
4084 if (start
+ 2 > section_end
)
4086 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4091 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4093 if (start
+ length
> section_end
)
4095 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4100 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4101 print_dwarf_vma (end
+ base_address
, pointer_size
);
4104 need_frame_base
= decode_location_expression (start
,
4109 cu_offset
, section
);
4112 if (need_frame_base
&& !has_frame_base
)
4113 printf (_(" [without DW_AT_frame_base]"));
4116 fputs (_(" (start == end)"), stdout
);
4117 else if (begin
> end
)
4118 fputs (_(" (start > end)"), stdout
);
4128 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4129 right-adjusted in a field of length LEN, and followed by a space. */
4132 print_addr_index (unsigned int idx
, unsigned int len
)
4134 static char buf
[15];
4135 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4136 printf ("%*s ", len
, buf
);
4139 /* Display a location list from a .dwo section. It uses address indexes rather
4140 than embedded addresses. This code closely follows display_loc_list, but the
4141 two are sufficiently different that combining things is very ugly. */
4144 display_loc_list_dwo (struct dwarf_section
*section
,
4145 unsigned char **start_ptr
,
4146 int debug_info_entry
,
4147 unsigned long offset
,
4150 unsigned char *start
= *start_ptr
;
4151 unsigned char *section_end
= section
->start
+ section
->size
;
4152 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4153 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4154 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4155 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4157 unsigned short length
;
4158 int need_frame_base
;
4160 unsigned int bytes_read
;
4164 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4166 if (start
>= section_end
)
4168 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4173 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4176 case 0: /* A terminating entry. */
4178 printf (_("<End of list>\n"));
4180 case 1: /* A base-address entry. */
4181 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4182 start
+= bytes_read
;
4183 print_addr_index (idx
, 8);
4185 printf (_("(base address selection entry)\n"));
4187 case 2: /* A start/end entry. */
4188 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4189 start
+= bytes_read
;
4190 print_addr_index (idx
, 8);
4191 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4192 start
+= bytes_read
;
4193 print_addr_index (idx
, 8);
4195 case 3: /* A start/length entry. */
4196 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4197 start
+= bytes_read
;
4198 print_addr_index (idx
, 8);
4199 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4200 printf ("%08x ", idx
);
4202 case 4: /* An offset pair entry. */
4203 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4204 printf ("%08x ", idx
);
4205 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4206 printf ("%08x ", idx
);
4209 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4214 if (start
+ 2 > section_end
)
4216 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4221 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4222 if (start
+ length
> section_end
)
4224 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4230 need_frame_base
= decode_location_expression (start
,
4235 cu_offset
, section
);
4238 if (need_frame_base
&& !has_frame_base
)
4239 printf (_(" [without DW_AT_frame_base]"));
4249 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4251 static dwarf_vma
*loc_offsets
;
4254 loc_offsets_compar (const void *ap
, const void *bp
)
4256 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4257 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4259 return (a
> b
) - (b
> a
);
4263 display_debug_loc (struct dwarf_section
*section
, void *file
)
4265 unsigned char *start
= section
->start
;
4266 unsigned long bytes
;
4267 unsigned char *section_begin
= start
;
4268 unsigned int num_loc_list
= 0;
4269 unsigned long last_offset
= 0;
4270 unsigned int first
= 0;
4274 int seen_first_offset
= 0;
4275 int locs_sorted
= 1;
4276 unsigned char *next
;
4277 unsigned int *array
= NULL
;
4278 const char *suffix
= strrchr (section
->name
, '.');
4281 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4284 bytes
= section
->size
;
4288 printf (_("\nThe %s section is empty.\n"), section
->name
);
4292 if (load_debug_info (file
) == 0)
4294 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4299 /* Check the order of location list in .debug_info section. If
4300 offsets of location lists are in the ascending order, we can
4301 use `debug_information' directly. */
4302 for (i
= 0; i
< num_debug_info_entries
; i
++)
4306 num
= debug_information
[i
].num_loc_offsets
;
4307 if (num
> num_loc_list
)
4310 /* Check if we can use `debug_information' directly. */
4311 if (locs_sorted
&& num
!= 0)
4313 if (!seen_first_offset
)
4315 /* This is the first location list. */
4316 last_offset
= debug_information
[i
].loc_offsets
[0];
4318 seen_first_offset
= 1;
4324 for (; j
< num
; j
++)
4327 debug_information
[i
].loc_offsets
[j
])
4332 last_offset
= debug_information
[i
].loc_offsets
[j
];
4337 if (!seen_first_offset
)
4338 error (_("No location lists in .debug_info section!\n"));
4340 /* DWARF sections under Mach-O have non-zero addresses. */
4341 if (debug_information
[first
].num_loc_offsets
> 0
4342 && debug_information
[first
].loc_offsets
[0] != section
->address
)
4343 warn (_("Location lists in %s section start at 0x%s\n"),
4345 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4348 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4349 printf (_("Contents of the %s section:\n\n"), section
->name
);
4350 printf (_(" Offset Begin End Expression\n"));
4352 seen_first_offset
= 0;
4353 for (i
= first
; i
< num_debug_info_entries
; i
++)
4355 unsigned long offset
;
4356 unsigned long base_address
;
4361 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4363 loc_offsets
= debug_information
[i
].loc_offsets
;
4364 qsort (array
, debug_information
[i
].num_loc_offsets
,
4365 sizeof (*array
), loc_offsets_compar
);
4368 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4370 j
= locs_sorted
? k
: array
[k
];
4372 && debug_information
[i
].loc_offsets
[locs_sorted
4373 ? k
- 1 : array
[k
- 1]]
4374 == debug_information
[i
].loc_offsets
[j
])
4376 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4377 /* DWARF sections under Mach-O have non-zero addresses. */
4378 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
4379 next
= section_begin
+ offset
;
4380 base_address
= debug_information
[i
].base_address
;
4382 if (!seen_first_offset
)
4383 seen_first_offset
= 1;
4387 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4388 (unsigned long) (start
- section_begin
),
4389 (unsigned long) (next
- section_begin
));
4390 else if (start
> next
)
4391 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4392 (unsigned long) (start
- section_begin
),
4393 (unsigned long) (next
- section_begin
));
4397 if (offset
>= bytes
)
4399 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4405 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4407 display_loc_list (section
, &start
, i
, offset
, base_address
,
4412 if (start
< section
->start
+ section
->size
)
4413 warn (_("There are %ld unused bytes at the end of section %s\n"),
4414 (long) (section
->start
+ section
->size
- start
), section
->name
);
4421 display_debug_str (struct dwarf_section
*section
,
4422 void *file ATTRIBUTE_UNUSED
)
4424 unsigned char *start
= section
->start
;
4425 unsigned long bytes
= section
->size
;
4426 dwarf_vma addr
= section
->address
;
4430 printf (_("\nThe %s section is empty.\n"), section
->name
);
4434 printf (_("Contents of the %s section:\n\n"), section
->name
);
4442 lbytes
= (bytes
> 16 ? 16 : bytes
);
4444 printf (" 0x%8.8lx ", (unsigned long) addr
);
4446 for (j
= 0; j
< 16; j
++)
4449 printf ("%2.2x", start
[j
]);
4457 for (j
= 0; j
< lbytes
; j
++)
4460 if (k
>= ' ' && k
< 0x80)
4479 display_debug_info (struct dwarf_section
*section
, void *file
)
4481 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4485 display_debug_types (struct dwarf_section
*section
, void *file
)
4487 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4491 display_trace_info (struct dwarf_section
*section
, void *file
)
4493 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4497 display_debug_aranges (struct dwarf_section
*section
,
4498 void *file ATTRIBUTE_UNUSED
)
4500 unsigned char *start
= section
->start
;
4501 unsigned char *end
= start
+ section
->size
;
4503 printf (_("Contents of the %s section:\n\n"), section
->name
);
4505 /* It does not matter if this load fails,
4506 we test for that later on. */
4507 load_debug_info (file
);
4511 unsigned char *hdrptr
;
4512 DWARF2_Internal_ARange arange
;
4513 unsigned char *addr_ranges
;
4516 unsigned char address_size
;
4519 int initial_length_size
;
4523 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4524 if (arange
.ar_length
== 0xffffffff)
4526 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4528 initial_length_size
= 12;
4533 initial_length_size
= 4;
4536 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4537 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4539 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4540 && num_debug_info_entries
> 0
4541 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4542 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4543 (unsigned long) arange
.ar_info_offset
, section
->name
);
4545 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4546 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4548 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4550 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4554 printf (_(" Length: %ld\n"),
4555 (long) arange
.ar_length
);
4556 printf (_(" Version: %d\n"), arange
.ar_version
);
4557 printf (_(" Offset into .debug_info: 0x%lx\n"),
4558 (unsigned long) arange
.ar_info_offset
);
4559 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4560 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4562 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4564 if (address_size
== 0)
4566 error (_("Invalid address size in %s section!\n"),
4571 /* The DWARF spec does not require that the address size be a power
4572 of two, but we do. This will have to change if we ever encounter
4573 an uneven architecture. */
4574 if ((address_size
& (address_size
- 1)) != 0)
4576 warn (_("Pointer size + Segment size is not a power of two.\n"));
4580 if (address_size
> 4)
4581 printf (_("\n Address Length\n"));
4583 printf (_("\n Address Length\n"));
4585 addr_ranges
= hdrptr
;
4587 /* Must pad to an alignment boundary that is twice the address size. */
4588 excess
= (hdrptr
- start
) % (2 * address_size
);
4590 addr_ranges
+= (2 * address_size
) - excess
;
4592 start
+= arange
.ar_length
+ initial_length_size
;
4594 while (addr_ranges
+ 2 * address_size
<= start
)
4596 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4597 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4600 print_dwarf_vma (address
, address_size
);
4601 print_dwarf_vma (length
, address_size
);
4611 /* Comparison function for qsort. */
4613 comp_addr_base (const void * v0
, const void * v1
)
4615 debug_info
* info0
= (debug_info
*) v0
;
4616 debug_info
* info1
= (debug_info
*) v1
;
4617 return info0
->addr_base
- info1
->addr_base
;
4620 /* Display the debug_addr section. */
4622 display_debug_addr (struct dwarf_section
*section
,
4625 debug_info
**debug_addr_info
;
4626 unsigned char *entry
;
4631 if (section
->size
== 0)
4633 printf (_("\nThe %s section is empty.\n"), section
->name
);
4637 if (load_debug_info (file
) == 0)
4639 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4644 printf (_("Contents of the %s section:\n\n"), section
->name
);
4646 debug_addr_info
= (debug_info
**) xmalloc ((num_debug_info_entries
+ 1)
4647 * sizeof (debug_info
*));
4650 for (i
= 0; i
< num_debug_info_entries
; i
++)
4652 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4653 debug_addr_info
[count
++] = &debug_information
[i
];
4656 /* Add a sentinel to make iteration convenient. */
4657 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
4658 debug_addr_info
[count
]->addr_base
= section
->size
;
4660 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
4661 for (i
= 0; i
< count
; i
++)
4664 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
4666 printf (_(" For compilation unit at offset 0x%s:\n"),
4667 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
4669 printf (_("\tIndex\tAddress\n"));
4670 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
4671 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
4675 dwarf_vma base
= byte_get (entry
, address_size
);
4676 printf (_("\t%d:\t"), idx
);
4677 print_dwarf_vma (base
, address_size
);
4679 entry
+= address_size
;
4685 free (debug_addr_info
);
4689 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4691 display_debug_str_offsets (struct dwarf_section
*section
,
4692 void *file ATTRIBUTE_UNUSED
)
4694 if (section
->size
== 0)
4696 printf (_("\nThe %s section is empty.\n"), section
->name
);
4699 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
4700 what the offset size is for this section. */
4704 /* Each debug_information[x].range_lists[y] gets this representation for
4705 sorting purposes. */
4709 /* The debug_information[x].range_lists[y] value. */
4710 unsigned long ranges_offset
;
4712 /* Original debug_information to find parameters of the data. */
4713 debug_info
*debug_info_p
;
4716 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4719 range_entry_compar (const void *ap
, const void *bp
)
4721 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
4722 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
4723 const unsigned long a
= a_re
->ranges_offset
;
4724 const unsigned long b
= b_re
->ranges_offset
;
4726 return (a
> b
) - (b
> a
);
4730 display_debug_ranges (struct dwarf_section
*section
,
4731 void *file ATTRIBUTE_UNUSED
)
4733 unsigned char *start
= section
->start
;
4734 unsigned char *last_start
= start
;
4735 unsigned long bytes
= section
->size
;
4736 unsigned char *section_begin
= start
;
4737 unsigned char *finish
= start
+ bytes
;
4738 unsigned int num_range_list
, i
;
4739 struct range_entry
*range_entries
, *range_entry_fill
;
4743 printf (_("\nThe %s section is empty.\n"), section
->name
);
4747 if (load_debug_info (file
) == 0)
4749 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4755 for (i
= 0; i
< num_debug_info_entries
; i
++)
4756 num_range_list
+= debug_information
[i
].num_range_lists
;
4758 if (num_range_list
== 0)
4760 /* This can happen when the file was compiled with -gsplit-debug
4761 which removes references to range lists from the primary .o file. */
4762 printf (_("No range lists in .debug_info section.\n"));
4766 range_entries
= (struct range_entry
*)
4767 xmalloc (sizeof (*range_entries
) * num_range_list
);
4768 range_entry_fill
= range_entries
;
4770 for (i
= 0; i
< num_debug_info_entries
; i
++)
4772 debug_info
*debug_info_p
= &debug_information
[i
];
4775 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
4777 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
4778 range_entry_fill
->debug_info_p
= debug_info_p
;
4783 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
4784 range_entry_compar
);
4786 /* DWARF sections under Mach-O have non-zero addresses. */
4787 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= section
->address
)
4788 warn (_("Range lists in %s section start at 0x%lx\n"),
4789 section
->name
, range_entries
[0].ranges_offset
);
4791 printf (_("Contents of the %s section:\n\n"), section
->name
);
4792 printf (_(" Offset Begin End\n"));
4794 for (i
= 0; i
< num_range_list
; i
++)
4796 struct range_entry
*range_entry
= &range_entries
[i
];
4797 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
4798 unsigned int pointer_size
;
4799 unsigned long offset
;
4800 unsigned char *next
;
4801 unsigned long base_address
;
4803 pointer_size
= debug_info_p
->pointer_size
;
4805 /* DWARF sections under Mach-O have non-zero addresses. */
4806 offset
= range_entry
->ranges_offset
- section
->address
;
4807 next
= section_begin
+ offset
;
4808 base_address
= debug_info_p
->base_address
;
4810 if (dwarf_check
!= 0 && i
> 0)
4813 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4814 (unsigned long) (start
- section_begin
),
4815 (unsigned long) (next
- section_begin
), section
->name
);
4816 else if (start
> next
)
4818 if (next
== last_start
)
4820 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4821 (unsigned long) (start
- section_begin
),
4822 (unsigned long) (next
- section_begin
), section
->name
);
4828 while (start
< finish
)
4833 /* Note: we use sign extension here in order to be sure that
4834 we can detect the -1 escape value. Sign extension into the
4835 top 32 bits of a 32-bit address will not affect the values
4836 that we display since we always show hex values, and always
4837 the bottom 32-bits. */
4838 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
4839 if (start
>= finish
)
4841 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
4843 printf (" %8.8lx ", offset
);
4845 if (begin
== 0 && end
== 0)
4847 printf (_("<End of list>\n"));
4851 /* Check base address specifiers. */
4852 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4855 print_dwarf_vma (begin
, pointer_size
);
4856 print_dwarf_vma (end
, pointer_size
);
4857 printf ("(base address)\n");
4861 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4862 print_dwarf_vma (end
+ base_address
, pointer_size
);
4865 fputs (_("(start == end)"), stdout
);
4866 else if (begin
> end
)
4867 fputs (_("(start > end)"), stdout
);
4874 free (range_entries
);
4879 typedef struct Frame_Chunk
4881 struct Frame_Chunk
*next
;
4882 unsigned char *chunk_start
;
4884 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
4885 short int *col_type
;
4888 unsigned int code_factor
;
4890 unsigned long pc_begin
;
4891 unsigned long pc_range
;
4895 unsigned char fde_encoding
;
4896 unsigned char cfa_exp
;
4897 unsigned char ptr_size
;
4898 unsigned char segment_size
;
4902 static const char *const *dwarf_regnames
;
4903 static unsigned int dwarf_regnames_count
;
4905 /* A marker for a col_type that means this column was never referenced
4906 in the frame info. */
4907 #define DW_CFA_unreferenced (-1)
4909 /* Return 0 if not more space is needed, 1 if more space is needed,
4910 -1 for invalid reg. */
4913 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
4915 int prev
= fc
->ncols
;
4917 if (reg
< (unsigned int) fc
->ncols
)
4920 if (dwarf_regnames_count
4921 && reg
> dwarf_regnames_count
)
4924 fc
->ncols
= reg
+ 1;
4925 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
4926 sizeof (short int));
4927 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
4929 while (prev
< fc
->ncols
)
4931 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
4932 fc
->col_offset
[prev
] = 0;
4938 static const char *const dwarf_regnames_i386
[] =
4940 "eax", "ecx", "edx", "ebx",
4941 "esp", "ebp", "esi", "edi",
4942 "eip", "eflags", NULL
,
4943 "st0", "st1", "st2", "st3",
4944 "st4", "st5", "st6", "st7",
4946 "xmm0", "xmm1", "xmm2", "xmm3",
4947 "xmm4", "xmm5", "xmm6", "xmm7",
4948 "mm0", "mm1", "mm2", "mm3",
4949 "mm4", "mm5", "mm6", "mm7",
4950 "fcw", "fsw", "mxcsr",
4951 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
4956 init_dwarf_regnames_i386 (void)
4958 dwarf_regnames
= dwarf_regnames_i386
;
4959 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
4962 static const char *const dwarf_regnames_x86_64
[] =
4964 "rax", "rdx", "rcx", "rbx",
4965 "rsi", "rdi", "rbp", "rsp",
4966 "r8", "r9", "r10", "r11",
4967 "r12", "r13", "r14", "r15",
4969 "xmm0", "xmm1", "xmm2", "xmm3",
4970 "xmm4", "xmm5", "xmm6", "xmm7",
4971 "xmm8", "xmm9", "xmm10", "xmm11",
4972 "xmm12", "xmm13", "xmm14", "xmm15",
4973 "st0", "st1", "st2", "st3",
4974 "st4", "st5", "st6", "st7",
4975 "mm0", "mm1", "mm2", "mm3",
4976 "mm4", "mm5", "mm6", "mm7",
4978 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
4979 "fs.base", "gs.base", NULL
, NULL
,
4981 "mxcsr", "fcw", "fsw"
4985 init_dwarf_regnames_x86_64 (void)
4987 dwarf_regnames
= dwarf_regnames_x86_64
;
4988 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
4992 init_dwarf_regnames (unsigned int e_machine
)
4998 init_dwarf_regnames_i386 ();
5004 init_dwarf_regnames_x86_64 ();
5013 regname (unsigned int regno
, int row
)
5015 static char reg
[64];
5017 && regno
< dwarf_regnames_count
5018 && dwarf_regnames
[regno
] != NULL
)
5021 return dwarf_regnames
[regno
];
5022 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5023 dwarf_regnames
[regno
]);
5026 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5031 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
5036 if (*max_regs
< fc
->ncols
)
5037 *max_regs
= fc
->ncols
;
5039 if (*need_col_headers
)
5041 static const char *sloc
= " LOC";
5043 *need_col_headers
= 0;
5045 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5047 for (r
= 0; r
< *max_regs
; r
++)
5048 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5053 printf ("%-5s ", regname (r
, 1));
5059 printf ("%0*lx ", eh_addr_size
* 2, fc
->pc_begin
);
5061 strcpy (tmp
, "exp");
5063 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5064 printf ("%-8s ", tmp
);
5066 for (r
= 0; r
< fc
->ncols
; r
++)
5068 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5070 switch (fc
->col_type
[r
])
5072 case DW_CFA_undefined
:
5075 case DW_CFA_same_value
:
5079 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5081 case DW_CFA_val_offset
:
5082 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5084 case DW_CFA_register
:
5085 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5087 case DW_CFA_expression
:
5088 strcpy (tmp
, "exp");
5090 case DW_CFA_val_expression
:
5091 strcpy (tmp
, "vexp");
5094 strcpy (tmp
, "n/a");
5097 printf ("%-5s ", tmp
);
5103 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end);
5104 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5105 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5108 display_debug_frames (struct dwarf_section
*section
,
5109 void *file ATTRIBUTE_UNUSED
)
5111 unsigned char *start
= section
->start
;
5112 unsigned char *end
= start
+ section
->size
;
5113 unsigned char *section_start
= start
;
5114 Frame_Chunk
*chunks
= 0;
5115 Frame_Chunk
*remembered_state
= 0;
5117 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5118 unsigned int length_return
;
5120 const char *bad_reg
= _("bad register: ");
5121 int saved_eh_addr_size
= eh_addr_size
;
5123 printf (_("Contents of the %s section:\n"), section
->name
);
5127 unsigned char *saved_start
;
5128 unsigned char *block_end
;
5129 unsigned long length
;
5130 unsigned long cie_id
;
5133 int need_col_headers
= 1;
5134 unsigned char *augmentation_data
= NULL
;
5135 unsigned long augmentation_data_len
= 0;
5136 int encoded_ptr_size
= saved_eh_addr_size
;
5138 int initial_length_size
;
5140 saved_start
= start
;
5142 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5145 printf ("\n%08lx ZERO terminator\n\n",
5146 (unsigned long)(saved_start
- section_start
));
5150 if (length
== 0xffffffff)
5152 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5154 initial_length_size
= 12;
5159 initial_length_size
= 4;
5162 block_end
= saved_start
+ length
+ initial_length_size
;
5163 if (block_end
> end
)
5165 warn ("Invalid length %#08lx in FDE at %#08lx\n",
5166 length
, (unsigned long)(saved_start
- section_start
));
5170 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5172 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
5176 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5177 memset (fc
, 0, sizeof (Frame_Chunk
));
5181 fc
->chunk_start
= saved_start
;
5183 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5184 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5185 frame_need_space (fc
, max_regs
- 1);
5189 fc
->augmentation
= (char *) start
;
5190 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
5192 if (strcmp (fc
->augmentation
, "eh") == 0)
5193 start
+= eh_addr_size
;
5197 GET (fc
->ptr_size
, 1);
5198 GET (fc
->segment_size
, 1);
5199 eh_addr_size
= fc
->ptr_size
;
5203 fc
->ptr_size
= eh_addr_size
;
5204 fc
->segment_size
= 0;
5206 fc
->code_factor
= LEB ();
5207 fc
->data_factor
= SLEB ();
5217 if (fc
->augmentation
[0] == 'z')
5219 augmentation_data_len
= LEB ();
5220 augmentation_data
= start
;
5221 start
+= augmentation_data_len
;
5225 if (do_debug_frames_interp
)
5226 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
5227 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
5228 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
5232 printf ("\n%08lx %08lx %08lx CIE\n",
5233 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
5234 printf (" Version: %d\n", version
);
5235 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5238 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5239 printf (" Segment Size: %u\n", fc
->segment_size
);
5241 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5242 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5243 printf (" Return address column: %d\n", fc
->ra
);
5245 if (augmentation_data_len
)
5248 printf (" Augmentation data: ");
5249 for (i
= 0; i
< augmentation_data_len
; ++i
)
5250 printf (" %02x", augmentation_data
[i
]);
5256 if (augmentation_data_len
)
5258 unsigned char *p
, *q
;
5259 p
= (unsigned char *) fc
->augmentation
+ 1;
5260 q
= augmentation_data
;
5267 q
+= 1 + size_of_encoded_value (*q
);
5269 fc
->fde_encoding
= *q
++;
5277 if (fc
->fde_encoding
)
5278 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5281 frame_need_space (fc
, fc
->ra
);
5285 unsigned char *look_for
;
5286 static Frame_Chunk fde_fc
;
5287 unsigned long segment_selector
;
5290 memset (fc
, 0, sizeof (Frame_Chunk
));
5292 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
5294 for (cie
= chunks
; cie
; cie
= cie
->next
)
5295 if (cie
->chunk_start
== look_for
)
5300 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
5301 cie_id
, (unsigned long)(saved_start
- section_start
));
5303 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5304 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5305 frame_need_space (fc
, max_regs
- 1);
5307 fc
->augmentation
= "";
5308 fc
->fde_encoding
= 0;
5309 fc
->ptr_size
= eh_addr_size
;
5310 fc
->segment_size
= 0;
5314 fc
->ncols
= cie
->ncols
;
5315 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5316 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5317 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5318 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5319 fc
->augmentation
= cie
->augmentation
;
5320 fc
->ptr_size
= cie
->ptr_size
;
5321 eh_addr_size
= cie
->ptr_size
;
5322 fc
->segment_size
= cie
->segment_size
;
5323 fc
->code_factor
= cie
->code_factor
;
5324 fc
->data_factor
= cie
->data_factor
;
5325 fc
->cfa_reg
= cie
->cfa_reg
;
5326 fc
->cfa_offset
= cie
->cfa_offset
;
5328 frame_need_space (fc
, max_regs
- 1);
5329 fc
->fde_encoding
= cie
->fde_encoding
;
5332 if (fc
->fde_encoding
)
5333 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5335 segment_selector
= 0;
5336 if (fc
->segment_size
)
5338 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5340 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
, section
);
5341 start
+= encoded_ptr_size
;
5343 /* FIXME: It appears that sometimes the final pc_range value is
5344 encoded in less than encoded_ptr_size bytes. See the x86_64
5345 run of the "objcopy on compressed debug sections" test for an
5347 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5349 if (cie
->augmentation
[0] == 'z')
5351 augmentation_data_len
= LEB ();
5352 augmentation_data
= start
;
5353 start
+= augmentation_data_len
;
5356 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
5357 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
5358 (unsigned long)(cie
->chunk_start
- section_start
));
5359 if (fc
->segment_size
)
5360 printf ("%04lx:", segment_selector
);
5361 printf ("%08lx..%08lx\n", fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
5362 if (! do_debug_frames_interp
&& augmentation_data_len
)
5366 printf (" Augmentation data: ");
5367 for (i
= 0; i
< augmentation_data_len
; ++i
)
5368 printf (" %02x", augmentation_data
[i
]);
5374 /* At this point, fc is the current chunk, cie (if any) is set, and
5375 we're about to interpret instructions for the chunk. */
5376 /* ??? At present we need to do this always, since this sizes the
5377 fc->col_type and fc->col_offset arrays, which we write into always.
5378 We should probably split the interpreted and non-interpreted bits
5379 into two different routines, since there's so much that doesn't
5380 really overlap between them. */
5381 if (1 || do_debug_frames_interp
)
5383 /* Start by making a pass over the chunk, allocating storage
5384 and taking note of what registers are used. */
5385 unsigned char *tmp
= start
;
5387 while (start
< block_end
)
5390 unsigned long reg
, temp
;
5397 /* Warning: if you add any more cases to this switch, be
5398 sure to add them to the corresponding switch below. */
5401 case DW_CFA_advance_loc
:
5405 if (frame_need_space (fc
, opa
) >= 0)
5406 fc
->col_type
[opa
] = DW_CFA_undefined
;
5408 case DW_CFA_restore
:
5409 if (frame_need_space (fc
, opa
) >= 0)
5410 fc
->col_type
[opa
] = DW_CFA_undefined
;
5412 case DW_CFA_set_loc
:
5413 start
+= encoded_ptr_size
;
5415 case DW_CFA_advance_loc1
:
5418 case DW_CFA_advance_loc2
:
5421 case DW_CFA_advance_loc4
:
5424 case DW_CFA_offset_extended
:
5425 case DW_CFA_val_offset
:
5426 reg
= LEB (); LEB ();
5427 if (frame_need_space (fc
, reg
) >= 0)
5428 fc
->col_type
[reg
] = DW_CFA_undefined
;
5430 case DW_CFA_restore_extended
:
5432 frame_need_space (fc
, reg
);
5433 if (frame_need_space (fc
, reg
) >= 0)
5434 fc
->col_type
[reg
] = DW_CFA_undefined
;
5436 case DW_CFA_undefined
:
5438 if (frame_need_space (fc
, reg
) >= 0)
5439 fc
->col_type
[reg
] = DW_CFA_undefined
;
5441 case DW_CFA_same_value
:
5443 if (frame_need_space (fc
, reg
) >= 0)
5444 fc
->col_type
[reg
] = DW_CFA_undefined
;
5446 case DW_CFA_register
:
5447 reg
= LEB (); LEB ();
5448 if (frame_need_space (fc
, reg
) >= 0)
5449 fc
->col_type
[reg
] = DW_CFA_undefined
;
5451 case DW_CFA_def_cfa
:
5454 case DW_CFA_def_cfa_register
:
5457 case DW_CFA_def_cfa_offset
:
5460 case DW_CFA_def_cfa_expression
:
5464 case DW_CFA_expression
:
5465 case DW_CFA_val_expression
:
5469 if (frame_need_space (fc
, reg
) >= 0)
5470 fc
->col_type
[reg
] = DW_CFA_undefined
;
5472 case DW_CFA_offset_extended_sf
:
5473 case DW_CFA_val_offset_sf
:
5474 reg
= LEB (); SLEB ();
5475 if (frame_need_space (fc
, reg
) >= 0)
5476 fc
->col_type
[reg
] = DW_CFA_undefined
;
5478 case DW_CFA_def_cfa_sf
:
5481 case DW_CFA_def_cfa_offset_sf
:
5484 case DW_CFA_MIPS_advance_loc8
:
5487 case DW_CFA_GNU_args_size
:
5490 case DW_CFA_GNU_negative_offset_extended
:
5491 reg
= LEB (); LEB ();
5492 if (frame_need_space (fc
, reg
) >= 0)
5493 fc
->col_type
[reg
] = DW_CFA_undefined
;
5502 /* Now we know what registers are used, make a second pass over
5503 the chunk, this time actually printing out the info. */
5505 while (start
< block_end
)
5508 unsigned long ul
, reg
, roffs
;
5511 const char *reg_prefix
= "";
5518 /* Warning: if you add any more cases to this switch, be
5519 sure to add them to the corresponding switch above. */
5522 case DW_CFA_advance_loc
:
5523 if (do_debug_frames_interp
)
5524 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5526 printf (" DW_CFA_advance_loc: %d to %08lx\n",
5527 opa
* fc
->code_factor
,
5528 fc
->pc_begin
+ opa
* fc
->code_factor
);
5529 fc
->pc_begin
+= opa
* fc
->code_factor
;
5534 if (opa
>= (unsigned int) fc
->ncols
)
5535 reg_prefix
= bad_reg
;
5536 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5537 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
5538 reg_prefix
, regname (opa
, 0),
5539 roffs
* fc
->data_factor
);
5540 if (*reg_prefix
== '\0')
5542 fc
->col_type
[opa
] = DW_CFA_offset
;
5543 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
5547 case DW_CFA_restore
:
5548 if (opa
>= (unsigned int) cie
->ncols
5549 || opa
>= (unsigned int) fc
->ncols
)
5550 reg_prefix
= bad_reg
;
5551 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5552 printf (" DW_CFA_restore: %s%s\n",
5553 reg_prefix
, regname (opa
, 0));
5554 if (*reg_prefix
== '\0')
5556 fc
->col_type
[opa
] = cie
->col_type
[opa
];
5557 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
5558 if (do_debug_frames_interp
5559 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
5560 fc
->col_type
[opa
] = DW_CFA_undefined
;
5564 case DW_CFA_set_loc
:
5565 vma
= get_encoded_value (start
, fc
->fde_encoding
, section
);
5566 start
+= encoded_ptr_size
;
5567 if (do_debug_frames_interp
)
5568 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5570 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
5574 case DW_CFA_advance_loc1
:
5575 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
5576 if (do_debug_frames_interp
)
5577 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5579 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
5580 ofs
* fc
->code_factor
,
5581 fc
->pc_begin
+ ofs
* fc
->code_factor
);
5582 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5585 case DW_CFA_advance_loc2
:
5586 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, end
);
5587 if (do_debug_frames_interp
)
5588 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5590 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
5591 ofs
* fc
->code_factor
,
5592 fc
->pc_begin
+ ofs
* fc
->code_factor
);
5593 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5596 case DW_CFA_advance_loc4
:
5597 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, end
);
5598 if (do_debug_frames_interp
)
5599 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5601 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
5602 ofs
* fc
->code_factor
,
5603 fc
->pc_begin
+ ofs
* fc
->code_factor
);
5604 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5607 case DW_CFA_offset_extended
:
5610 if (reg
>= (unsigned int) fc
->ncols
)
5611 reg_prefix
= bad_reg
;
5612 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5613 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5614 reg_prefix
, regname (reg
, 0),
5615 roffs
* fc
->data_factor
);
5616 if (*reg_prefix
== '\0')
5618 fc
->col_type
[reg
] = DW_CFA_offset
;
5619 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
5623 case DW_CFA_val_offset
:
5626 if (reg
>= (unsigned int) fc
->ncols
)
5627 reg_prefix
= bad_reg
;
5628 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5629 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
5630 reg_prefix
, regname (reg
, 0),
5631 roffs
* fc
->data_factor
);
5632 if (*reg_prefix
== '\0')
5634 fc
->col_type
[reg
] = DW_CFA_val_offset
;
5635 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
5639 case DW_CFA_restore_extended
:
5641 if (reg
>= (unsigned int) cie
->ncols
5642 || reg
>= (unsigned int) fc
->ncols
)
5643 reg_prefix
= bad_reg
;
5644 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5645 printf (" DW_CFA_restore_extended: %s%s\n",
5646 reg_prefix
, regname (reg
, 0));
5647 if (*reg_prefix
== '\0')
5649 fc
->col_type
[reg
] = cie
->col_type
[reg
];
5650 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
5654 case DW_CFA_undefined
:
5656 if (reg
>= (unsigned int) fc
->ncols
)
5657 reg_prefix
= bad_reg
;
5658 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5659 printf (" DW_CFA_undefined: %s%s\n",
5660 reg_prefix
, regname (reg
, 0));
5661 if (*reg_prefix
== '\0')
5663 fc
->col_type
[reg
] = DW_CFA_undefined
;
5664 fc
->col_offset
[reg
] = 0;
5668 case DW_CFA_same_value
:
5670 if (reg
>= (unsigned int) fc
->ncols
)
5671 reg_prefix
= bad_reg
;
5672 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5673 printf (" DW_CFA_same_value: %s%s\n",
5674 reg_prefix
, regname (reg
, 0));
5675 if (*reg_prefix
== '\0')
5677 fc
->col_type
[reg
] = DW_CFA_same_value
;
5678 fc
->col_offset
[reg
] = 0;
5682 case DW_CFA_register
:
5685 if (reg
>= (unsigned int) fc
->ncols
)
5686 reg_prefix
= bad_reg
;
5687 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5689 printf (" DW_CFA_register: %s%s in ",
5690 reg_prefix
, regname (reg
, 0));
5691 puts (regname (roffs
, 0));
5693 if (*reg_prefix
== '\0')
5695 fc
->col_type
[reg
] = DW_CFA_register
;
5696 fc
->col_offset
[reg
] = roffs
;
5700 case DW_CFA_remember_state
:
5701 if (! do_debug_frames_interp
)
5702 printf (" DW_CFA_remember_state\n");
5703 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5704 rs
->ncols
= fc
->ncols
;
5705 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
5706 sizeof (short int));
5707 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (int));
5708 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
5709 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
5710 rs
->next
= remembered_state
;
5711 remembered_state
= rs
;
5714 case DW_CFA_restore_state
:
5715 if (! do_debug_frames_interp
)
5716 printf (" DW_CFA_restore_state\n");
5717 rs
= remembered_state
;
5720 remembered_state
= rs
->next
;
5721 frame_need_space (fc
, rs
->ncols
- 1);
5722 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
5723 memcpy (fc
->col_offset
, rs
->col_offset
,
5724 rs
->ncols
* sizeof (int));
5725 free (rs
->col_type
);
5726 free (rs
->col_offset
);
5729 else if (do_debug_frames_interp
)
5730 printf ("Mismatched DW_CFA_restore_state\n");
5733 case DW_CFA_def_cfa
:
5734 fc
->cfa_reg
= LEB ();
5735 fc
->cfa_offset
= LEB ();
5737 if (! do_debug_frames_interp
)
5738 printf (" DW_CFA_def_cfa: %s ofs %d\n",
5739 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
5742 case DW_CFA_def_cfa_register
:
5743 fc
->cfa_reg
= LEB ();
5745 if (! do_debug_frames_interp
)
5746 printf (" DW_CFA_def_cfa_register: %s\n",
5747 regname (fc
->cfa_reg
, 0));
5750 case DW_CFA_def_cfa_offset
:
5751 fc
->cfa_offset
= LEB ();
5752 if (! do_debug_frames_interp
)
5753 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
5757 if (! do_debug_frames_interp
)
5758 printf (" DW_CFA_nop\n");
5761 case DW_CFA_def_cfa_expression
:
5763 if (! do_debug_frames_interp
)
5765 printf (" DW_CFA_def_cfa_expression (");
5766 decode_location_expression (start
, eh_addr_size
, 0, -1,
5774 case DW_CFA_expression
:
5777 if (reg
>= (unsigned int) fc
->ncols
)
5778 reg_prefix
= bad_reg
;
5779 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5781 printf (" DW_CFA_expression: %s%s (",
5782 reg_prefix
, regname (reg
, 0));
5783 decode_location_expression (start
, eh_addr_size
, 0, -1,
5787 if (*reg_prefix
== '\0')
5788 fc
->col_type
[reg
] = DW_CFA_expression
;
5792 case DW_CFA_val_expression
:
5795 if (reg
>= (unsigned int) fc
->ncols
)
5796 reg_prefix
= bad_reg
;
5797 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5799 printf (" DW_CFA_val_expression: %s%s (",
5800 reg_prefix
, regname (reg
, 0));
5801 decode_location_expression (start
, eh_addr_size
, 0, -1,
5805 if (*reg_prefix
== '\0')
5806 fc
->col_type
[reg
] = DW_CFA_val_expression
;
5810 case DW_CFA_offset_extended_sf
:
5813 if (frame_need_space (fc
, reg
) < 0)
5814 reg_prefix
= bad_reg
;
5815 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5816 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5817 reg_prefix
, regname (reg
, 0),
5818 l
* fc
->data_factor
);
5819 if (*reg_prefix
== '\0')
5821 fc
->col_type
[reg
] = DW_CFA_offset
;
5822 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
5826 case DW_CFA_val_offset_sf
:
5829 if (frame_need_space (fc
, reg
) < 0)
5830 reg_prefix
= bad_reg
;
5831 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5832 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5833 reg_prefix
, regname (reg
, 0),
5834 l
* fc
->data_factor
);
5835 if (*reg_prefix
== '\0')
5837 fc
->col_type
[reg
] = DW_CFA_val_offset
;
5838 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
5842 case DW_CFA_def_cfa_sf
:
5843 fc
->cfa_reg
= LEB ();
5844 fc
->cfa_offset
= SLEB ();
5845 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
5847 if (! do_debug_frames_interp
)
5848 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
5849 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
5852 case DW_CFA_def_cfa_offset_sf
:
5853 fc
->cfa_offset
= SLEB ();
5854 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
5855 if (! do_debug_frames_interp
)
5856 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
5859 case DW_CFA_MIPS_advance_loc8
:
5860 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, end
);
5861 if (do_debug_frames_interp
)
5862 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5864 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
5865 ofs
* fc
->code_factor
,
5866 fc
->pc_begin
+ ofs
* fc
->code_factor
);
5867 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5870 case DW_CFA_GNU_window_save
:
5871 if (! do_debug_frames_interp
)
5872 printf (" DW_CFA_GNU_window_save\n");
5875 case DW_CFA_GNU_args_size
:
5877 if (! do_debug_frames_interp
)
5878 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
5881 case DW_CFA_GNU_negative_offset_extended
:
5884 if (frame_need_space (fc
, reg
) < 0)
5885 reg_prefix
= bad_reg
;
5886 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5887 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5888 reg_prefix
, regname (reg
, 0),
5889 l
* fc
->data_factor
);
5890 if (*reg_prefix
== '\0')
5892 fc
->col_type
[reg
] = DW_CFA_offset
;
5893 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
5898 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
5899 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
5901 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
5906 if (do_debug_frames_interp
)
5907 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5910 eh_addr_size
= saved_eh_addr_size
;
5923 display_gdb_index (struct dwarf_section
*section
,
5924 void *file ATTRIBUTE_UNUSED
)
5926 unsigned char *start
= section
->start
;
5928 uint32_t cu_list_offset
, tu_list_offset
;
5929 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
5930 unsigned int cu_list_elements
, tu_list_elements
;
5931 unsigned int address_table_size
, symbol_table_slots
;
5932 unsigned char *cu_list
, *tu_list
;
5933 unsigned char *address_table
, *symbol_table
, *constant_pool
;
5936 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
5938 printf (_("Contents of the %s section:\n"), section
->name
);
5940 if (section
->size
< 6 * sizeof (uint32_t))
5942 warn (_("Truncated header in the %s section.\n"), section
->name
);
5946 version
= byte_get_little_endian (start
, 4);
5947 printf (_("Version %ld\n"), (long) version
);
5949 /* Prior versions are obsolete, and future versions may not be
5950 backwards compatible. */
5951 if (version
< 3 || version
> 8)
5953 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
5957 warn (_("The address table data in version 3 may be wrong.\n"));
5959 warn (_("Version 4 does not support case insensitive lookups.\n"));
5961 warn (_("Version 5 does not include inlined functions.\n"));
5963 warn (_("Version 6 does not include symbol attributes.\n"));
5964 /* Version 7 indices generated by Gold have bad type unit references,
5965 PR binutils/15021. But we don't know if the index was generated by
5966 Gold or not, so to avoid worrying users with gdb-generated indices
5967 we say nothing for version 7 here. */
5969 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
5970 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
5971 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
5972 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
5973 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
5975 if (cu_list_offset
> section
->size
5976 || tu_list_offset
> section
->size
5977 || address_table_offset
> section
->size
5978 || symbol_table_offset
> section
->size
5979 || constant_pool_offset
> section
->size
)
5981 warn (_("Corrupt header in the %s section.\n"), section
->name
);
5985 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
5986 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
5987 address_table_size
= symbol_table_offset
- address_table_offset
;
5988 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
5990 cu_list
= start
+ cu_list_offset
;
5991 tu_list
= start
+ tu_list_offset
;
5992 address_table
= start
+ address_table_offset
;
5993 symbol_table
= start
+ symbol_table_offset
;
5994 constant_pool
= start
+ constant_pool_offset
;
5996 printf (_("\nCU table:\n"));
5997 for (i
= 0; i
< cu_list_elements
; i
+= 2)
5999 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6000 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6002 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6003 (unsigned long) cu_offset
,
6004 (unsigned long) (cu_offset
+ cu_length
- 1));
6007 printf (_("\nTU table:\n"));
6008 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6010 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6011 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6012 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6014 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6015 (unsigned long) tu_offset
,
6016 (unsigned long) type_offset
);
6017 print_dwarf_vma (signature
, 8);
6021 printf (_("\nAddress table:\n"));
6022 for (i
= 0; i
< address_table_size
; i
+= 2 * 8 + 4)
6024 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6025 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6026 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6028 print_dwarf_vma (low
, 8);
6029 print_dwarf_vma (high
, 8);
6030 printf (_("%lu\n"), (unsigned long) cu_index
);
6033 printf (_("\nSymbol table:\n"));
6034 for (i
= 0; i
< symbol_table_slots
; ++i
)
6036 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6037 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6038 uint32_t num_cus
, cu
;
6040 if (name_offset
!= 0
6041 || cu_vector_offset
!= 0)
6045 printf ("[%3u] %s:", i
, constant_pool
+ name_offset
);
6046 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
6049 for (j
= 0; j
< num_cus
; ++j
)
6052 gdb_index_symbol_kind kind
;
6054 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6055 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6056 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6057 cu
= GDB_INDEX_CU_VALUE (cu
);
6058 /* Convert to TU number if it's for a type unit. */
6059 if (cu
>= cu_list_elements
/ 2)
6060 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6061 (unsigned long) (cu
- cu_list_elements
/ 2));
6063 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6067 case GDB_INDEX_SYMBOL_KIND_NONE
:
6068 printf (_(" [no symbol information]"));
6070 case GDB_INDEX_SYMBOL_KIND_TYPE
:
6072 ? _(" [static type]")
6073 : _(" [global type]"));
6075 case GDB_INDEX_SYMBOL_KIND_VARIABLE
:
6077 ? _(" [static variable]")
6078 : _(" [global variable]"));
6080 case GDB_INDEX_SYMBOL_KIND_FUNCTION
:
6082 ? _(" [static function]")
6083 : _(" [global function]"));
6085 case GDB_INDEX_SYMBOL_KIND_OTHER
:
6087 ? _(" [static other]")
6088 : _(" [global other]"));
6092 ? _(" [static unknown: %d]")
6093 : _(" [global unknown: %d]"),
6108 /* Pre-allocate enough space for the CU/TU sets needed. */
6111 prealloc_cu_tu_list (unsigned int nshndx
)
6113 if (shndx_pool
== NULL
)
6115 shndx_pool_size
= nshndx
;
6116 shndx_pool_used
= 0;
6117 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6118 sizeof (unsigned int));
6122 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6123 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6124 sizeof (unsigned int));
6129 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6131 if (shndx_pool_used
>= shndx_pool_size
)
6133 error (_("Internal error: out of space in the shndx pool.\n"));
6136 shndx_pool
[shndx_pool_used
++] = shndx
;
6140 end_cu_tu_entry (void)
6142 if (shndx_pool_used
>= shndx_pool_size
)
6144 error (_("Internal error: out of space in the shndx pool.\n"));
6147 shndx_pool
[shndx_pool_used
++] = 0;
6150 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6153 get_DW_SECT_short_name (unsigned int dw_sect
)
6155 static char buf
[16];
6163 case DW_SECT_ABBREV
:
6169 case DW_SECT_STR_OFFSETS
:
6171 case DW_SECT_MACINFO
:
6179 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6183 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6184 These sections are extensions for Fission.
6185 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6188 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6190 unsigned char *phdr
= section
->start
;
6191 unsigned char *limit
= phdr
+ section
->size
;
6192 unsigned char *phash
;
6193 unsigned char *pindex
;
6194 unsigned char *ppool
;
6195 unsigned int version
;
6196 unsigned int ncols
= 0;
6198 unsigned int nslots
;
6201 dwarf_vma signature_high
;
6202 dwarf_vma signature_low
;
6205 version
= byte_get (phdr
, 4);
6207 ncols
= byte_get (phdr
+ 4, 4);
6208 nused
= byte_get (phdr
+ 8, 4);
6209 nslots
= byte_get (phdr
+ 12, 4);
6211 pindex
= phash
+ nslots
* 8;
6212 ppool
= pindex
+ nslots
* 4;
6216 printf (_("Contents of the %s section:\n\n"), section
->name
);
6217 printf (_(" Version: %d\n"), version
);
6219 printf (_(" Number of columns: %d\n"), ncols
);
6220 printf (_(" Number of used entries: %d\n"), nused
);
6221 printf (_(" Number of slots: %d\n\n"), nslots
);
6226 warn (_("Section %s too small for %d hash table entries\n"),
6227 section
->name
, nslots
);
6234 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6235 for (i
= 0; i
< nslots
; i
++)
6237 unsigned char *shndx_list
;
6240 byte_get_64 (phash
, &signature_high
, &signature_low
);
6241 if (signature_high
!= 0 || signature_low
!= 0)
6243 j
= byte_get (pindex
, 4);
6244 shndx_list
= ppool
+ j
* 4;
6246 printf (_(" [%3d] Signature: 0x%s Sections: "),
6247 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6248 buf
, sizeof (buf
)));
6251 if (shndx_list
>= limit
)
6253 warn (_("Section %s too small for shndx pool\n"),
6257 shndx
= byte_get (shndx_list
, 4);
6261 printf (" %d", shndx
);
6263 add_shndx_to_cu_tu_entry (shndx
);
6275 else if (version
== 2)
6278 unsigned int dw_sect
;
6279 unsigned char *ph
= phash
;
6280 unsigned char *pi
= pindex
;
6281 unsigned char *poffsets
= ppool
+ ncols
* 4;
6282 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
6283 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
6284 bfd_boolean is_tu_index
;
6285 struct cu_tu_set
*this_set
= NULL
;
6287 unsigned char *prow
;
6289 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
6293 warn (_("Section %s too small for offset and size tables\n"),
6300 printf (_(" Offset table\n"));
6301 printf (" slot %-16s ",
6302 is_tu_index
? _("signature") : _("dwo_id"));
6309 tu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6315 cu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6321 for (j
= 0; j
< ncols
; j
++)
6323 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6324 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
6328 for (i
= 0; i
< nslots
; i
++)
6330 byte_get_64 (ph
, &signature_high
, &signature_low
);
6331 row
= byte_get (pi
, 4);
6335 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
6336 prow
= poffsets
+ (row
- 1) * ncols
* 4;
6338 printf (_(" [%3d] 0x%s"),
6339 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6340 buf
, sizeof (buf
)));
6341 for (j
= 0; j
< ncols
; j
++)
6343 val
= byte_get (prow
+ j
* 4, 4);
6345 printf (" %8d", val
);
6348 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6349 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
6364 printf (_(" Size table\n"));
6365 printf (" slot %-16s ",
6366 is_tu_index
? _("signature") : _("dwo_id"));
6368 for (j
= 0; j
< ncols
; j
++)
6370 val
= byte_get (ppool
+ j
* 4, 4);
6372 printf (" %8s", get_DW_SECT_short_name (val
));
6376 for (i
= 0; i
< nslots
; i
++)
6378 byte_get_64 (ph
, &signature_high
, &signature_low
);
6379 row
= byte_get (pi
, 4);
6382 prow
= psizes
+ (row
- 1) * ncols
* 4;
6384 printf (_(" [%3d] 0x%s"),
6385 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6386 buf
, sizeof (buf
)));
6387 for (j
= 0; j
< ncols
; j
++)
6389 val
= byte_get (prow
+ j
* 4, 4);
6391 printf (" %8d", val
);
6394 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6395 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
6405 else if (do_display
)
6406 printf (_(" Unsupported version\n"));
6414 /* Load the CU and TU indexes if present. This will build a list of
6415 section sets that we can use to associate a .debug_info.dwo section
6416 with its associated .debug_abbrev.dwo section in a .dwp file. */
6419 load_cu_tu_indexes (void *file
)
6421 /* If we have already loaded (or tried to load) the CU and TU indexes
6422 then do not bother to repeat the task. */
6423 if (cu_tu_indexes_read
)
6426 if (load_debug_section (dwp_cu_index
, file
))
6427 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
6429 if (load_debug_section (dwp_tu_index
, file
))
6430 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
6432 cu_tu_indexes_read
= 1;
6435 /* Find the set of sections that includes section SHNDX. */
6438 find_cu_tu_set (void *file
, unsigned int shndx
)
6442 load_cu_tu_indexes (file
);
6444 /* Find SHNDX in the shndx pool. */
6445 for (i
= 0; i
< shndx_pool_used
; i
++)
6446 if (shndx_pool
[i
] == shndx
)
6449 if (i
>= shndx_pool_used
)
6452 /* Now backup to find the first entry in the set. */
6453 while (i
> 0 && shndx_pool
[i
- 1] != 0)
6456 return shndx_pool
+ i
;
6459 /* Display a .debug_cu_index or .debug_tu_index section. */
6462 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
6464 return process_cu_tu_index (section
, 1);
6468 display_debug_not_supported (struct dwarf_section
*section
,
6469 void *file ATTRIBUTE_UNUSED
)
6471 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6478 cmalloc (size_t nmemb
, size_t size
)
6480 /* Check for overflow. */
6481 if (nmemb
>= ~(size_t) 0 / size
)
6484 return malloc (nmemb
* size
);
6488 xcmalloc (size_t nmemb
, size_t size
)
6490 /* Check for overflow. */
6491 if (nmemb
>= ~(size_t) 0 / size
)
6494 return xmalloc (nmemb
* size
);
6498 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
6500 /* Check for overflow. */
6501 if (nmemb
>= ~(size_t) 0 / size
)
6504 return xrealloc (ptr
, nmemb
* size
);
6508 free_debug_memory (void)
6514 for (i
= 0; i
< max
; i
++)
6515 free_debug_section ((enum dwarf_section_display_enum
) i
);
6517 if (debug_information
!= NULL
)
6519 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
6521 for (i
= 0; i
< num_debug_info_entries
; i
++)
6523 if (!debug_information
[i
].max_loc_offsets
)
6525 free (debug_information
[i
].loc_offsets
);
6526 free (debug_information
[i
].have_frame_base
);
6528 if (!debug_information
[i
].max_range_lists
)
6529 free (debug_information
[i
].range_lists
);
6533 free (debug_information
);
6534 debug_information
= NULL
;
6535 num_debug_info_entries
= 0;
6540 dwarf_select_sections_by_names (const char *names
)
6544 const char * option
;
6548 debug_dump_long_opts
;
6550 static const debug_dump_long_opts opts_table
[] =
6552 /* Please keep this table alpha- sorted. */
6553 { "Ranges", & do_debug_ranges
, 1 },
6554 { "abbrev", & do_debug_abbrevs
, 1 },
6555 { "addr", & do_debug_addr
, 1 },
6556 { "aranges", & do_debug_aranges
, 1 },
6557 { "cu_index", & do_debug_cu_index
, 1 },
6558 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
6559 { "frames", & do_debug_frames
, 1 },
6560 { "frames-interp", & do_debug_frames_interp
, 1 },
6561 /* The special .gdb_index section. */
6562 { "gdb_index", & do_gdb_index
, 1 },
6563 { "info", & do_debug_info
, 1 },
6564 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
6565 { "loc", & do_debug_loc
, 1 },
6566 { "macro", & do_debug_macinfo
, 1 },
6567 { "pubnames", & do_debug_pubnames
, 1 },
6568 { "pubtypes", & do_debug_pubtypes
, 1 },
6569 /* This entry is for compatability
6570 with earlier versions of readelf. */
6571 { "ranges", & do_debug_aranges
, 1 },
6572 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
6573 { "str", & do_debug_str
, 1 },
6574 /* These trace_* sections are used by Itanium VMS. */
6575 { "trace_abbrev", & do_trace_abbrevs
, 1 },
6576 { "trace_aranges", & do_trace_aranges
, 1 },
6577 { "trace_info", & do_trace_info
, 1 },
6586 const debug_dump_long_opts
* entry
;
6588 for (entry
= opts_table
; entry
->option
; entry
++)
6590 size_t len
= strlen (entry
->option
);
6592 if (strncmp (p
, entry
->option
, len
) == 0
6593 && (p
[len
] == ',' || p
[len
] == '\0'))
6595 * entry
->variable
|= entry
->val
;
6597 /* The --debug-dump=frames-interp option also
6598 enables the --debug-dump=frames option. */
6599 if (do_debug_frames_interp
)
6600 do_debug_frames
= 1;
6607 if (entry
->option
== NULL
)
6609 warn (_("Unrecognized debug option '%s'\n"), p
);
6610 p
= strchr (p
, ',');
6621 dwarf_select_sections_by_letters (const char *letters
)
6623 unsigned int lindex
= 0;
6625 while (letters
[lindex
])
6626 switch (letters
[lindex
++])
6633 do_debug_abbrevs
= 1;
6637 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
6641 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
6645 do_debug_pubnames
= 1;
6649 do_debug_pubtypes
= 1;
6653 do_debug_aranges
= 1;
6657 do_debug_ranges
= 1;
6661 do_debug_frames_interp
= 1;
6663 do_debug_frames
= 1;
6667 do_debug_macinfo
= 1;
6679 warn (_("Unrecognized debug option '%s'\n"), optarg
);
6685 dwarf_select_sections_all (void)
6688 do_debug_abbrevs
= 1;
6689 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
6690 do_debug_pubnames
= 1;
6691 do_debug_pubtypes
= 1;
6692 do_debug_aranges
= 1;
6693 do_debug_ranges
= 1;
6694 do_debug_frames
= 1;
6695 do_debug_macinfo
= 1;
6700 do_trace_abbrevs
= 1;
6701 do_trace_aranges
= 1;
6703 do_debug_cu_index
= 1;
6706 struct dwarf_section_display debug_displays
[] =
6708 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0 },
6709 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
6710 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0 },
6711 display_debug_aranges
, &do_debug_aranges
, 1 },
6712 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0 },
6713 display_debug_frames
, &do_debug_frames
, 1 },
6714 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
},
6715 display_debug_info
, &do_debug_info
, 1 },
6716 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0 },
6717 display_debug_lines
, &do_debug_lines
, 1 },
6718 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0 },
6719 display_debug_pubnames
, &do_debug_pubnames
, 0 },
6720 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0 },
6721 display_debug_frames
, &do_debug_frames
, 1 },
6722 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0 },
6723 display_debug_macinfo
, &do_debug_macinfo
, 0 },
6724 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0 },
6725 display_debug_macro
, &do_debug_macinfo
, 1 },
6726 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0 },
6727 display_debug_str
, &do_debug_str
, 0 },
6728 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0 },
6729 display_debug_loc
, &do_debug_loc
, 1 },
6730 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0 },
6731 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
6732 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0 },
6733 display_debug_ranges
, &do_debug_ranges
, 1 },
6734 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0 },
6735 display_debug_not_supported
, NULL
, 0 },
6736 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0 },
6737 display_debug_not_supported
, NULL
, 0 },
6738 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
},
6739 display_debug_types
, &do_debug_info
, 1 },
6740 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0 },
6741 display_debug_not_supported
, NULL
, 0 },
6742 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0 },
6743 display_gdb_index
, &do_gdb_index
, 0 },
6744 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
},
6745 display_trace_info
, &do_trace_info
, 1 },
6746 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0 },
6747 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
6748 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0 },
6749 display_debug_aranges
, &do_trace_aranges
, 0 },
6750 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
6751 display_debug_info
, &do_debug_info
, 1 },
6752 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0 },
6753 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
6754 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
6755 display_debug_types
, &do_debug_info
, 1 },
6756 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0 },
6757 display_debug_lines
, &do_debug_lines
, 1 },
6758 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0 },
6759 display_debug_loc
, &do_debug_loc
, 1 },
6760 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0 },
6761 display_debug_macro
, &do_debug_macinfo
, 1 },
6762 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0 },
6763 display_debug_macinfo
, &do_debug_macinfo
, 0 },
6764 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0 },
6765 display_debug_str
, &do_debug_str
, 1 },
6766 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0 },
6767 display_debug_str_offsets
, NULL
, 0 },
6768 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0 },
6769 display_debug_str_offsets
, NULL
, 0 },
6770 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0 },
6771 display_debug_addr
, &do_debug_addr
, 1 },
6772 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0 },
6773 display_cu_index
, &do_debug_cu_index
, 0 },
6774 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0 },
6775 display_cu_index
, &do_debug_cu_index
, 0 },