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
;
2550 display_debug_lines_raw (struct dwarf_section
*section
,
2551 unsigned char *data
,
2554 unsigned char *start
= section
->start
;
2556 printf (_("Raw dump of debug contents of section %s:\n\n"),
2561 DWARF2_Internal_LineInfo linfo
;
2562 unsigned char *standard_opcodes
;
2563 unsigned char *end_of_sequence
;
2564 unsigned char *hdrptr
;
2565 unsigned long hdroff
;
2566 int initial_length_size
;
2571 hdroff
= hdrptr
- start
;
2573 /* Check the length of the block. */
2574 SAFE_BYTE_GET_AND_INC (linfo
.li_length
, hdrptr
, 4, end
);
2576 if (linfo
.li_length
== 0xffffffff)
2578 /* This section is 64-bit DWARF 3. */
2579 SAFE_BYTE_GET_AND_INC (linfo
.li_length
, hdrptr
, 8, end
);
2581 initial_length_size
= 12;
2586 initial_length_size
= 4;
2589 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2592 (_("The information in section %s appears to be corrupt - the section is too small\n"),
2597 /* Check its version number. */
2598 SAFE_BYTE_GET_AND_INC (linfo
.li_version
, hdrptr
, 2, end
);
2599 if (linfo
.li_version
!= 2
2600 && linfo
.li_version
!= 3
2601 && linfo
.li_version
!= 4)
2603 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2607 SAFE_BYTE_GET_AND_INC (linfo
.li_prologue_length
, hdrptr
, offset_size
, end
);
2608 SAFE_BYTE_GET_AND_INC (linfo
.li_min_insn_length
, hdrptr
, 1, end
);
2610 if (linfo
.li_version
>= 4)
2612 SAFE_BYTE_GET_AND_INC (linfo
.li_max_ops_per_insn
, hdrptr
, 1, end
);
2614 if (linfo
.li_max_ops_per_insn
== 0)
2616 warn (_("Invalid maximum operations per insn.\n"));
2621 linfo
.li_max_ops_per_insn
= 1;
2623 SAFE_BYTE_GET_AND_INC (linfo
.li_default_is_stmt
, hdrptr
, 1, end
);
2624 SAFE_BYTE_GET_AND_INC (linfo
.li_line_base
, hdrptr
, 1, end
);
2625 SAFE_BYTE_GET_AND_INC (linfo
.li_line_range
, hdrptr
, 1, end
);
2626 SAFE_BYTE_GET_AND_INC (linfo
.li_opcode_base
, hdrptr
, 1, end
);
2628 /* Sign extend the line base field. */
2629 linfo
.li_line_base
<<= 24;
2630 linfo
.li_line_base
>>= 24;
2632 printf (_(" Offset: 0x%lx\n"), hdroff
);
2633 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2634 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2635 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2636 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2637 if (linfo
.li_version
>= 4)
2638 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2639 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2640 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2641 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2642 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2644 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
2646 reset_state_machine (linfo
.li_default_is_stmt
);
2648 /* Display the contents of the Opcodes table. */
2649 standard_opcodes
= hdrptr
;
2651 printf (_("\n Opcodes:\n"));
2653 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2654 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2656 /* Display the contents of the Directory table. */
2657 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2660 printf (_("\n The Directory Table is empty.\n"));
2663 printf (_("\n The Directory Table:\n"));
2667 printf (" %s\n", data
);
2669 data
+= strnlen ((char *) data
, end
- data
) + 1;
2673 /* Skip the NUL at the end of the table. */
2676 /* Display the contents of the File Name table. */
2678 printf (_("\n The File Name Table is empty.\n"));
2681 printf (_("\n The File Name Table:\n"));
2682 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2686 unsigned char *name
;
2687 unsigned int bytes_read
;
2689 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2691 data
+= strnlen ((char *) data
, end
- data
) + 1;
2694 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2697 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2700 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2702 printf ("%s\n", name
);
2706 warn (_("Corrupt file name table entry\n"));
2712 /* Skip the NUL at the end of the table. */
2715 /* Now display the statements. */
2716 printf (_("\n Line Number Statements:\n"));
2718 while (data
< end_of_sequence
)
2720 unsigned char op_code
;
2721 dwarf_signed_vma adv
;
2723 unsigned int bytes_read
;
2727 if (op_code
>= linfo
.li_opcode_base
)
2729 op_code
-= linfo
.li_opcode_base
;
2730 uladv
= (op_code
/ linfo
.li_line_range
);
2731 if (linfo
.li_max_ops_per_insn
== 1)
2733 uladv
*= linfo
.li_min_insn_length
;
2734 state_machine_regs
.address
+= uladv
;
2735 printf (_(" Special opcode %d: "
2736 "advance Address by %s to 0x%s"),
2737 op_code
, dwarf_vmatoa ("u", uladv
),
2738 dwarf_vmatoa ("x", state_machine_regs
.address
));
2742 state_machine_regs
.address
2743 += ((state_machine_regs
.op_index
+ uladv
)
2744 / linfo
.li_max_ops_per_insn
)
2745 * linfo
.li_min_insn_length
;
2746 state_machine_regs
.op_index
2747 = (state_machine_regs
.op_index
+ uladv
)
2748 % linfo
.li_max_ops_per_insn
;
2749 printf (_(" Special opcode %d: "
2750 "advance Address by %s to 0x%s[%d]"),
2751 op_code
, dwarf_vmatoa ("u", uladv
),
2752 dwarf_vmatoa ("x", state_machine_regs
.address
),
2753 state_machine_regs
.op_index
);
2755 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2756 state_machine_regs
.line
+= adv
;
2757 printf (_(" and Line by %s to %d\n"),
2758 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
2760 else switch (op_code
)
2762 case DW_LNS_extended_op
:
2763 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
2767 printf (_(" Copy\n"));
2770 case DW_LNS_advance_pc
:
2771 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2773 if (linfo
.li_max_ops_per_insn
== 1)
2775 uladv
*= linfo
.li_min_insn_length
;
2776 state_machine_regs
.address
+= uladv
;
2777 printf (_(" Advance PC by %s to 0x%s\n"),
2778 dwarf_vmatoa ("u", uladv
),
2779 dwarf_vmatoa ("x", state_machine_regs
.address
));
2783 state_machine_regs
.address
2784 += ((state_machine_regs
.op_index
+ uladv
)
2785 / linfo
.li_max_ops_per_insn
)
2786 * linfo
.li_min_insn_length
;
2787 state_machine_regs
.op_index
2788 = (state_machine_regs
.op_index
+ uladv
)
2789 % linfo
.li_max_ops_per_insn
;
2790 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
2791 dwarf_vmatoa ("u", uladv
),
2792 dwarf_vmatoa ("x", state_machine_regs
.address
),
2793 state_machine_regs
.op_index
);
2797 case DW_LNS_advance_line
:
2798 adv
= read_sleb128 (data
, & bytes_read
, end
);
2800 state_machine_regs
.line
+= adv
;
2801 printf (_(" Advance Line by %s to %d\n"),
2802 dwarf_vmatoa ("d", adv
),
2803 state_machine_regs
.line
);
2806 case DW_LNS_set_file
:
2807 adv
= read_uleb128 (data
, & bytes_read
, end
);
2809 printf (_(" Set File Name to entry %s in the File Name Table\n"),
2810 dwarf_vmatoa ("d", adv
));
2811 state_machine_regs
.file
= adv
;
2814 case DW_LNS_set_column
:
2815 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2817 printf (_(" Set column to %s\n"),
2818 dwarf_vmatoa ("u", uladv
));
2819 state_machine_regs
.column
= uladv
;
2822 case DW_LNS_negate_stmt
:
2823 adv
= state_machine_regs
.is_stmt
;
2825 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
2826 state_machine_regs
.is_stmt
= adv
;
2829 case DW_LNS_set_basic_block
:
2830 printf (_(" Set basic block\n"));
2831 state_machine_regs
.basic_block
= 1;
2834 case DW_LNS_const_add_pc
:
2835 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2836 if (linfo
.li_max_ops_per_insn
)
2838 uladv
*= linfo
.li_min_insn_length
;
2839 state_machine_regs
.address
+= uladv
;
2840 printf (_(" Advance PC by constant %s to 0x%s\n"),
2841 dwarf_vmatoa ("u", uladv
),
2842 dwarf_vmatoa ("x", state_machine_regs
.address
));
2846 state_machine_regs
.address
2847 += ((state_machine_regs
.op_index
+ uladv
)
2848 / linfo
.li_max_ops_per_insn
)
2849 * linfo
.li_min_insn_length
;
2850 state_machine_regs
.op_index
2851 = (state_machine_regs
.op_index
+ uladv
)
2852 % linfo
.li_max_ops_per_insn
;
2853 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
2854 dwarf_vmatoa ("u", uladv
),
2855 dwarf_vmatoa ("x", state_machine_regs
.address
),
2856 state_machine_regs
.op_index
);
2860 case DW_LNS_fixed_advance_pc
:
2861 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
2862 state_machine_regs
.address
+= uladv
;
2863 state_machine_regs
.op_index
= 0;
2864 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
2865 dwarf_vmatoa ("u", uladv
),
2866 dwarf_vmatoa ("x", state_machine_regs
.address
));
2869 case DW_LNS_set_prologue_end
:
2870 printf (_(" Set prologue_end to true\n"));
2873 case DW_LNS_set_epilogue_begin
:
2874 printf (_(" Set epilogue_begin to true\n"));
2877 case DW_LNS_set_isa
:
2878 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2880 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
2884 printf (_(" Unknown opcode %d with operands: "), op_code
);
2886 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2888 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
2890 i
== 1 ? "" : ", ");
2905 unsigned char *name
;
2906 unsigned int directory_index
;
2907 unsigned int modification_date
;
2908 unsigned int length
;
2911 /* Output a decoded representation of the .debug_line section. */
2914 display_debug_lines_decoded (struct dwarf_section
*section
,
2915 unsigned char *data
,
2918 printf (_("Decoded dump of debug contents of section %s:\n\n"),
2923 /* This loop amounts to one iteration per compilation unit. */
2924 DWARF2_Internal_LineInfo linfo
;
2925 unsigned char *standard_opcodes
;
2926 unsigned char *end_of_sequence
;
2927 unsigned char *hdrptr
;
2928 int initial_length_size
;
2931 File_Entry
*file_table
= NULL
;
2932 unsigned int n_files
= 0;
2933 unsigned char **directory_table
= NULL
;
2934 unsigned int n_directories
= 0;
2938 /* Extract information from the Line Number Program Header.
2939 (section 6.2.4 in the Dwarf3 doc). */
2941 /* Get the length of this CU's line number information block. */
2942 SAFE_BYTE_GET_AND_INC (linfo
.li_length
, hdrptr
, 4, end
);
2944 if (linfo
.li_length
== 0xffffffff)
2946 /* This section is 64-bit DWARF 3. */
2947 SAFE_BYTE_GET_AND_INC (linfo
.li_length
, hdrptr
, 8, end
);
2949 initial_length_size
= 12;
2954 initial_length_size
= 4;
2957 if (linfo
.li_length
+ initial_length_size
> section
->size
)
2959 warn (_("The line info appears to be corrupt - "
2960 "the section is too small\n"));
2964 /* Get this CU's Line Number Block version number. */
2965 SAFE_BYTE_GET_AND_INC (linfo
.li_version
, hdrptr
, 2, end
);
2966 if (linfo
.li_version
!= 2
2967 && linfo
.li_version
!= 3
2968 && linfo
.li_version
!= 4)
2970 warn (_("Only DWARF version 2, 3 and 4 line info is currently "
2975 SAFE_BYTE_GET_AND_INC (linfo
.li_prologue_length
, hdrptr
, offset_size
, end
);
2976 SAFE_BYTE_GET_AND_INC (linfo
.li_min_insn_length
, hdrptr
, 1, end
);
2978 if (linfo
.li_version
>= 4)
2980 SAFE_BYTE_GET_AND_INC (linfo
.li_max_ops_per_insn
, hdrptr
, 1, end
);
2981 if (linfo
.li_max_ops_per_insn
== 0)
2983 warn (_("Invalid maximum operations per insn.\n"));
2988 linfo
.li_max_ops_per_insn
= 1;
2990 SAFE_BYTE_GET_AND_INC (linfo
.li_default_is_stmt
, hdrptr
, 1, end
);
2991 SAFE_BYTE_GET_AND_INC (linfo
.li_line_base
, hdrptr
, 1, end
);
2992 SAFE_BYTE_GET_AND_INC (linfo
.li_line_range
, hdrptr
, 1, end
);
2993 SAFE_BYTE_GET_AND_INC (linfo
.li_opcode_base
, hdrptr
, 1, end
);
2995 /* Sign extend the line base field. */
2996 linfo
.li_line_base
<<= 24;
2997 linfo
.li_line_base
>>= 24;
2999 /* Find the end of this CU's Line Number Information Block. */
3000 end_of_sequence
= data
+ linfo
.li_length
+ initial_length_size
;
3002 reset_state_machine (linfo
.li_default_is_stmt
);
3004 /* Save a pointer to the contents of the Opcodes table. */
3005 standard_opcodes
= hdrptr
;
3007 /* Traverse the Directory table just to count entries. */
3008 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3011 unsigned char *ptr_directory_table
= data
;
3015 data
+= strnlen ((char *) data
, end
- data
) + 1;
3019 /* Go through the directory table again to save the directories. */
3020 directory_table
= (unsigned char **)
3021 xmalloc (n_directories
* sizeof (unsigned char *));
3024 while (*ptr_directory_table
!= 0)
3026 directory_table
[i
] = ptr_directory_table
;
3027 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3028 ptr_directory_table
- end
) + 1;
3032 /* Skip the NUL at the end of the table. */
3035 /* Traverse the File Name table just to count the entries. */
3038 unsigned char *ptr_file_name_table
= data
;
3042 unsigned int bytes_read
;
3044 /* Skip Name, directory index, last modification time and length
3046 data
+= strnlen ((char *) data
, end
- data
) + 1;
3047 read_uleb128 (data
, & bytes_read
, end
);
3049 read_uleb128 (data
, & bytes_read
, end
);
3051 read_uleb128 (data
, & bytes_read
, end
);
3057 /* Go through the file table again to save the strings. */
3058 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3061 while (*ptr_file_name_table
!= 0)
3063 unsigned int bytes_read
;
3065 file_table
[i
].name
= ptr_file_name_table
;
3066 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3067 end
- ptr_file_name_table
) + 1;
3069 /* We are not interested in directory, time or size. */
3070 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3072 ptr_file_name_table
+= bytes_read
;
3073 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3075 ptr_file_name_table
+= bytes_read
;
3076 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3077 ptr_file_name_table
+= bytes_read
;
3082 /* Print the Compilation Unit's name and a header. */
3083 if (directory_table
== NULL
)
3085 printf (_("CU: %s:\n"), file_table
[0].name
);
3086 printf (_("File name Line number Starting address\n"));
3090 unsigned int ix
= file_table
[0].directory_index
;
3091 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3093 if (do_wide
|| strlen (directory
) < 76)
3094 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3096 printf ("%s:\n", file_table
[0].name
);
3098 printf (_("File name Line number Starting address\n"));
3102 /* Skip the NUL at the end of the table. */
3105 /* This loop iterates through the Dwarf Line Number Program. */
3106 while (data
< end_of_sequence
)
3108 unsigned char op_code
;
3110 unsigned long int uladv
;
3111 unsigned int bytes_read
;
3112 int is_special_opcode
= 0;
3116 if (op_code
>= linfo
.li_opcode_base
)
3118 op_code
-= linfo
.li_opcode_base
;
3119 uladv
= (op_code
/ linfo
.li_line_range
);
3120 if (linfo
.li_max_ops_per_insn
== 1)
3122 uladv
*= linfo
.li_min_insn_length
;
3123 state_machine_regs
.address
+= uladv
;
3127 state_machine_regs
.address
3128 += ((state_machine_regs
.op_index
+ uladv
)
3129 / linfo
.li_max_ops_per_insn
)
3130 * linfo
.li_min_insn_length
;
3131 state_machine_regs
.op_index
3132 = (state_machine_regs
.op_index
+ uladv
)
3133 % linfo
.li_max_ops_per_insn
;
3136 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3137 state_machine_regs
.line
+= adv
;
3138 is_special_opcode
= 1;
3140 else switch (op_code
)
3142 case DW_LNS_extended_op
:
3144 unsigned int ext_op_code_len
;
3145 unsigned char ext_op_code
;
3146 unsigned char *op_code_data
= data
;
3148 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3150 op_code_data
+= bytes_read
;
3152 if (ext_op_code_len
== 0)
3154 warn (_("badly formed extended line op encountered!\n"));
3157 ext_op_code_len
+= bytes_read
;
3158 ext_op_code
= *op_code_data
++;
3160 switch (ext_op_code
)
3162 case DW_LNE_end_sequence
:
3163 reset_state_machine (linfo
.li_default_is_stmt
);
3165 case DW_LNE_set_address
:
3166 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3167 op_code_data
, ext_op_code_len
- bytes_read
- 1,
3169 state_machine_regs
.op_index
= 0;
3171 case DW_LNE_define_file
:
3173 file_table
= (File_Entry
*) xrealloc
3174 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3176 ++state_machine_regs
.last_file_entry
;
3177 /* Source file name. */
3178 file_table
[n_files
].name
= op_code_data
;
3179 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3180 /* Directory index. */
3181 file_table
[n_files
].directory_index
=
3182 read_uleb128 (op_code_data
, & bytes_read
,
3184 op_code_data
+= bytes_read
;
3185 /* Last modification time. */
3186 file_table
[n_files
].modification_date
=
3187 read_uleb128 (op_code_data
, & bytes_read
,
3189 op_code_data
+= bytes_read
;
3191 file_table
[n_files
].length
=
3192 read_uleb128 (op_code_data
, & bytes_read
,
3198 case DW_LNE_set_discriminator
:
3199 case DW_LNE_HP_set_sequence
:
3200 /* Simply ignored. */
3204 printf (_("UNKNOWN (%u): length %d\n"),
3205 ext_op_code
, ext_op_code_len
- bytes_read
);
3208 data
+= ext_op_code_len
;
3214 case DW_LNS_advance_pc
:
3215 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3217 if (linfo
.li_max_ops_per_insn
== 1)
3219 uladv
*= linfo
.li_min_insn_length
;
3220 state_machine_regs
.address
+= uladv
;
3224 state_machine_regs
.address
3225 += ((state_machine_regs
.op_index
+ uladv
)
3226 / linfo
.li_max_ops_per_insn
)
3227 * linfo
.li_min_insn_length
;
3228 state_machine_regs
.op_index
3229 = (state_machine_regs
.op_index
+ uladv
)
3230 % linfo
.li_max_ops_per_insn
;
3234 case DW_LNS_advance_line
:
3235 adv
= read_sleb128 (data
, & bytes_read
, end
);
3237 state_machine_regs
.line
+= adv
;
3240 case DW_LNS_set_file
:
3241 adv
= read_uleb128 (data
, & bytes_read
, end
);
3243 state_machine_regs
.file
= adv
;
3244 if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3246 /* If directory index is 0, that means current directory. */
3247 printf ("\n./%s:[++]\n",
3248 file_table
[state_machine_regs
.file
- 1].name
);
3252 /* The directory index starts counting at 1. */
3253 printf ("\n%s/%s:\n",
3254 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3255 file_table
[state_machine_regs
.file
- 1].name
);
3259 case DW_LNS_set_column
:
3260 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3262 state_machine_regs
.column
= uladv
;
3265 case DW_LNS_negate_stmt
:
3266 adv
= state_machine_regs
.is_stmt
;
3268 state_machine_regs
.is_stmt
= adv
;
3271 case DW_LNS_set_basic_block
:
3272 state_machine_regs
.basic_block
= 1;
3275 case DW_LNS_const_add_pc
:
3276 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3277 if (linfo
.li_max_ops_per_insn
== 1)
3279 uladv
*= linfo
.li_min_insn_length
;
3280 state_machine_regs
.address
+= uladv
;
3284 state_machine_regs
.address
3285 += ((state_machine_regs
.op_index
+ uladv
)
3286 / linfo
.li_max_ops_per_insn
)
3287 * linfo
.li_min_insn_length
;
3288 state_machine_regs
.op_index
3289 = (state_machine_regs
.op_index
+ uladv
)
3290 % linfo
.li_max_ops_per_insn
;
3294 case DW_LNS_fixed_advance_pc
:
3295 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3296 state_machine_regs
.address
+= uladv
;
3297 state_machine_regs
.op_index
= 0;
3300 case DW_LNS_set_prologue_end
:
3303 case DW_LNS_set_epilogue_begin
:
3306 case DW_LNS_set_isa
:
3307 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3309 printf (_(" Set ISA to %lu\n"), uladv
);
3313 printf (_(" Unknown opcode %d with operands: "), op_code
);
3315 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3317 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3319 i
== 1 ? "" : ", ");
3326 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3327 to the DWARF address/line matrix. */
3328 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3329 || (op_code
== DW_LNS_copy
))
3331 const unsigned int MAX_FILENAME_LENGTH
= 35;
3332 char *fileName
= (char *)file_table
[state_machine_regs
.file
- 1].name
;
3333 char *newFileName
= NULL
;
3334 size_t fileNameLength
= strlen (fileName
);
3336 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3338 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3339 /* Truncate file name */
3340 strncpy (newFileName
,
3341 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3342 MAX_FILENAME_LENGTH
+ 1);
3346 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3347 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3350 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3352 if (linfo
.li_max_ops_per_insn
== 1)
3353 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3354 newFileName
, state_machine_regs
.line
,
3355 state_machine_regs
.address
);
3357 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3358 newFileName
, state_machine_regs
.line
,
3359 state_machine_regs
.address
,
3360 state_machine_regs
.op_index
);
3364 if (linfo
.li_max_ops_per_insn
== 1)
3365 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3366 newFileName
, state_machine_regs
.line
,
3367 state_machine_regs
.address
);
3369 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3370 newFileName
, state_machine_regs
.line
,
3371 state_machine_regs
.address
,
3372 state_machine_regs
.op_index
);
3375 if (op_code
== DW_LNE_end_sequence
)
3383 free (directory_table
);
3384 directory_table
= NULL
;
3392 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3394 unsigned char *data
= section
->start
;
3395 unsigned char *end
= data
+ section
->size
;
3397 int retValDecoded
= 1;
3399 if (do_debug_lines
== 0)
3400 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3402 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3403 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3405 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3406 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3408 if (!retValRaw
|| !retValDecoded
)
3415 find_debug_info_for_offset (unsigned long offset
)
3419 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3422 for (i
= 0; i
< num_debug_info_entries
; i
++)
3423 if (debug_information
[i
].cu_offset
== offset
)
3424 return debug_information
+ i
;
3430 display_debug_pubnames (struct dwarf_section
*section
,
3431 void *file ATTRIBUTE_UNUSED
)
3433 DWARF2_Internal_PubNames names
;
3434 unsigned char *start
= section
->start
;
3435 unsigned char *end
= start
+ section
->size
;
3437 /* It does not matter if this load fails,
3438 we test for that later on. */
3439 load_debug_info (file
);
3441 printf (_("Contents of the %s section:\n\n"), section
->name
);
3445 unsigned char *data
;
3446 unsigned long offset
;
3447 int offset_size
, initial_length_size
;
3451 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3452 if (names
.pn_length
== 0xffffffff)
3454 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3456 initial_length_size
= 12;
3461 initial_length_size
= 4;
3464 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3465 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3467 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3468 && num_debug_info_entries
> 0
3469 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3470 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3471 (unsigned long) names
.pn_offset
, section
->name
);
3473 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3475 start
+= names
.pn_length
+ initial_length_size
;
3477 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3479 static int warned
= 0;
3483 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3490 printf (_(" Length: %ld\n"),
3491 (long) names
.pn_length
);
3492 printf (_(" Version: %d\n"),
3494 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3495 (unsigned long) names
.pn_offset
);
3496 printf (_(" Size of area in .debug_info section: %ld\n"),
3497 (long) names
.pn_size
);
3499 printf (_("\n Offset\tName\n"));
3503 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3507 data
+= offset_size
;
3508 printf (" %-6lx\t%s\n", offset
, data
);
3509 data
+= strnlen ((char *) data
, end
- data
) + 1;
3512 while (offset
!= 0);
3520 display_debug_macinfo (struct dwarf_section
*section
,
3521 void *file ATTRIBUTE_UNUSED
)
3523 unsigned char *start
= section
->start
;
3524 unsigned char *end
= start
+ section
->size
;
3525 unsigned char *curr
= start
;
3526 unsigned int bytes_read
;
3527 enum dwarf_macinfo_record_type op
;
3529 printf (_("Contents of the %s section:\n\n"), section
->name
);
3533 unsigned int lineno
;
3534 const unsigned char *string
;
3536 op
= (enum dwarf_macinfo_record_type
) *curr
;
3541 case DW_MACINFO_start_file
:
3543 unsigned int filenum
;
3545 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3547 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3550 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3555 case DW_MACINFO_end_file
:
3556 printf (_(" DW_MACINFO_end_file\n"));
3559 case DW_MACINFO_define
:
3560 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3563 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3564 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3568 case DW_MACINFO_undef
:
3569 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3572 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3573 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3577 case DW_MACINFO_vendor_ext
:
3579 unsigned int constant
;
3581 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3584 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3585 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3595 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3596 filename and dirname corresponding to file name table entry with index
3597 FILEIDX. Return NULL on failure. */
3599 static unsigned char *
3600 get_line_filename_and_dirname (dwarf_vma line_offset
,
3602 unsigned char **dir_name
)
3604 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3605 unsigned char *hdrptr
, *dirtable
, *file_name
;
3606 unsigned int offset_size
, initial_length_size
;
3607 unsigned int version
, opcode_base
, bytes_read
;
3608 dwarf_vma length
, diridx
;
3609 const unsigned char * end
;
3612 if (section
->start
== NULL
3613 || line_offset
>= section
->size
3617 hdrptr
= section
->start
+ line_offset
;
3618 end
= section
->start
+ section
->size
;
3620 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3621 if (length
== 0xffffffff)
3623 /* This section is 64-bit DWARF 3. */
3624 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3626 initial_length_size
= 12;
3631 initial_length_size
= 4;
3633 if (length
+ initial_length_size
> section
->size
)
3636 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3637 if (version
!= 2 && version
!= 3 && version
!= 4)
3639 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3641 hdrptr
++; /* Skip max_ops_per_insn. */
3642 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3644 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3645 if (opcode_base
== 0)
3648 hdrptr
+= opcode_base
- 1;
3650 /* Skip over dirname table. */
3651 while (*hdrptr
!= '\0')
3652 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3653 hdrptr
++; /* Skip the NUL at the end of the table. */
3654 /* Now skip over preceding filename table entries. */
3655 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3657 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3658 read_uleb128 (hdrptr
, &bytes_read
, end
);
3659 hdrptr
+= bytes_read
;
3660 read_uleb128 (hdrptr
, &bytes_read
, end
);
3661 hdrptr
+= bytes_read
;
3662 read_uleb128 (hdrptr
, &bytes_read
, end
);
3663 hdrptr
+= bytes_read
;
3665 if (hdrptr
== end
|| *hdrptr
== '\0')
3668 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3669 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
3672 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
3673 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
3674 if (*dirtable
== '\0')
3676 *dir_name
= dirtable
;
3681 display_debug_macro (struct dwarf_section
*section
,
3684 unsigned char *start
= section
->start
;
3685 unsigned char *end
= start
+ section
->size
;
3686 unsigned char *curr
= start
;
3687 unsigned char *extended_op_buf
[256];
3688 unsigned int bytes_read
;
3690 load_debug_section (str
, file
);
3691 load_debug_section (line
, file
);
3693 printf (_("Contents of the %s section:\n\n"), section
->name
);
3697 unsigned int lineno
, version
, flags
;
3698 unsigned int offset_size
= 4;
3699 const unsigned char *string
;
3700 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
3701 unsigned char **extended_ops
= NULL
;
3703 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
3706 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3711 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
3714 printf (_(" Offset: 0x%lx\n"),
3715 (unsigned long) sec_offset
);
3716 printf (_(" Version: %d\n"), version
);
3717 printf (_(" Offset size: %d\n"), offset_size
);
3720 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
3721 printf (_(" Offset into .debug_line: 0x%lx\n"),
3722 (unsigned long) line_offset
);
3726 unsigned int i
, count
, op
;
3729 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
3731 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
3732 extended_ops
= extended_op_buf
;
3735 printf (_(" Extension opcode arguments:\n"));
3736 for (i
= 0; i
< count
; i
++)
3738 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3739 extended_ops
[op
] = curr
;
3740 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
3743 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
3746 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
3747 for (n
= 0; n
< nargs
; n
++)
3751 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
3752 printf ("%s%s", get_FORM_name (form
),
3753 n
== nargs
- 1 ? "\n" : ", ");
3763 case DW_FORM_block1
:
3764 case DW_FORM_block2
:
3765 case DW_FORM_block4
:
3767 case DW_FORM_string
:
3769 case DW_FORM_sec_offset
:
3772 error (_("Invalid extension opcode form %s\n"),
3773 get_FORM_name (form
));
3789 error (_(".debug_macro section not zero terminated\n"));
3793 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3799 case DW_MACRO_GNU_start_file
:
3801 unsigned int filenum
;
3802 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
3804 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3806 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
3809 if ((flags
& 2) == 0)
3810 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3813 = get_line_filename_and_dirname (line_offset
, filenum
,
3815 if (file_name
== NULL
)
3816 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3819 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3821 dir_name
!= NULL
? (const char *) dir_name
: "",
3822 dir_name
!= NULL
? "/" : "", file_name
);
3826 case DW_MACRO_GNU_end_file
:
3827 printf (_(" DW_MACRO_GNU_end_file\n"));
3830 case DW_MACRO_GNU_define
:
3831 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3834 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3835 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3839 case DW_MACRO_GNU_undef
:
3840 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3843 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3844 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3848 case DW_MACRO_GNU_define_indirect
:
3849 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3851 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3852 string
= fetch_indirect_string (offset
);
3853 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3857 case DW_MACRO_GNU_undef_indirect
:
3858 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3860 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3861 string
= fetch_indirect_string (offset
);
3862 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
3866 case DW_MACRO_GNU_transparent_include
:
3867 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3868 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
3869 (unsigned long) offset
);
3872 case DW_MACRO_GNU_define_indirect_alt
:
3873 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3875 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3876 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
3877 lineno
, (unsigned long) offset
);
3880 case DW_MACRO_GNU_undef_indirect_alt
:
3881 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3883 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3884 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
3885 lineno
, (unsigned long) offset
);
3888 case DW_MACRO_GNU_transparent_include_alt
:
3889 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3890 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
3891 (unsigned long) offset
);
3895 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
3897 error (_(" Unknown macro opcode %02x seen\n"), op
);
3902 /* Skip over unhandled opcodes. */
3904 unsigned char *desc
= extended_ops
[op
];
3905 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
3909 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
3912 printf (_(" DW_MACRO_GNU_%02x -"), op
);
3913 for (n
= 0; n
< nargs
; n
++)
3917 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
3919 = read_and_display_attr_value (0, val
,
3920 curr
, end
, 0, 0, offset_size
,
3921 version
, NULL
, 0, NULL
,
3939 display_debug_abbrev (struct dwarf_section
*section
,
3940 void *file ATTRIBUTE_UNUSED
)
3942 abbrev_entry
*entry
;
3943 unsigned char *start
= section
->start
;
3944 unsigned char *end
= start
+ section
->size
;
3946 printf (_("Contents of the %s section:\n\n"), section
->name
);
3950 unsigned char *last
;
3955 start
= process_abbrev_section (start
, end
);
3957 if (first_abbrev
== NULL
)
3960 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
3962 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
3966 printf (" %ld %s [%s]\n",
3968 get_TAG_name (entry
->tag
),
3969 entry
->children
? _("has children") : _("no children"));
3971 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
3972 printf (" %-18s %s\n",
3973 get_AT_name (attr
->attribute
),
3974 get_FORM_name (attr
->form
));
3984 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
3987 display_loc_list (struct dwarf_section
*section
,
3988 unsigned char **start_ptr
,
3989 int debug_info_entry
,
3990 unsigned long offset
,
3991 unsigned long base_address
,
3994 unsigned char *start
= *start_ptr
;
3995 unsigned char *section_end
= section
->start
+ section
->size
;
3996 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
3997 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
3998 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
3999 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4003 unsigned short length
;
4004 int need_frame_base
;
4008 if (start
+ 2 * pointer_size
> section_end
)
4010 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4015 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4017 /* Note: we use sign extension here in order to be sure that we can detect
4018 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4019 address will not affect the values that we display since we always show
4020 hex values, and always the bottom 32-bits. */
4021 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4022 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4024 if (begin
== 0 && end
== 0)
4026 printf (_("<End of list>\n"));
4030 /* Check base address specifiers. */
4031 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4034 print_dwarf_vma (begin
, pointer_size
);
4035 print_dwarf_vma (end
, pointer_size
);
4036 printf (_("(base address)\n"));
4040 if (start
+ 2 > section_end
)
4042 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4047 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4049 if (start
+ length
> section_end
)
4051 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4056 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4057 print_dwarf_vma (end
+ base_address
, pointer_size
);
4060 need_frame_base
= decode_location_expression (start
,
4065 cu_offset
, section
);
4068 if (need_frame_base
&& !has_frame_base
)
4069 printf (_(" [without DW_AT_frame_base]"));
4072 fputs (_(" (start == end)"), stdout
);
4073 else if (begin
> end
)
4074 fputs (_(" (start > end)"), stdout
);
4084 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4085 right-adjusted in a field of length LEN, and followed by a space. */
4088 print_addr_index (unsigned int idx
, unsigned int len
)
4090 static char buf
[15];
4091 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4092 printf ("%*s ", len
, buf
);
4095 /* Display a location list from a .dwo section. It uses address indexes rather
4096 than embedded addresses. This code closely follows display_loc_list, but the
4097 two are sufficiently different that combining things is very ugly. */
4100 display_loc_list_dwo (struct dwarf_section
*section
,
4101 unsigned char **start_ptr
,
4102 int debug_info_entry
,
4103 unsigned long offset
,
4106 unsigned char *start
= *start_ptr
;
4107 unsigned char *section_end
= section
->start
+ section
->size
;
4108 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4109 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4110 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4111 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4113 unsigned short length
;
4114 int need_frame_base
;
4116 unsigned int bytes_read
;
4120 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4122 if (start
>= section_end
)
4124 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4129 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4132 case 0: /* A terminating entry. */
4134 printf (_("<End of list>\n"));
4136 case 1: /* A base-address entry. */
4137 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4138 start
+= bytes_read
;
4139 print_addr_index (idx
, 8);
4141 printf (_("(base address selection entry)\n"));
4143 case 2: /* A start/end entry. */
4144 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4145 start
+= bytes_read
;
4146 print_addr_index (idx
, 8);
4147 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4148 start
+= bytes_read
;
4149 print_addr_index (idx
, 8);
4151 case 3: /* A start/length entry. */
4152 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4153 start
+= bytes_read
;
4154 print_addr_index (idx
, 8);
4155 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4156 printf ("%08x ", idx
);
4158 case 4: /* An offset pair entry. */
4159 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4160 printf ("%08x ", idx
);
4161 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4162 printf ("%08x ", idx
);
4165 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4170 if (start
+ 2 > section_end
)
4172 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4177 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4178 if (start
+ length
> section_end
)
4180 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4186 need_frame_base
= decode_location_expression (start
,
4191 cu_offset
, section
);
4194 if (need_frame_base
&& !has_frame_base
)
4195 printf (_(" [without DW_AT_frame_base]"));
4205 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4207 static dwarf_vma
*loc_offsets
;
4210 loc_offsets_compar (const void *ap
, const void *bp
)
4212 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4213 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4215 return (a
> b
) - (b
> a
);
4219 display_debug_loc (struct dwarf_section
*section
, void *file
)
4221 unsigned char *start
= section
->start
;
4222 unsigned long bytes
;
4223 unsigned char *section_begin
= start
;
4224 unsigned int num_loc_list
= 0;
4225 unsigned long last_offset
= 0;
4226 unsigned int first
= 0;
4230 int seen_first_offset
= 0;
4231 int locs_sorted
= 1;
4232 unsigned char *next
;
4233 unsigned int *array
= NULL
;
4234 const char *suffix
= strrchr (section
->name
, '.');
4237 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4240 bytes
= section
->size
;
4244 printf (_("\nThe %s section is empty.\n"), section
->name
);
4248 if (load_debug_info (file
) == 0)
4250 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4255 /* Check the order of location list in .debug_info section. If
4256 offsets of location lists are in the ascending order, we can
4257 use `debug_information' directly. */
4258 for (i
= 0; i
< num_debug_info_entries
; i
++)
4262 num
= debug_information
[i
].num_loc_offsets
;
4263 if (num
> num_loc_list
)
4266 /* Check if we can use `debug_information' directly. */
4267 if (locs_sorted
&& num
!= 0)
4269 if (!seen_first_offset
)
4271 /* This is the first location list. */
4272 last_offset
= debug_information
[i
].loc_offsets
[0];
4274 seen_first_offset
= 1;
4280 for (; j
< num
; j
++)
4283 debug_information
[i
].loc_offsets
[j
])
4288 last_offset
= debug_information
[i
].loc_offsets
[j
];
4293 if (!seen_first_offset
)
4294 error (_("No location lists in .debug_info section!\n"));
4296 /* DWARF sections under Mach-O have non-zero addresses. */
4297 if (debug_information
[first
].num_loc_offsets
> 0
4298 && debug_information
[first
].loc_offsets
[0] != section
->address
)
4299 warn (_("Location lists in %s section start at 0x%s\n"),
4301 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4304 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4305 printf (_("Contents of the %s section:\n\n"), section
->name
);
4306 printf (_(" Offset Begin End Expression\n"));
4308 seen_first_offset
= 0;
4309 for (i
= first
; i
< num_debug_info_entries
; i
++)
4311 unsigned long offset
;
4312 unsigned long base_address
;
4317 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4319 loc_offsets
= debug_information
[i
].loc_offsets
;
4320 qsort (array
, debug_information
[i
].num_loc_offsets
,
4321 sizeof (*array
), loc_offsets_compar
);
4324 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4326 j
= locs_sorted
? k
: array
[k
];
4328 && debug_information
[i
].loc_offsets
[locs_sorted
4329 ? k
- 1 : array
[k
- 1]]
4330 == debug_information
[i
].loc_offsets
[j
])
4332 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4333 /* DWARF sections under Mach-O have non-zero addresses. */
4334 offset
= debug_information
[i
].loc_offsets
[j
] - section
->address
;
4335 next
= section_begin
+ offset
;
4336 base_address
= debug_information
[i
].base_address
;
4338 if (!seen_first_offset
)
4339 seen_first_offset
= 1;
4343 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4344 (unsigned long) (start
- section_begin
),
4345 (unsigned long) (next
- section_begin
));
4346 else if (start
> next
)
4347 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4348 (unsigned long) (start
- section_begin
),
4349 (unsigned long) (next
- section_begin
));
4353 if (offset
>= bytes
)
4355 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4361 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4363 display_loc_list (section
, &start
, i
, offset
, base_address
,
4368 if (start
< section
->start
+ section
->size
)
4369 warn (_("There are %ld unused bytes at the end of section %s\n"),
4370 (long) (section
->start
+ section
->size
- start
), section
->name
);
4377 display_debug_str (struct dwarf_section
*section
,
4378 void *file ATTRIBUTE_UNUSED
)
4380 unsigned char *start
= section
->start
;
4381 unsigned long bytes
= section
->size
;
4382 dwarf_vma addr
= section
->address
;
4386 printf (_("\nThe %s section is empty.\n"), section
->name
);
4390 printf (_("Contents of the %s section:\n\n"), section
->name
);
4398 lbytes
= (bytes
> 16 ? 16 : bytes
);
4400 printf (" 0x%8.8lx ", (unsigned long) addr
);
4402 for (j
= 0; j
< 16; j
++)
4405 printf ("%2.2x", start
[j
]);
4413 for (j
= 0; j
< lbytes
; j
++)
4416 if (k
>= ' ' && k
< 0x80)
4435 display_debug_info (struct dwarf_section
*section
, void *file
)
4437 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4441 display_debug_types (struct dwarf_section
*section
, void *file
)
4443 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4447 display_trace_info (struct dwarf_section
*section
, void *file
)
4449 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4453 display_debug_aranges (struct dwarf_section
*section
,
4454 void *file ATTRIBUTE_UNUSED
)
4456 unsigned char *start
= section
->start
;
4457 unsigned char *end
= start
+ section
->size
;
4459 printf (_("Contents of the %s section:\n\n"), section
->name
);
4461 /* It does not matter if this load fails,
4462 we test for that later on. */
4463 load_debug_info (file
);
4467 unsigned char *hdrptr
;
4468 DWARF2_Internal_ARange arange
;
4469 unsigned char *addr_ranges
;
4472 unsigned char address_size
;
4475 int initial_length_size
;
4479 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4480 if (arange
.ar_length
== 0xffffffff)
4482 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4484 initial_length_size
= 12;
4489 initial_length_size
= 4;
4492 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4493 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4495 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4496 && num_debug_info_entries
> 0
4497 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4498 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4499 (unsigned long) arange
.ar_info_offset
, section
->name
);
4501 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4502 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4504 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4506 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4510 printf (_(" Length: %ld\n"),
4511 (long) arange
.ar_length
);
4512 printf (_(" Version: %d\n"), arange
.ar_version
);
4513 printf (_(" Offset into .debug_info: 0x%lx\n"),
4514 (unsigned long) arange
.ar_info_offset
);
4515 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4516 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4518 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4520 if (address_size
== 0)
4522 error (_("Invalid address size in %s section!\n"),
4527 /* The DWARF spec does not require that the address size be a power
4528 of two, but we do. This will have to change if we ever encounter
4529 an uneven architecture. */
4530 if ((address_size
& (address_size
- 1)) != 0)
4532 warn (_("Pointer size + Segment size is not a power of two.\n"));
4536 if (address_size
> 4)
4537 printf (_("\n Address Length\n"));
4539 printf (_("\n Address Length\n"));
4541 addr_ranges
= hdrptr
;
4543 /* Must pad to an alignment boundary that is twice the address size. */
4544 excess
= (hdrptr
- start
) % (2 * address_size
);
4546 addr_ranges
+= (2 * address_size
) - excess
;
4548 start
+= arange
.ar_length
+ initial_length_size
;
4550 while (addr_ranges
+ 2 * address_size
<= start
)
4552 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4553 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4556 print_dwarf_vma (address
, address_size
);
4557 print_dwarf_vma (length
, address_size
);
4567 /* Comparison function for qsort. */
4569 comp_addr_base (const void * v0
, const void * v1
)
4571 debug_info
* info0
= (debug_info
*) v0
;
4572 debug_info
* info1
= (debug_info
*) v1
;
4573 return info0
->addr_base
- info1
->addr_base
;
4576 /* Display the debug_addr section. */
4578 display_debug_addr (struct dwarf_section
*section
,
4581 debug_info
**debug_addr_info
;
4582 unsigned char *entry
;
4587 if (section
->size
== 0)
4589 printf (_("\nThe %s section is empty.\n"), section
->name
);
4593 if (load_debug_info (file
) == 0)
4595 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4600 printf (_("Contents of the %s section:\n\n"), section
->name
);
4602 debug_addr_info
= (debug_info
**) xmalloc ((num_debug_info_entries
+ 1)
4603 * sizeof (debug_info
*));
4606 for (i
= 0; i
< num_debug_info_entries
; i
++)
4608 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4609 debug_addr_info
[count
++] = &debug_information
[i
];
4612 /* Add a sentinel to make iteration convenient. */
4613 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
4614 debug_addr_info
[count
]->addr_base
= section
->size
;
4616 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
4617 for (i
= 0; i
< count
; i
++)
4620 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
4622 printf (_(" For compilation unit at offset 0x%s:\n"),
4623 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
4625 printf (_("\tIndex\tAddress\n"));
4626 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
4627 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
4631 dwarf_vma base
= byte_get (entry
, address_size
);
4632 printf (_("\t%d:\t"), idx
);
4633 print_dwarf_vma (base
, address_size
);
4635 entry
+= address_size
;
4641 free (debug_addr_info
);
4645 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4647 display_debug_str_offsets (struct dwarf_section
*section
,
4648 void *file ATTRIBUTE_UNUSED
)
4650 if (section
->size
== 0)
4652 printf (_("\nThe %s section is empty.\n"), section
->name
);
4655 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
4656 what the offset size is for this section. */
4660 /* Each debug_information[x].range_lists[y] gets this representation for
4661 sorting purposes. */
4665 /* The debug_information[x].range_lists[y] value. */
4666 unsigned long ranges_offset
;
4668 /* Original debug_information to find parameters of the data. */
4669 debug_info
*debug_info_p
;
4672 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4675 range_entry_compar (const void *ap
, const void *bp
)
4677 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
4678 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
4679 const unsigned long a
= a_re
->ranges_offset
;
4680 const unsigned long b
= b_re
->ranges_offset
;
4682 return (a
> b
) - (b
> a
);
4686 display_debug_ranges (struct dwarf_section
*section
,
4687 void *file ATTRIBUTE_UNUSED
)
4689 unsigned char *start
= section
->start
;
4690 unsigned char *last_start
= start
;
4691 unsigned long bytes
= section
->size
;
4692 unsigned char *section_begin
= start
;
4693 unsigned char *finish
= start
+ bytes
;
4694 unsigned int num_range_list
, i
;
4695 struct range_entry
*range_entries
, *range_entry_fill
;
4699 printf (_("\nThe %s section is empty.\n"), section
->name
);
4703 if (load_debug_info (file
) == 0)
4705 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4711 for (i
= 0; i
< num_debug_info_entries
; i
++)
4712 num_range_list
+= debug_information
[i
].num_range_lists
;
4714 if (num_range_list
== 0)
4716 /* This can happen when the file was compiled with -gsplit-debug
4717 which removes references to range lists from the primary .o file. */
4718 printf (_("No range lists in .debug_info section.\n"));
4722 range_entries
= (struct range_entry
*)
4723 xmalloc (sizeof (*range_entries
) * num_range_list
);
4724 range_entry_fill
= range_entries
;
4726 for (i
= 0; i
< num_debug_info_entries
; i
++)
4728 debug_info
*debug_info_p
= &debug_information
[i
];
4731 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
4733 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
4734 range_entry_fill
->debug_info_p
= debug_info_p
;
4739 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
4740 range_entry_compar
);
4742 /* DWARF sections under Mach-O have non-zero addresses. */
4743 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= section
->address
)
4744 warn (_("Range lists in %s section start at 0x%lx\n"),
4745 section
->name
, range_entries
[0].ranges_offset
);
4747 printf (_("Contents of the %s section:\n\n"), section
->name
);
4748 printf (_(" Offset Begin End\n"));
4750 for (i
= 0; i
< num_range_list
; i
++)
4752 struct range_entry
*range_entry
= &range_entries
[i
];
4753 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
4754 unsigned int pointer_size
;
4755 unsigned long offset
;
4756 unsigned char *next
;
4757 unsigned long base_address
;
4759 pointer_size
= debug_info_p
->pointer_size
;
4761 /* DWARF sections under Mach-O have non-zero addresses. */
4762 offset
= range_entry
->ranges_offset
- section
->address
;
4763 next
= section_begin
+ offset
;
4764 base_address
= debug_info_p
->base_address
;
4766 if (dwarf_check
!= 0 && i
> 0)
4769 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4770 (unsigned long) (start
- section_begin
),
4771 (unsigned long) (next
- section_begin
), section
->name
);
4772 else if (start
> next
)
4774 if (next
== last_start
)
4776 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4777 (unsigned long) (start
- section_begin
),
4778 (unsigned long) (next
- section_begin
), section
->name
);
4784 while (start
< finish
)
4789 /* Note: we use sign extension here in order to be sure that
4790 we can detect the -1 escape value. Sign extension into the
4791 top 32 bits of a 32-bit address will not affect the values
4792 that we display since we always show hex values, and always
4793 the bottom 32-bits. */
4794 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
4795 if (start
>= finish
)
4797 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
4799 printf (" %8.8lx ", offset
);
4801 if (begin
== 0 && end
== 0)
4803 printf (_("<End of list>\n"));
4807 /* Check base address specifiers. */
4808 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4811 print_dwarf_vma (begin
, pointer_size
);
4812 print_dwarf_vma (end
, pointer_size
);
4813 printf ("(base address)\n");
4817 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4818 print_dwarf_vma (end
+ base_address
, pointer_size
);
4821 fputs (_("(start == end)"), stdout
);
4822 else if (begin
> end
)
4823 fputs (_("(start > end)"), stdout
);
4830 free (range_entries
);
4835 typedef struct Frame_Chunk
4837 struct Frame_Chunk
*next
;
4838 unsigned char *chunk_start
;
4840 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
4841 short int *col_type
;
4844 unsigned int code_factor
;
4846 unsigned long pc_begin
;
4847 unsigned long pc_range
;
4851 unsigned char fde_encoding
;
4852 unsigned char cfa_exp
;
4853 unsigned char ptr_size
;
4854 unsigned char segment_size
;
4858 static const char *const *dwarf_regnames
;
4859 static unsigned int dwarf_regnames_count
;
4861 /* A marker for a col_type that means this column was never referenced
4862 in the frame info. */
4863 #define DW_CFA_unreferenced (-1)
4865 /* Return 0 if not more space is needed, 1 if more space is needed,
4866 -1 for invalid reg. */
4869 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
4871 int prev
= fc
->ncols
;
4873 if (reg
< (unsigned int) fc
->ncols
)
4876 if (dwarf_regnames_count
4877 && reg
> dwarf_regnames_count
)
4880 fc
->ncols
= reg
+ 1;
4881 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
4882 sizeof (short int));
4883 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
4885 while (prev
< fc
->ncols
)
4887 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
4888 fc
->col_offset
[prev
] = 0;
4894 static const char *const dwarf_regnames_i386
[] =
4896 "eax", "ecx", "edx", "ebx",
4897 "esp", "ebp", "esi", "edi",
4898 "eip", "eflags", NULL
,
4899 "st0", "st1", "st2", "st3",
4900 "st4", "st5", "st6", "st7",
4902 "xmm0", "xmm1", "xmm2", "xmm3",
4903 "xmm4", "xmm5", "xmm6", "xmm7",
4904 "mm0", "mm1", "mm2", "mm3",
4905 "mm4", "mm5", "mm6", "mm7",
4906 "fcw", "fsw", "mxcsr",
4907 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
4912 init_dwarf_regnames_i386 (void)
4914 dwarf_regnames
= dwarf_regnames_i386
;
4915 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
4918 static const char *const dwarf_regnames_x86_64
[] =
4920 "rax", "rdx", "rcx", "rbx",
4921 "rsi", "rdi", "rbp", "rsp",
4922 "r8", "r9", "r10", "r11",
4923 "r12", "r13", "r14", "r15",
4925 "xmm0", "xmm1", "xmm2", "xmm3",
4926 "xmm4", "xmm5", "xmm6", "xmm7",
4927 "xmm8", "xmm9", "xmm10", "xmm11",
4928 "xmm12", "xmm13", "xmm14", "xmm15",
4929 "st0", "st1", "st2", "st3",
4930 "st4", "st5", "st6", "st7",
4931 "mm0", "mm1", "mm2", "mm3",
4932 "mm4", "mm5", "mm6", "mm7",
4934 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
4935 "fs.base", "gs.base", NULL
, NULL
,
4937 "mxcsr", "fcw", "fsw"
4941 init_dwarf_regnames_x86_64 (void)
4943 dwarf_regnames
= dwarf_regnames_x86_64
;
4944 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
4948 init_dwarf_regnames (unsigned int e_machine
)
4954 init_dwarf_regnames_i386 ();
4960 init_dwarf_regnames_x86_64 ();
4969 regname (unsigned int regno
, int row
)
4971 static char reg
[64];
4973 && regno
< dwarf_regnames_count
4974 && dwarf_regnames
[regno
] != NULL
)
4977 return dwarf_regnames
[regno
];
4978 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
4979 dwarf_regnames
[regno
]);
4982 snprintf (reg
, sizeof (reg
), "r%d", regno
);
4987 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
4992 if (*max_regs
< fc
->ncols
)
4993 *max_regs
= fc
->ncols
;
4995 if (*need_col_headers
)
4997 static const char *sloc
= " LOC";
4999 *need_col_headers
= 0;
5001 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5003 for (r
= 0; r
< *max_regs
; r
++)
5004 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5009 printf ("%-5s ", regname (r
, 1));
5015 printf ("%0*lx ", eh_addr_size
* 2, fc
->pc_begin
);
5017 strcpy (tmp
, "exp");
5019 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5020 printf ("%-8s ", tmp
);
5022 for (r
= 0; r
< fc
->ncols
; r
++)
5024 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5026 switch (fc
->col_type
[r
])
5028 case DW_CFA_undefined
:
5031 case DW_CFA_same_value
:
5035 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5037 case DW_CFA_val_offset
:
5038 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5040 case DW_CFA_register
:
5041 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5043 case DW_CFA_expression
:
5044 strcpy (tmp
, "exp");
5046 case DW_CFA_val_expression
:
5047 strcpy (tmp
, "vexp");
5050 strcpy (tmp
, "n/a");
5053 printf ("%-5s ", tmp
);
5059 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end);
5060 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5061 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5064 display_debug_frames (struct dwarf_section
*section
,
5065 void *file ATTRIBUTE_UNUSED
)
5067 unsigned char *start
= section
->start
;
5068 unsigned char *end
= start
+ section
->size
;
5069 unsigned char *section_start
= start
;
5070 Frame_Chunk
*chunks
= 0;
5071 Frame_Chunk
*remembered_state
= 0;
5073 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5074 unsigned int length_return
;
5076 const char *bad_reg
= _("bad register: ");
5077 int saved_eh_addr_size
= eh_addr_size
;
5079 printf (_("Contents of the %s section:\n"), section
->name
);
5083 unsigned char *saved_start
;
5084 unsigned char *block_end
;
5085 unsigned long length
;
5086 unsigned long cie_id
;
5089 int need_col_headers
= 1;
5090 unsigned char *augmentation_data
= NULL
;
5091 unsigned long augmentation_data_len
= 0;
5092 int encoded_ptr_size
= saved_eh_addr_size
;
5094 int initial_length_size
;
5096 saved_start
= start
;
5098 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5101 printf ("\n%08lx ZERO terminator\n\n",
5102 (unsigned long)(saved_start
- section_start
));
5106 if (length
== 0xffffffff)
5108 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5110 initial_length_size
= 12;
5115 initial_length_size
= 4;
5118 block_end
= saved_start
+ length
+ initial_length_size
;
5119 if (block_end
> end
)
5121 warn ("Invalid length %#08lx in FDE at %#08lx\n",
5122 length
, (unsigned long)(saved_start
- section_start
));
5126 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5128 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
5132 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5133 memset (fc
, 0, sizeof (Frame_Chunk
));
5137 fc
->chunk_start
= saved_start
;
5139 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5140 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5141 frame_need_space (fc
, max_regs
- 1);
5145 fc
->augmentation
= (char *) start
;
5146 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
5148 if (strcmp (fc
->augmentation
, "eh") == 0)
5149 start
+= eh_addr_size
;
5153 GET (fc
->ptr_size
, 1);
5154 GET (fc
->segment_size
, 1);
5155 eh_addr_size
= fc
->ptr_size
;
5159 fc
->ptr_size
= eh_addr_size
;
5160 fc
->segment_size
= 0;
5162 fc
->code_factor
= LEB ();
5163 fc
->data_factor
= SLEB ();
5173 if (fc
->augmentation
[0] == 'z')
5175 augmentation_data_len
= LEB ();
5176 augmentation_data
= start
;
5177 start
+= augmentation_data_len
;
5181 if (do_debug_frames_interp
)
5182 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
5183 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
5184 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
5188 printf ("\n%08lx %08lx %08lx CIE\n",
5189 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
5190 printf (" Version: %d\n", version
);
5191 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5194 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5195 printf (" Segment Size: %u\n", fc
->segment_size
);
5197 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5198 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5199 printf (" Return address column: %d\n", fc
->ra
);
5201 if (augmentation_data_len
)
5204 printf (" Augmentation data: ");
5205 for (i
= 0; i
< augmentation_data_len
; ++i
)
5206 printf (" %02x", augmentation_data
[i
]);
5212 if (augmentation_data_len
)
5214 unsigned char *p
, *q
;
5215 p
= (unsigned char *) fc
->augmentation
+ 1;
5216 q
= augmentation_data
;
5223 q
+= 1 + size_of_encoded_value (*q
);
5225 fc
->fde_encoding
= *q
++;
5233 if (fc
->fde_encoding
)
5234 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5237 frame_need_space (fc
, fc
->ra
);
5241 unsigned char *look_for
;
5242 static Frame_Chunk fde_fc
;
5243 unsigned long segment_selector
;
5246 memset (fc
, 0, sizeof (Frame_Chunk
));
5248 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
5250 for (cie
= chunks
; cie
; cie
= cie
->next
)
5251 if (cie
->chunk_start
== look_for
)
5256 warn ("Invalid CIE pointer %#08lx in FDE at %#08lx\n",
5257 cie_id
, (unsigned long)(saved_start
- section_start
));
5259 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5260 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5261 frame_need_space (fc
, max_regs
- 1);
5263 fc
->augmentation
= "";
5264 fc
->fde_encoding
= 0;
5265 fc
->ptr_size
= eh_addr_size
;
5266 fc
->segment_size
= 0;
5270 fc
->ncols
= cie
->ncols
;
5271 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5272 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5273 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5274 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5275 fc
->augmentation
= cie
->augmentation
;
5276 fc
->ptr_size
= cie
->ptr_size
;
5277 eh_addr_size
= cie
->ptr_size
;
5278 fc
->segment_size
= cie
->segment_size
;
5279 fc
->code_factor
= cie
->code_factor
;
5280 fc
->data_factor
= cie
->data_factor
;
5281 fc
->cfa_reg
= cie
->cfa_reg
;
5282 fc
->cfa_offset
= cie
->cfa_offset
;
5284 frame_need_space (fc
, max_regs
- 1);
5285 fc
->fde_encoding
= cie
->fde_encoding
;
5288 if (fc
->fde_encoding
)
5289 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5291 segment_selector
= 0;
5292 if (fc
->segment_size
)
5294 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5296 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
, section
);
5297 start
+= encoded_ptr_size
;
5299 /* FIXME: It appears that sometimes the final pc_range value is
5300 encoded in less than encoded_ptr_size bytes. See the x86_64
5301 run of the "objcopy on compressed debug sections" test for an
5303 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5305 if (cie
->augmentation
[0] == 'z')
5307 augmentation_data_len
= LEB ();
5308 augmentation_data
= start
;
5309 start
+= augmentation_data_len
;
5312 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=",
5313 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
5314 (unsigned long)(cie
->chunk_start
- section_start
));
5315 if (fc
->segment_size
)
5316 printf ("%04lx:", segment_selector
);
5317 printf ("%08lx..%08lx\n", fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
5318 if (! do_debug_frames_interp
&& augmentation_data_len
)
5322 printf (" Augmentation data: ");
5323 for (i
= 0; i
< augmentation_data_len
; ++i
)
5324 printf (" %02x", augmentation_data
[i
]);
5330 /* At this point, fc is the current chunk, cie (if any) is set, and
5331 we're about to interpret instructions for the chunk. */
5332 /* ??? At present we need to do this always, since this sizes the
5333 fc->col_type and fc->col_offset arrays, which we write into always.
5334 We should probably split the interpreted and non-interpreted bits
5335 into two different routines, since there's so much that doesn't
5336 really overlap between them. */
5337 if (1 || do_debug_frames_interp
)
5339 /* Start by making a pass over the chunk, allocating storage
5340 and taking note of what registers are used. */
5341 unsigned char *tmp
= start
;
5343 while (start
< block_end
)
5346 unsigned long reg
, temp
;
5353 /* Warning: if you add any more cases to this switch, be
5354 sure to add them to the corresponding switch below. */
5357 case DW_CFA_advance_loc
:
5361 if (frame_need_space (fc
, opa
) >= 0)
5362 fc
->col_type
[opa
] = DW_CFA_undefined
;
5364 case DW_CFA_restore
:
5365 if (frame_need_space (fc
, opa
) >= 0)
5366 fc
->col_type
[opa
] = DW_CFA_undefined
;
5368 case DW_CFA_set_loc
:
5369 start
+= encoded_ptr_size
;
5371 case DW_CFA_advance_loc1
:
5374 case DW_CFA_advance_loc2
:
5377 case DW_CFA_advance_loc4
:
5380 case DW_CFA_offset_extended
:
5381 case DW_CFA_val_offset
:
5382 reg
= LEB (); LEB ();
5383 if (frame_need_space (fc
, reg
) >= 0)
5384 fc
->col_type
[reg
] = DW_CFA_undefined
;
5386 case DW_CFA_restore_extended
:
5388 frame_need_space (fc
, reg
);
5389 if (frame_need_space (fc
, reg
) >= 0)
5390 fc
->col_type
[reg
] = DW_CFA_undefined
;
5392 case DW_CFA_undefined
:
5394 if (frame_need_space (fc
, reg
) >= 0)
5395 fc
->col_type
[reg
] = DW_CFA_undefined
;
5397 case DW_CFA_same_value
:
5399 if (frame_need_space (fc
, reg
) >= 0)
5400 fc
->col_type
[reg
] = DW_CFA_undefined
;
5402 case DW_CFA_register
:
5403 reg
= LEB (); LEB ();
5404 if (frame_need_space (fc
, reg
) >= 0)
5405 fc
->col_type
[reg
] = DW_CFA_undefined
;
5407 case DW_CFA_def_cfa
:
5410 case DW_CFA_def_cfa_register
:
5413 case DW_CFA_def_cfa_offset
:
5416 case DW_CFA_def_cfa_expression
:
5420 case DW_CFA_expression
:
5421 case DW_CFA_val_expression
:
5425 if (frame_need_space (fc
, reg
) >= 0)
5426 fc
->col_type
[reg
] = DW_CFA_undefined
;
5428 case DW_CFA_offset_extended_sf
:
5429 case DW_CFA_val_offset_sf
:
5430 reg
= LEB (); SLEB ();
5431 if (frame_need_space (fc
, reg
) >= 0)
5432 fc
->col_type
[reg
] = DW_CFA_undefined
;
5434 case DW_CFA_def_cfa_sf
:
5437 case DW_CFA_def_cfa_offset_sf
:
5440 case DW_CFA_MIPS_advance_loc8
:
5443 case DW_CFA_GNU_args_size
:
5446 case DW_CFA_GNU_negative_offset_extended
:
5447 reg
= LEB (); LEB ();
5448 if (frame_need_space (fc
, reg
) >= 0)
5449 fc
->col_type
[reg
] = DW_CFA_undefined
;
5458 /* Now we know what registers are used, make a second pass over
5459 the chunk, this time actually printing out the info. */
5461 while (start
< block_end
)
5464 unsigned long ul
, reg
, roffs
;
5467 const char *reg_prefix
= "";
5474 /* Warning: if you add any more cases to this switch, be
5475 sure to add them to the corresponding switch above. */
5478 case DW_CFA_advance_loc
:
5479 if (do_debug_frames_interp
)
5480 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5482 printf (" DW_CFA_advance_loc: %d to %08lx\n",
5483 opa
* fc
->code_factor
,
5484 fc
->pc_begin
+ opa
* fc
->code_factor
);
5485 fc
->pc_begin
+= opa
* fc
->code_factor
;
5490 if (opa
>= (unsigned int) fc
->ncols
)
5491 reg_prefix
= bad_reg
;
5492 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5493 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
5494 reg_prefix
, regname (opa
, 0),
5495 roffs
* fc
->data_factor
);
5496 if (*reg_prefix
== '\0')
5498 fc
->col_type
[opa
] = DW_CFA_offset
;
5499 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
5503 case DW_CFA_restore
:
5504 if (opa
>= (unsigned int) cie
->ncols
5505 || opa
>= (unsigned int) fc
->ncols
)
5506 reg_prefix
= bad_reg
;
5507 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5508 printf (" DW_CFA_restore: %s%s\n",
5509 reg_prefix
, regname (opa
, 0));
5510 if (*reg_prefix
== '\0')
5512 fc
->col_type
[opa
] = cie
->col_type
[opa
];
5513 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
5514 if (do_debug_frames_interp
5515 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
5516 fc
->col_type
[opa
] = DW_CFA_undefined
;
5520 case DW_CFA_set_loc
:
5521 vma
= get_encoded_value (start
, fc
->fde_encoding
, section
);
5522 start
+= encoded_ptr_size
;
5523 if (do_debug_frames_interp
)
5524 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5526 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
5530 case DW_CFA_advance_loc1
:
5531 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
5532 if (do_debug_frames_interp
)
5533 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5535 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
5536 ofs
* fc
->code_factor
,
5537 fc
->pc_begin
+ ofs
* fc
->code_factor
);
5538 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5541 case DW_CFA_advance_loc2
:
5542 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, end
);
5543 if (do_debug_frames_interp
)
5544 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5546 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
5547 ofs
* fc
->code_factor
,
5548 fc
->pc_begin
+ ofs
* fc
->code_factor
);
5549 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5552 case DW_CFA_advance_loc4
:
5553 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, end
);
5554 if (do_debug_frames_interp
)
5555 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5557 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
5558 ofs
* fc
->code_factor
,
5559 fc
->pc_begin
+ ofs
* fc
->code_factor
);
5560 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5563 case DW_CFA_offset_extended
:
5566 if (reg
>= (unsigned int) fc
->ncols
)
5567 reg_prefix
= bad_reg
;
5568 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5569 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5570 reg_prefix
, regname (reg
, 0),
5571 roffs
* fc
->data_factor
);
5572 if (*reg_prefix
== '\0')
5574 fc
->col_type
[reg
] = DW_CFA_offset
;
5575 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
5579 case DW_CFA_val_offset
:
5582 if (reg
>= (unsigned int) fc
->ncols
)
5583 reg_prefix
= bad_reg
;
5584 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5585 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
5586 reg_prefix
, regname (reg
, 0),
5587 roffs
* fc
->data_factor
);
5588 if (*reg_prefix
== '\0')
5590 fc
->col_type
[reg
] = DW_CFA_val_offset
;
5591 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
5595 case DW_CFA_restore_extended
:
5597 if (reg
>= (unsigned int) cie
->ncols
5598 || reg
>= (unsigned int) fc
->ncols
)
5599 reg_prefix
= bad_reg
;
5600 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5601 printf (" DW_CFA_restore_extended: %s%s\n",
5602 reg_prefix
, regname (reg
, 0));
5603 if (*reg_prefix
== '\0')
5605 fc
->col_type
[reg
] = cie
->col_type
[reg
];
5606 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
5610 case DW_CFA_undefined
:
5612 if (reg
>= (unsigned int) fc
->ncols
)
5613 reg_prefix
= bad_reg
;
5614 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5615 printf (" DW_CFA_undefined: %s%s\n",
5616 reg_prefix
, regname (reg
, 0));
5617 if (*reg_prefix
== '\0')
5619 fc
->col_type
[reg
] = DW_CFA_undefined
;
5620 fc
->col_offset
[reg
] = 0;
5624 case DW_CFA_same_value
:
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_same_value: %s%s\n",
5630 reg_prefix
, regname (reg
, 0));
5631 if (*reg_prefix
== '\0')
5633 fc
->col_type
[reg
] = DW_CFA_same_value
;
5634 fc
->col_offset
[reg
] = 0;
5638 case DW_CFA_register
:
5641 if (reg
>= (unsigned int) fc
->ncols
)
5642 reg_prefix
= bad_reg
;
5643 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5645 printf (" DW_CFA_register: %s%s in ",
5646 reg_prefix
, regname (reg
, 0));
5647 puts (regname (roffs
, 0));
5649 if (*reg_prefix
== '\0')
5651 fc
->col_type
[reg
] = DW_CFA_register
;
5652 fc
->col_offset
[reg
] = roffs
;
5656 case DW_CFA_remember_state
:
5657 if (! do_debug_frames_interp
)
5658 printf (" DW_CFA_remember_state\n");
5659 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5660 rs
->ncols
= fc
->ncols
;
5661 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
5662 sizeof (short int));
5663 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (int));
5664 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
5665 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
5666 rs
->next
= remembered_state
;
5667 remembered_state
= rs
;
5670 case DW_CFA_restore_state
:
5671 if (! do_debug_frames_interp
)
5672 printf (" DW_CFA_restore_state\n");
5673 rs
= remembered_state
;
5676 remembered_state
= rs
->next
;
5677 frame_need_space (fc
, rs
->ncols
- 1);
5678 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
5679 memcpy (fc
->col_offset
, rs
->col_offset
,
5680 rs
->ncols
* sizeof (int));
5681 free (rs
->col_type
);
5682 free (rs
->col_offset
);
5685 else if (do_debug_frames_interp
)
5686 printf ("Mismatched DW_CFA_restore_state\n");
5689 case DW_CFA_def_cfa
:
5690 fc
->cfa_reg
= LEB ();
5691 fc
->cfa_offset
= LEB ();
5693 if (! do_debug_frames_interp
)
5694 printf (" DW_CFA_def_cfa: %s ofs %d\n",
5695 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
5698 case DW_CFA_def_cfa_register
:
5699 fc
->cfa_reg
= LEB ();
5701 if (! do_debug_frames_interp
)
5702 printf (" DW_CFA_def_cfa_register: %s\n",
5703 regname (fc
->cfa_reg
, 0));
5706 case DW_CFA_def_cfa_offset
:
5707 fc
->cfa_offset
= LEB ();
5708 if (! do_debug_frames_interp
)
5709 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
5713 if (! do_debug_frames_interp
)
5714 printf (" DW_CFA_nop\n");
5717 case DW_CFA_def_cfa_expression
:
5719 if (! do_debug_frames_interp
)
5721 printf (" DW_CFA_def_cfa_expression (");
5722 decode_location_expression (start
, eh_addr_size
, 0, -1,
5730 case DW_CFA_expression
:
5733 if (reg
>= (unsigned int) fc
->ncols
)
5734 reg_prefix
= bad_reg
;
5735 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5737 printf (" DW_CFA_expression: %s%s (",
5738 reg_prefix
, regname (reg
, 0));
5739 decode_location_expression (start
, eh_addr_size
, 0, -1,
5743 if (*reg_prefix
== '\0')
5744 fc
->col_type
[reg
] = DW_CFA_expression
;
5748 case DW_CFA_val_expression
:
5751 if (reg
>= (unsigned int) fc
->ncols
)
5752 reg_prefix
= bad_reg
;
5753 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5755 printf (" DW_CFA_val_expression: %s%s (",
5756 reg_prefix
, regname (reg
, 0));
5757 decode_location_expression (start
, eh_addr_size
, 0, -1,
5761 if (*reg_prefix
== '\0')
5762 fc
->col_type
[reg
] = DW_CFA_val_expression
;
5766 case DW_CFA_offset_extended_sf
:
5769 if (frame_need_space (fc
, reg
) < 0)
5770 reg_prefix
= bad_reg
;
5771 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5772 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
5773 reg_prefix
, regname (reg
, 0),
5774 l
* fc
->data_factor
);
5775 if (*reg_prefix
== '\0')
5777 fc
->col_type
[reg
] = DW_CFA_offset
;
5778 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
5782 case DW_CFA_val_offset_sf
:
5785 if (frame_need_space (fc
, reg
) < 0)
5786 reg_prefix
= bad_reg
;
5787 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5788 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
5789 reg_prefix
, regname (reg
, 0),
5790 l
* fc
->data_factor
);
5791 if (*reg_prefix
== '\0')
5793 fc
->col_type
[reg
] = DW_CFA_val_offset
;
5794 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
5798 case DW_CFA_def_cfa_sf
:
5799 fc
->cfa_reg
= LEB ();
5800 fc
->cfa_offset
= SLEB ();
5801 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
5803 if (! do_debug_frames_interp
)
5804 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
5805 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
5808 case DW_CFA_def_cfa_offset_sf
:
5809 fc
->cfa_offset
= SLEB ();
5810 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
5811 if (! do_debug_frames_interp
)
5812 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
5815 case DW_CFA_MIPS_advance_loc8
:
5816 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, end
);
5817 if (do_debug_frames_interp
)
5818 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5820 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
5821 ofs
* fc
->code_factor
,
5822 fc
->pc_begin
+ ofs
* fc
->code_factor
);
5823 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5826 case DW_CFA_GNU_window_save
:
5827 if (! do_debug_frames_interp
)
5828 printf (" DW_CFA_GNU_window_save\n");
5831 case DW_CFA_GNU_args_size
:
5833 if (! do_debug_frames_interp
)
5834 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
5837 case DW_CFA_GNU_negative_offset_extended
:
5840 if (frame_need_space (fc
, reg
) < 0)
5841 reg_prefix
= bad_reg
;
5842 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5843 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
5844 reg_prefix
, regname (reg
, 0),
5845 l
* fc
->data_factor
);
5846 if (*reg_prefix
== '\0')
5848 fc
->col_type
[reg
] = DW_CFA_offset
;
5849 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
5854 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
5855 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
5857 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
5862 if (do_debug_frames_interp
)
5863 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5866 eh_addr_size
= saved_eh_addr_size
;
5879 display_gdb_index (struct dwarf_section
*section
,
5880 void *file ATTRIBUTE_UNUSED
)
5882 unsigned char *start
= section
->start
;
5884 uint32_t cu_list_offset
, tu_list_offset
;
5885 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
5886 unsigned int cu_list_elements
, tu_list_elements
;
5887 unsigned int address_table_size
, symbol_table_slots
;
5888 unsigned char *cu_list
, *tu_list
;
5889 unsigned char *address_table
, *symbol_table
, *constant_pool
;
5892 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
5894 printf (_("Contents of the %s section:\n"), section
->name
);
5896 if (section
->size
< 6 * sizeof (uint32_t))
5898 warn (_("Truncated header in the %s section.\n"), section
->name
);
5902 version
= byte_get_little_endian (start
, 4);
5903 printf (_("Version %ld\n"), (long) version
);
5905 /* Prior versions are obsolete, and future versions may not be
5906 backwards compatible. */
5907 if (version
< 3 || version
> 8)
5909 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
5913 warn (_("The address table data in version 3 may be wrong.\n"));
5915 warn (_("Version 4 does not support case insensitive lookups.\n"));
5917 warn (_("Version 5 does not include inlined functions.\n"));
5919 warn (_("Version 6 does not include symbol attributes.\n"));
5920 /* Version 7 indices generated by Gold have bad type unit references,
5921 PR binutils/15021. But we don't know if the index was generated by
5922 Gold or not, so to avoid worrying users with gdb-generated indices
5923 we say nothing for version 7 here. */
5925 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
5926 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
5927 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
5928 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
5929 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
5931 if (cu_list_offset
> section
->size
5932 || tu_list_offset
> section
->size
5933 || address_table_offset
> section
->size
5934 || symbol_table_offset
> section
->size
5935 || constant_pool_offset
> section
->size
)
5937 warn (_("Corrupt header in the %s section.\n"), section
->name
);
5941 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
5942 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
5943 address_table_size
= symbol_table_offset
- address_table_offset
;
5944 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
5946 cu_list
= start
+ cu_list_offset
;
5947 tu_list
= start
+ tu_list_offset
;
5948 address_table
= start
+ address_table_offset
;
5949 symbol_table
= start
+ symbol_table_offset
;
5950 constant_pool
= start
+ constant_pool_offset
;
5952 printf (_("\nCU table:\n"));
5953 for (i
= 0; i
< cu_list_elements
; i
+= 2)
5955 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
5956 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
5958 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
5959 (unsigned long) cu_offset
,
5960 (unsigned long) (cu_offset
+ cu_length
- 1));
5963 printf (_("\nTU table:\n"));
5964 for (i
= 0; i
< tu_list_elements
; i
+= 3)
5966 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
5967 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
5968 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
5970 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
5971 (unsigned long) tu_offset
,
5972 (unsigned long) type_offset
);
5973 print_dwarf_vma (signature
, 8);
5977 printf (_("\nAddress table:\n"));
5978 for (i
= 0; i
< address_table_size
; i
+= 2 * 8 + 4)
5980 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
5981 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
5982 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
5984 print_dwarf_vma (low
, 8);
5985 print_dwarf_vma (high
, 8);
5986 printf (_("%lu\n"), (unsigned long) cu_index
);
5989 printf (_("\nSymbol table:\n"));
5990 for (i
= 0; i
< symbol_table_slots
; ++i
)
5992 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
5993 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
5994 uint32_t num_cus
, cu
;
5996 if (name_offset
!= 0
5997 || cu_vector_offset
!= 0)
6001 printf ("[%3u] %s:", i
, constant_pool
+ name_offset
);
6002 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
6005 for (j
= 0; j
< num_cus
; ++j
)
6008 gdb_index_symbol_kind kind
;
6010 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6011 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6012 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6013 cu
= GDB_INDEX_CU_VALUE (cu
);
6014 /* Convert to TU number if it's for a type unit. */
6015 if (cu
>= cu_list_elements
/ 2)
6016 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6017 (unsigned long) (cu
- cu_list_elements
/ 2));
6019 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6023 case GDB_INDEX_SYMBOL_KIND_NONE
:
6024 printf (_(" [no symbol information]"));
6026 case GDB_INDEX_SYMBOL_KIND_TYPE
:
6028 ? _(" [static type]")
6029 : _(" [global type]"));
6031 case GDB_INDEX_SYMBOL_KIND_VARIABLE
:
6033 ? _(" [static variable]")
6034 : _(" [global variable]"));
6036 case GDB_INDEX_SYMBOL_KIND_FUNCTION
:
6038 ? _(" [static function]")
6039 : _(" [global function]"));
6041 case GDB_INDEX_SYMBOL_KIND_OTHER
:
6043 ? _(" [static other]")
6044 : _(" [global other]"));
6048 ? _(" [static unknown: %d]")
6049 : _(" [global unknown: %d]"),
6064 /* Pre-allocate enough space for the CU/TU sets needed. */
6067 prealloc_cu_tu_list (unsigned int nshndx
)
6069 if (shndx_pool
== NULL
)
6071 shndx_pool_size
= nshndx
;
6072 shndx_pool_used
= 0;
6073 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6074 sizeof (unsigned int));
6078 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6079 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6080 sizeof (unsigned int));
6085 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6087 if (shndx_pool_used
>= shndx_pool_size
)
6089 error (_("Internal error: out of space in the shndx pool.\n"));
6092 shndx_pool
[shndx_pool_used
++] = shndx
;
6096 end_cu_tu_entry (void)
6098 if (shndx_pool_used
>= shndx_pool_size
)
6100 error (_("Internal error: out of space in the shndx pool.\n"));
6103 shndx_pool
[shndx_pool_used
++] = 0;
6106 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6109 get_DW_SECT_short_name (unsigned int dw_sect
)
6111 static char buf
[16];
6119 case DW_SECT_ABBREV
:
6125 case DW_SECT_STR_OFFSETS
:
6127 case DW_SECT_MACINFO
:
6135 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6139 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6140 These sections are extensions for Fission.
6141 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6144 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6146 unsigned char *phdr
= section
->start
;
6147 unsigned char *limit
= phdr
+ section
->size
;
6148 unsigned char *phash
;
6149 unsigned char *pindex
;
6150 unsigned char *ppool
;
6151 unsigned int version
;
6152 unsigned int ncols
= 0;
6154 unsigned int nslots
;
6157 dwarf_vma signature_high
;
6158 dwarf_vma signature_low
;
6161 version
= byte_get (phdr
, 4);
6163 ncols
= byte_get (phdr
+ 4, 4);
6164 nused
= byte_get (phdr
+ 8, 4);
6165 nslots
= byte_get (phdr
+ 12, 4);
6167 pindex
= phash
+ nslots
* 8;
6168 ppool
= pindex
+ nslots
* 4;
6172 printf (_("Contents of the %s section:\n\n"), section
->name
);
6173 printf (_(" Version: %d\n"), version
);
6175 printf (_(" Number of columns: %d\n"), ncols
);
6176 printf (_(" Number of used entries: %d\n"), nused
);
6177 printf (_(" Number of slots: %d\n\n"), nslots
);
6182 warn (_("Section %s too small for %d hash table entries\n"),
6183 section
->name
, nslots
);
6190 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6191 for (i
= 0; i
< nslots
; i
++)
6193 unsigned char *shndx_list
;
6196 byte_get_64 (phash
, &signature_high
, &signature_low
);
6197 if (signature_high
!= 0 || signature_low
!= 0)
6199 j
= byte_get (pindex
, 4);
6200 shndx_list
= ppool
+ j
* 4;
6202 printf (_(" [%3d] Signature: 0x%s Sections: "),
6203 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6204 buf
, sizeof (buf
)));
6207 if (shndx_list
>= limit
)
6209 warn (_("Section %s too small for shndx pool\n"),
6213 shndx
= byte_get (shndx_list
, 4);
6217 printf (" %d", shndx
);
6219 add_shndx_to_cu_tu_entry (shndx
);
6231 else if (version
== 2)
6234 unsigned int dw_sect
;
6235 unsigned char *ph
= phash
;
6236 unsigned char *pi
= pindex
;
6237 unsigned char *poffsets
= ppool
+ ncols
* 4;
6238 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
6239 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
6240 bfd_boolean is_tu_index
;
6241 struct cu_tu_set
*this_set
= NULL
;
6243 unsigned char *prow
;
6245 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
6249 warn (_("Section %s too small for offset and size tables\n"),
6256 printf (_(" Offset table\n"));
6257 printf (" slot %-16s ",
6258 is_tu_index
? _("signature") : _("dwo_id"));
6265 tu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6271 cu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6277 for (j
= 0; j
< ncols
; j
++)
6279 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6280 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
6284 for (i
= 0; i
< nslots
; i
++)
6286 byte_get_64 (ph
, &signature_high
, &signature_low
);
6287 row
= byte_get (pi
, 4);
6291 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
6292 prow
= poffsets
+ (row
- 1) * ncols
* 4;
6294 printf (_(" [%3d] 0x%s"),
6295 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6296 buf
, sizeof (buf
)));
6297 for (j
= 0; j
< ncols
; j
++)
6299 val
= byte_get (prow
+ j
* 4, 4);
6301 printf (" %8d", val
);
6304 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6305 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
6320 printf (_(" Size table\n"));
6321 printf (" slot %-16s ",
6322 is_tu_index
? _("signature") : _("dwo_id"));
6324 for (j
= 0; j
< ncols
; j
++)
6326 val
= byte_get (ppool
+ j
* 4, 4);
6328 printf (" %8s", get_DW_SECT_short_name (val
));
6332 for (i
= 0; i
< nslots
; i
++)
6334 byte_get_64 (ph
, &signature_high
, &signature_low
);
6335 row
= byte_get (pi
, 4);
6338 prow
= psizes
+ (row
- 1) * ncols
* 4;
6340 printf (_(" [%3d] 0x%s"),
6341 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6342 buf
, sizeof (buf
)));
6343 for (j
= 0; j
< ncols
; j
++)
6345 val
= byte_get (prow
+ j
* 4, 4);
6347 printf (" %8d", val
);
6350 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6351 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
6361 else if (do_display
)
6362 printf (_(" Unsupported version\n"));
6370 /* Load the CU and TU indexes if present. This will build a list of
6371 section sets that we can use to associate a .debug_info.dwo section
6372 with its associated .debug_abbrev.dwo section in a .dwp file. */
6375 load_cu_tu_indexes (void *file
)
6377 /* If we have already loaded (or tried to load) the CU and TU indexes
6378 then do not bother to repeat the task. */
6379 if (cu_tu_indexes_read
)
6382 if (load_debug_section (dwp_cu_index
, file
))
6383 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
6385 if (load_debug_section (dwp_tu_index
, file
))
6386 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
6388 cu_tu_indexes_read
= 1;
6391 /* Find the set of sections that includes section SHNDX. */
6394 find_cu_tu_set (void *file
, unsigned int shndx
)
6398 load_cu_tu_indexes (file
);
6400 /* Find SHNDX in the shndx pool. */
6401 for (i
= 0; i
< shndx_pool_used
; i
++)
6402 if (shndx_pool
[i
] == shndx
)
6405 if (i
>= shndx_pool_used
)
6408 /* Now backup to find the first entry in the set. */
6409 while (i
> 0 && shndx_pool
[i
- 1] != 0)
6412 return shndx_pool
+ i
;
6415 /* Display a .debug_cu_index or .debug_tu_index section. */
6418 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
6420 return process_cu_tu_index (section
, 1);
6424 display_debug_not_supported (struct dwarf_section
*section
,
6425 void *file ATTRIBUTE_UNUSED
)
6427 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6434 cmalloc (size_t nmemb
, size_t size
)
6436 /* Check for overflow. */
6437 if (nmemb
>= ~(size_t) 0 / size
)
6440 return malloc (nmemb
* size
);
6444 xcmalloc (size_t nmemb
, size_t size
)
6446 /* Check for overflow. */
6447 if (nmemb
>= ~(size_t) 0 / size
)
6450 return xmalloc (nmemb
* size
);
6454 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
6456 /* Check for overflow. */
6457 if (nmemb
>= ~(size_t) 0 / size
)
6460 return xrealloc (ptr
, nmemb
* size
);
6464 free_debug_memory (void)
6470 for (i
= 0; i
< max
; i
++)
6471 free_debug_section ((enum dwarf_section_display_enum
) i
);
6473 if (debug_information
!= NULL
)
6475 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
6477 for (i
= 0; i
< num_debug_info_entries
; i
++)
6479 if (!debug_information
[i
].max_loc_offsets
)
6481 free (debug_information
[i
].loc_offsets
);
6482 free (debug_information
[i
].have_frame_base
);
6484 if (!debug_information
[i
].max_range_lists
)
6485 free (debug_information
[i
].range_lists
);
6489 free (debug_information
);
6490 debug_information
= NULL
;
6491 num_debug_info_entries
= 0;
6496 dwarf_select_sections_by_names (const char *names
)
6500 const char * option
;
6504 debug_dump_long_opts
;
6506 static const debug_dump_long_opts opts_table
[] =
6508 /* Please keep this table alpha- sorted. */
6509 { "Ranges", & do_debug_ranges
, 1 },
6510 { "abbrev", & do_debug_abbrevs
, 1 },
6511 { "addr", & do_debug_addr
, 1 },
6512 { "aranges", & do_debug_aranges
, 1 },
6513 { "cu_index", & do_debug_cu_index
, 1 },
6514 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
6515 { "frames", & do_debug_frames
, 1 },
6516 { "frames-interp", & do_debug_frames_interp
, 1 },
6517 /* The special .gdb_index section. */
6518 { "gdb_index", & do_gdb_index
, 1 },
6519 { "info", & do_debug_info
, 1 },
6520 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
6521 { "loc", & do_debug_loc
, 1 },
6522 { "macro", & do_debug_macinfo
, 1 },
6523 { "pubnames", & do_debug_pubnames
, 1 },
6524 { "pubtypes", & do_debug_pubtypes
, 1 },
6525 /* This entry is for compatability
6526 with earlier versions of readelf. */
6527 { "ranges", & do_debug_aranges
, 1 },
6528 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
6529 { "str", & do_debug_str
, 1 },
6530 /* These trace_* sections are used by Itanium VMS. */
6531 { "trace_abbrev", & do_trace_abbrevs
, 1 },
6532 { "trace_aranges", & do_trace_aranges
, 1 },
6533 { "trace_info", & do_trace_info
, 1 },
6542 const debug_dump_long_opts
* entry
;
6544 for (entry
= opts_table
; entry
->option
; entry
++)
6546 size_t len
= strlen (entry
->option
);
6548 if (strncmp (p
, entry
->option
, len
) == 0
6549 && (p
[len
] == ',' || p
[len
] == '\0'))
6551 * entry
->variable
|= entry
->val
;
6553 /* The --debug-dump=frames-interp option also
6554 enables the --debug-dump=frames option. */
6555 if (do_debug_frames_interp
)
6556 do_debug_frames
= 1;
6563 if (entry
->option
== NULL
)
6565 warn (_("Unrecognized debug option '%s'\n"), p
);
6566 p
= strchr (p
, ',');
6577 dwarf_select_sections_by_letters (const char *letters
)
6579 unsigned int lindex
= 0;
6581 while (letters
[lindex
])
6582 switch (letters
[lindex
++])
6589 do_debug_abbrevs
= 1;
6593 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
6597 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
6601 do_debug_pubnames
= 1;
6605 do_debug_pubtypes
= 1;
6609 do_debug_aranges
= 1;
6613 do_debug_ranges
= 1;
6617 do_debug_frames_interp
= 1;
6619 do_debug_frames
= 1;
6623 do_debug_macinfo
= 1;
6635 warn (_("Unrecognized debug option '%s'\n"), optarg
);
6641 dwarf_select_sections_all (void)
6644 do_debug_abbrevs
= 1;
6645 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
6646 do_debug_pubnames
= 1;
6647 do_debug_pubtypes
= 1;
6648 do_debug_aranges
= 1;
6649 do_debug_ranges
= 1;
6650 do_debug_frames
= 1;
6651 do_debug_macinfo
= 1;
6656 do_trace_abbrevs
= 1;
6657 do_trace_aranges
= 1;
6659 do_debug_cu_index
= 1;
6662 struct dwarf_section_display debug_displays
[] =
6664 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0 },
6665 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
6666 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0 },
6667 display_debug_aranges
, &do_debug_aranges
, 1 },
6668 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0 },
6669 display_debug_frames
, &do_debug_frames
, 1 },
6670 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
},
6671 display_debug_info
, &do_debug_info
, 1 },
6672 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0 },
6673 display_debug_lines
, &do_debug_lines
, 1 },
6674 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0 },
6675 display_debug_pubnames
, &do_debug_pubnames
, 0 },
6676 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0 },
6677 display_debug_frames
, &do_debug_frames
, 1 },
6678 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0 },
6679 display_debug_macinfo
, &do_debug_macinfo
, 0 },
6680 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0 },
6681 display_debug_macro
, &do_debug_macinfo
, 1 },
6682 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0 },
6683 display_debug_str
, &do_debug_str
, 0 },
6684 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0 },
6685 display_debug_loc
, &do_debug_loc
, 1 },
6686 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0 },
6687 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
6688 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0 },
6689 display_debug_ranges
, &do_debug_ranges
, 1 },
6690 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0 },
6691 display_debug_not_supported
, NULL
, 0 },
6692 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0 },
6693 display_debug_not_supported
, NULL
, 0 },
6694 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
},
6695 display_debug_types
, &do_debug_info
, 1 },
6696 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0 },
6697 display_debug_not_supported
, NULL
, 0 },
6698 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0 },
6699 display_gdb_index
, &do_gdb_index
, 0 },
6700 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
},
6701 display_trace_info
, &do_trace_info
, 1 },
6702 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0 },
6703 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
6704 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0 },
6705 display_debug_aranges
, &do_trace_aranges
, 0 },
6706 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
6707 display_debug_info
, &do_debug_info
, 1 },
6708 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0 },
6709 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
6710 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
6711 display_debug_types
, &do_debug_info
, 1 },
6712 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0 },
6713 display_debug_lines
, &do_debug_lines
, 1 },
6714 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0 },
6715 display_debug_loc
, &do_debug_loc
, 1 },
6716 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0 },
6717 display_debug_macro
, &do_debug_macinfo
, 1 },
6718 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0 },
6719 display_debug_macinfo
, &do_debug_macinfo
, 0 },
6720 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0 },
6721 display_debug_str
, &do_debug_str
, 1 },
6722 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0 },
6723 display_debug_str_offsets
, NULL
, 0 },
6724 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0 },
6725 display_debug_str_offsets
, NULL
, 0 },
6726 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0 },
6727 display_debug_addr
, &do_debug_addr
, 1 },
6728 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0 },
6729 display_cu_index
, &do_debug_cu_index
, 0 },
6730 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0 },
6731 display_cu_index
, &do_debug_cu_index
, 0 },