1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2014 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 #include "libiberty.h"
24 #include "bfd_stdint.h"
27 #include "elf/common.h"
30 #include "gdb/gdb-index.h"
32 static const char *regname (unsigned int regno
, int row
);
34 static int have_frame_base
;
35 static int need_base_address
;
37 static unsigned int last_pointer_size
= 0;
38 static int warned_about_missing_comp_units
= FALSE
;
40 static unsigned int num_debug_info_entries
= 0;
41 static debug_info
*debug_information
= NULL
;
42 /* Special value for num_debug_info_entries to indicate
43 that the .debug_info section could not be loaded/parsed. */
44 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
51 int do_debug_pubnames
;
52 int do_debug_pubtypes
;
56 int do_debug_frames_interp
;
65 int do_debug_cu_index
;
68 int dwarf_cutoff_level
= -1;
69 unsigned long dwarf_start_die
;
73 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
74 sections. For version 1 package files, each set is stored in SHNDX_POOL
75 as a zero-terminated list of section indexes comprising one set of debug
76 sections from a .dwo file. */
78 static int cu_tu_indexes_read
= 0;
79 static unsigned int *shndx_pool
= NULL
;
80 static unsigned int shndx_pool_size
= 0;
81 static unsigned int shndx_pool_used
= 0;
83 /* For version 2 package files, each set contains an array of section offsets
84 and an array of section sizes, giving the offset and size of the
85 contribution from a CU or TU within one of the debug sections.
86 When displaying debug info from a package file, we need to use these
87 tables to locate the corresponding contributions to each section. */
92 dwarf_vma section_offsets
[DW_SECT_MAX
];
93 size_t section_sizes
[DW_SECT_MAX
];
96 static int cu_count
= 0;
97 static int tu_count
= 0;
98 static struct cu_tu_set
*cu_sets
= NULL
;
99 static struct cu_tu_set
*tu_sets
= NULL
;
101 static void load_cu_tu_indexes (void *file
);
103 /* Values for do_debug_lines. */
104 #define FLAG_DEBUG_LINES_RAW 1
105 #define FLAG_DEBUG_LINES_DECODED 2
108 size_of_encoded_value (int encoding
)
110 switch (encoding
& 0x7)
113 case 0: return eh_addr_size
;
121 get_encoded_value (unsigned char *data
,
123 struct dwarf_section
*section
)
125 int size
= size_of_encoded_value (encoding
);
128 if (encoding
& DW_EH_PE_signed
)
129 val
= byte_get_signed (data
, size
);
131 val
= byte_get (data
, size
);
133 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
134 val
+= section
->address
+ (data
- section
->start
);
138 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
140 #define DWARF_VMA_FMT "ll"
141 #define DWARF_VMA_FMT_LONG "%16.16llx"
143 #define DWARF_VMA_FMT "I64"
144 #define DWARF_VMA_FMT_LONG "%016I64x"
147 #define DWARF_VMA_FMT "l"
148 #define DWARF_VMA_FMT_LONG "%16.16lx"
151 /* Convert a dwarf vma value into a string. Returns a pointer to a static
152 buffer containing the converted VALUE. The value is converted according
153 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
154 it specifies the maximum number of bytes to be displayed in the converted
155 value and FMTCH is ignored - hex is always used. */
158 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
160 /* As dwarf_vmatoa is used more then once in a printf call
161 for output, we are cycling through an fixed array of pointers
162 for return address. */
163 static int buf_pos
= 0;
164 static struct dwarf_vmatoa_buf
170 ret
= buf
[buf_pos
++].place
;
171 buf_pos
%= ARRAY_SIZE (buf
);
175 /* Printf does not have a way of specifiying a maximum field width for an
176 integer value, so we print the full value into a buffer and then select
177 the precision we need. */
178 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
181 return ret
+ (16 - 2 * num_bytes
);
187 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
188 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
193 static inline const char *
194 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
196 return dwarf_vmatoa_1 (fmtch
, value
, 0);
199 /* Print a dwarf_vma value (typically an address, offset or length) in
200 hexadecimal format, followed by a space. The length of the VALUE (and
201 hence the precision displayed) is determined by the NUM_BYTES parameter. */
204 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
206 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
209 /* Format a 64-bit value, given as two 32-bit values, in hex.
210 For reentrancy, this uses a buffer provided by the caller. */
213 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
214 unsigned int buf_len
)
219 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
222 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
223 snprintf (buf
+ len
, buf_len
- len
,
224 "%08" DWARF_VMA_FMT
"x", lvalue
);
230 /* Read in a LEB128 encoded value starting at address DATA.
231 If SIGN is true, return a signed LEB128 value.
232 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
233 No bytes will be read at address END or beyond. */
236 read_leb128 (unsigned char *data
,
237 unsigned int *length_return
,
239 const unsigned char * const end
)
241 dwarf_vma result
= 0;
242 unsigned int num_read
= 0;
243 unsigned int shift
= 0;
244 unsigned char byte
= 0;
251 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
254 if ((byte
& 0x80) == 0)
258 if (length_return
!= NULL
)
259 *length_return
= num_read
;
261 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
262 result
|= (dwarf_vma
) -1 << shift
;
267 /* Create a signed version to avoid painful typecasts. */
268 static inline dwarf_signed_vma
269 read_sleb128 (unsigned char * data
,
270 unsigned int * length_return
,
271 const unsigned char * const end
)
273 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
276 static inline dwarf_vma
277 read_uleb128 (unsigned char * data
,
278 unsigned int * length_return
,
279 const unsigned char * const end
)
281 return read_leb128 (data
, length_return
, FALSE
, end
);
284 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
287 int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
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)); \
346 * (LOW) = * (HIGH) = 0; \
351 typedef struct State_Machine_Registers
359 unsigned char op_index
;
360 unsigned char end_sequence
;
361 /* This variable hold the number of the last entry seen
362 in the File Table. */
363 unsigned int last_file_entry
;
366 static SMR state_machine_regs
;
369 reset_state_machine (int is_stmt
)
371 state_machine_regs
.address
= 0;
372 state_machine_regs
.op_index
= 0;
373 state_machine_regs
.file
= 1;
374 state_machine_regs
.line
= 1;
375 state_machine_regs
.column
= 0;
376 state_machine_regs
.is_stmt
= is_stmt
;
377 state_machine_regs
.basic_block
= 0;
378 state_machine_regs
.end_sequence
= 0;
379 state_machine_regs
.last_file_entry
= 0;
382 /* Handled an extend line op.
383 Returns the number of bytes read. */
386 process_extended_line_op (unsigned char * data
,
390 unsigned char op_code
;
391 unsigned int bytes_read
;
394 unsigned char *orig_data
= data
;
397 len
= read_uleb128 (data
, & bytes_read
, end
);
400 if (len
== 0 || data
== end
)
402 warn (_("badly formed extended line op encountered!\n"));
409 printf (_(" Extended opcode %d: "), op_code
);
413 case DW_LNE_end_sequence
:
414 printf (_("End of Sequence\n\n"));
415 reset_state_machine (is_stmt
);
418 case DW_LNE_set_address
:
419 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
420 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
421 state_machine_regs
.address
= adr
;
422 state_machine_regs
.op_index
= 0;
425 case DW_LNE_define_file
:
426 printf (_("define new File Table entry\n"));
427 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
428 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
431 data
+= strnlen ((char *) data
, end
- data
) + 1;
432 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
434 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
436 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
438 printf ("%s\n\n", name
);
440 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
441 warn (_("DW_LNE_define_file: Bad opcode length\n"));
444 case DW_LNE_set_discriminator
:
445 printf (_("set Discriminator to %s\n"),
446 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
450 case DW_LNE_HP_negate_is_UV_update
:
451 printf ("DW_LNE_HP_negate_is_UV_update\n");
453 case DW_LNE_HP_push_context
:
454 printf ("DW_LNE_HP_push_context\n");
456 case DW_LNE_HP_pop_context
:
457 printf ("DW_LNE_HP_pop_context\n");
459 case DW_LNE_HP_set_file_line_column
:
460 printf ("DW_LNE_HP_set_file_line_column\n");
462 case DW_LNE_HP_set_routine_name
:
463 printf ("DW_LNE_HP_set_routine_name\n");
465 case DW_LNE_HP_set_sequence
:
466 printf ("DW_LNE_HP_set_sequence\n");
468 case DW_LNE_HP_negate_post_semantics
:
469 printf ("DW_LNE_HP_negate_post_semantics\n");
471 case DW_LNE_HP_negate_function_exit
:
472 printf ("DW_LNE_HP_negate_function_exit\n");
474 case DW_LNE_HP_negate_front_end_logical
:
475 printf ("DW_LNE_HP_negate_front_end_logical\n");
477 case DW_LNE_HP_define_proc
:
478 printf ("DW_LNE_HP_define_proc\n");
480 case DW_LNE_HP_source_file_correlation
:
482 unsigned char *edata
= data
+ len
- bytes_read
- 1;
484 printf ("DW_LNE_HP_source_file_correlation\n");
490 opc
= read_uleb128 (data
, & bytes_read
, edata
);
495 case DW_LNE_HP_SFC_formfeed
:
496 printf (" DW_LNE_HP_SFC_formfeed\n");
498 case DW_LNE_HP_SFC_set_listing_line
:
499 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
501 read_uleb128 (data
, & bytes_read
, edata
)));
504 case DW_LNE_HP_SFC_associate
:
505 printf (" DW_LNE_HP_SFC_associate ");
508 read_uleb128 (data
, & bytes_read
, edata
)));
512 read_uleb128 (data
, & bytes_read
, edata
)));
516 read_uleb128 (data
, & bytes_read
, edata
)));
520 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
530 unsigned int rlen
= len
- bytes_read
- 1;
532 if (op_code
>= DW_LNE_lo_user
533 /* The test against DW_LNW_hi_user is redundant due to
534 the limited range of the unsigned char data type used
536 /*&& op_code <= DW_LNE_hi_user*/)
537 printf (_("user defined: "));
539 printf (_("UNKNOWN: "));
540 printf (_("length %d ["), rlen
);
542 printf (" %02x", *data
++);
551 static const unsigned char *
552 fetch_indirect_string (dwarf_vma offset
)
554 struct dwarf_section
*section
= &debug_displays
[str
].section
;
556 if (section
->start
== NULL
)
557 return (const unsigned char *) _("<no .debug_str section>");
559 if (offset
> section
->size
)
561 warn (_("DW_FORM_strp offset too big: %s\n"),
562 dwarf_vmatoa ("x", offset
));
563 return (const unsigned char *) _("<offset is too big>");
566 return (const unsigned char *) section
->start
+ offset
;
570 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
571 dwarf_vma offset_size
, int dwo
)
573 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
574 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
575 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
576 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
577 dwarf_vma index_offset
= idx
* offset_size
;
578 dwarf_vma str_offset
;
580 if (index_section
->start
== NULL
)
581 return (dwo
? _("<no .debug_str_offsets.dwo section>")
582 : _("<no .debug_str_offsets section>"));
584 if (this_set
!= NULL
)
585 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
586 if (index_offset
> index_section
->size
)
588 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
589 dwarf_vmatoa ("x", index_offset
));
590 return _("<index offset is too big>");
593 if (str_section
->start
== NULL
)
594 return (dwo
? _("<no .debug_str.dwo section>")
595 : _("<no .debug_str section>"));
597 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
598 str_offset
-= str_section
->address
;
599 if (str_offset
> str_section
->size
)
601 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
602 dwarf_vmatoa ("x", str_offset
));
603 return _("<indirect index offset is too big>");
606 return (const char *) str_section
->start
+ str_offset
;
610 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
612 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
614 if (section
->start
== NULL
)
615 return (_("<no .debug_addr section>"));
617 if (offset
+ bytes
> section
->size
)
619 warn (_("Offset into section %s too big: %s\n"),
620 section
->name
, dwarf_vmatoa ("x", offset
));
621 return "<offset too big>";
624 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
628 /* FIXME: There are better and more efficient ways to handle
629 these structures. For now though, I just want something that
630 is simple to implement. */
631 typedef struct abbrev_attr
633 unsigned long attribute
;
635 struct abbrev_attr
*next
;
639 typedef struct abbrev_entry
644 struct abbrev_attr
*first_attr
;
645 struct abbrev_attr
*last_attr
;
646 struct abbrev_entry
*next
;
650 static abbrev_entry
*first_abbrev
= NULL
;
651 static abbrev_entry
*last_abbrev
= NULL
;
658 for (abbrv
= first_abbrev
; abbrv
;)
660 abbrev_entry
*next_abbrev
= abbrv
->next
;
663 for (attr
= abbrv
->first_attr
; attr
;)
665 abbrev_attr
*next_attr
= attr
->next
;
675 last_abbrev
= first_abbrev
= NULL
;
679 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
683 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
688 entry
->entry
= number
;
690 entry
->children
= children
;
691 entry
->first_attr
= NULL
;
692 entry
->last_attr
= NULL
;
695 if (first_abbrev
== NULL
)
696 first_abbrev
= entry
;
698 last_abbrev
->next
= entry
;
704 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
708 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
713 attr
->attribute
= attribute
;
717 if (last_abbrev
->first_attr
== NULL
)
718 last_abbrev
->first_attr
= attr
;
720 last_abbrev
->last_attr
->next
= attr
;
722 last_abbrev
->last_attr
= attr
;
725 /* Processes the (partial) contents of a .debug_abbrev section.
726 Returns NULL if the end of the section was encountered.
727 Returns the address after the last byte read if the end of
728 an abbreviation set was found. */
730 static unsigned char *
731 process_abbrev_section (unsigned char *start
, unsigned char *end
)
733 if (first_abbrev
!= NULL
)
738 unsigned int bytes_read
;
741 unsigned long attribute
;
744 entry
= read_uleb128 (start
, & bytes_read
, end
);
747 /* A single zero is supposed to end the section according
748 to the standard. If there's more, then signal that to
755 tag
= read_uleb128 (start
, & bytes_read
, end
);
762 add_abbrev (entry
, tag
, children
);
768 attribute
= read_uleb128 (start
, & bytes_read
, end
);
773 form
= read_uleb128 (start
, & bytes_read
, end
);
778 add_abbrev_attr (attribute
, form
);
780 while (attribute
!= 0);
783 /* Report the missing single zero which ends the section. */
784 error (_(".debug_abbrev section not zero terminated\n"));
790 get_TAG_name (unsigned long tag
)
792 const char *name
= get_DW_TAG_name ((unsigned int)tag
);
796 static char buffer
[100];
798 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
806 get_FORM_name (unsigned long form
)
811 return "DW_FORM value: 0";
813 name
= get_DW_FORM_name (form
);
816 static char buffer
[100];
818 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
825 static unsigned char *
826 display_block (unsigned char *data
,
828 const unsigned char * const end
)
832 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length
));
834 maxlen
= (dwarf_vma
) (end
- data
);
835 length
= length
> maxlen
? maxlen
: length
;
838 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
844 decode_location_expression (unsigned char * data
,
845 unsigned int pointer_size
,
846 unsigned int offset_size
,
850 struct dwarf_section
* section
)
853 unsigned int bytes_read
;
855 dwarf_signed_vma svalue
;
856 unsigned char *end
= data
+ length
;
857 int need_frame_base
= 0;
866 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
867 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
870 printf ("DW_OP_deref");
873 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
874 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
877 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
878 printf ("DW_OP_const1s: %ld", (long) svalue
);
881 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
882 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
885 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
886 printf ("DW_OP_const2s: %ld", (long) svalue
);
889 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
890 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
893 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
894 printf ("DW_OP_const4s: %ld", (long) svalue
);
897 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
898 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
899 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
900 printf ("%lu", (unsigned long) uvalue
);
903 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
904 printf ("DW_OP_const8s: %ld ", (long) svalue
);
905 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
906 printf ("%ld", (long) svalue
);
909 printf ("DW_OP_constu: %s",
910 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
914 printf ("DW_OP_consts: %s",
915 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
919 printf ("DW_OP_dup");
922 printf ("DW_OP_drop");
925 printf ("DW_OP_over");
928 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
929 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
932 printf ("DW_OP_swap");
935 printf ("DW_OP_rot");
938 printf ("DW_OP_xderef");
941 printf ("DW_OP_abs");
944 printf ("DW_OP_and");
947 printf ("DW_OP_div");
950 printf ("DW_OP_minus");
953 printf ("DW_OP_mod");
956 printf ("DW_OP_mul");
959 printf ("DW_OP_neg");
962 printf ("DW_OP_not");
968 printf ("DW_OP_plus");
970 case DW_OP_plus_uconst
:
971 printf ("DW_OP_plus_uconst: %s",
972 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
976 printf ("DW_OP_shl");
979 printf ("DW_OP_shr");
982 printf ("DW_OP_shra");
985 printf ("DW_OP_xor");
988 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
989 printf ("DW_OP_bra: %ld", (long) svalue
);
1001 printf ("DW_OP_le");
1004 printf ("DW_OP_lt");
1007 printf ("DW_OP_ne");
1010 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1011 printf ("DW_OP_skip: %ld", (long) svalue
);
1046 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1081 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1082 regname (op
- DW_OP_reg0
, 1));
1117 printf ("DW_OP_breg%d (%s): %s",
1119 regname (op
- DW_OP_breg0
, 1),
1120 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1125 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1127 printf ("DW_OP_regx: %s (%s)",
1128 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1131 need_frame_base
= 1;
1132 printf ("DW_OP_fbreg: %s",
1133 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1137 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1139 printf ("DW_OP_bregx: %s (%s) %s",
1140 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1141 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1145 printf ("DW_OP_piece: %s",
1146 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1149 case DW_OP_deref_size
:
1150 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1151 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1153 case DW_OP_xderef_size
:
1154 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1155 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1158 printf ("DW_OP_nop");
1161 /* DWARF 3 extensions. */
1162 case DW_OP_push_object_address
:
1163 printf ("DW_OP_push_object_address");
1166 /* XXX: Strictly speaking for 64-bit DWARF3 files
1167 this ought to be an 8-byte wide computation. */
1168 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1169 printf ("DW_OP_call2: <0x%s>",
1170 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1173 /* XXX: Strictly speaking for 64-bit DWARF3 files
1174 this ought to be an 8-byte wide computation. */
1175 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1176 printf ("DW_OP_call4: <0x%s>",
1177 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1179 case DW_OP_call_ref
:
1180 /* XXX: Strictly speaking for 64-bit DWARF3 files
1181 this ought to be an 8-byte wide computation. */
1182 if (dwarf_version
== -1)
1184 printf (_("(DW_OP_call_ref in frame info)"));
1185 /* No way to tell where the next op is, so just bail. */
1186 return need_frame_base
;
1188 if (dwarf_version
== 2)
1190 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1194 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1196 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1198 case DW_OP_form_tls_address
:
1199 printf ("DW_OP_form_tls_address");
1201 case DW_OP_call_frame_cfa
:
1202 printf ("DW_OP_call_frame_cfa");
1204 case DW_OP_bit_piece
:
1205 printf ("DW_OP_bit_piece: ");
1206 printf (_("size: %s "),
1207 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1209 printf (_("offset: %s "),
1210 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1214 /* DWARF 4 extensions. */
1215 case DW_OP_stack_value
:
1216 printf ("DW_OP_stack_value");
1219 case DW_OP_implicit_value
:
1220 printf ("DW_OP_implicit_value");
1221 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1223 display_block (data
, uvalue
, end
);
1227 /* GNU extensions. */
1228 case DW_OP_GNU_push_tls_address
:
1229 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1231 case DW_OP_GNU_uninit
:
1232 printf ("DW_OP_GNU_uninit");
1233 /* FIXME: Is there data associated with this OP ? */
1235 case DW_OP_GNU_encoded_addr
:
1241 addr
= get_encoded_value (data
, encoding
, section
);
1242 data
+= size_of_encoded_value (encoding
);
1244 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1245 print_dwarf_vma (addr
, pointer_size
);
1248 case DW_OP_GNU_implicit_pointer
:
1249 /* XXX: Strictly speaking for 64-bit DWARF3 files
1250 this ought to be an 8-byte wide computation. */
1251 if (dwarf_version
== -1)
1253 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1254 /* No way to tell where the next op is, so just bail. */
1255 return need_frame_base
;
1257 if (dwarf_version
== 2)
1259 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1263 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1265 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1266 dwarf_vmatoa ("x", uvalue
),
1267 dwarf_vmatoa ("d", read_sleb128 (data
,
1268 &bytes_read
, end
)));
1271 case DW_OP_GNU_entry_value
:
1272 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1274 printf ("DW_OP_GNU_entry_value: (");
1275 if (decode_location_expression (data
, pointer_size
, offset_size
,
1276 dwarf_version
, uvalue
,
1277 cu_offset
, section
))
1278 need_frame_base
= 1;
1282 case DW_OP_GNU_const_type
:
1283 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1285 printf ("DW_OP_GNU_const_type: <0x%s> ",
1286 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1287 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1288 display_block (data
, uvalue
, end
);
1291 case DW_OP_GNU_regval_type
:
1292 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1294 printf ("DW_OP_GNU_regval_type: %s (%s)",
1295 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1296 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1298 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1300 case DW_OP_GNU_deref_type
:
1301 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1302 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue
);
1303 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1305 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1307 case DW_OP_GNU_convert
:
1308 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1310 printf ("DW_OP_GNU_convert <0x%s>",
1311 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1313 case DW_OP_GNU_reinterpret
:
1314 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1316 printf ("DW_OP_GNU_reinterpret <0x%s>",
1317 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1319 case DW_OP_GNU_parameter_ref
:
1320 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1321 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1322 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1324 case DW_OP_GNU_addr_index
:
1325 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1327 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1329 case DW_OP_GNU_const_index
:
1330 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1332 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1335 /* HP extensions. */
1336 case DW_OP_HP_is_value
:
1337 printf ("DW_OP_HP_is_value");
1338 /* FIXME: Is there data associated with this OP ? */
1340 case DW_OP_HP_fltconst4
:
1341 printf ("DW_OP_HP_fltconst4");
1342 /* FIXME: Is there data associated with this OP ? */
1344 case DW_OP_HP_fltconst8
:
1345 printf ("DW_OP_HP_fltconst8");
1346 /* FIXME: Is there data associated with this OP ? */
1348 case DW_OP_HP_mod_range
:
1349 printf ("DW_OP_HP_mod_range");
1350 /* FIXME: Is there data associated with this OP ? */
1352 case DW_OP_HP_unmod_range
:
1353 printf ("DW_OP_HP_unmod_range");
1354 /* FIXME: Is there data associated with this OP ? */
1357 printf ("DW_OP_HP_tls");
1358 /* FIXME: Is there data associated with this OP ? */
1361 /* PGI (STMicroelectronics) extensions. */
1362 case DW_OP_PGI_omp_thread_num
:
1363 /* Pushes the thread number for the current thread as it would be
1364 returned by the standard OpenMP library function:
1365 omp_get_thread_num(). The "current thread" is the thread for
1366 which the expression is being evaluated. */
1367 printf ("DW_OP_PGI_omp_thread_num");
1371 if (op
>= DW_OP_lo_user
1372 && op
<= DW_OP_hi_user
)
1373 printf (_("(User defined location op)"));
1375 printf (_("(Unknown location op)"));
1376 /* No way to tell where the next op is, so just bail. */
1377 return need_frame_base
;
1380 /* Separate the ops. */
1385 return need_frame_base
;
1388 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1389 This is used for DWARF package files. */
1391 static struct cu_tu_set
*
1392 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1394 struct cu_tu_set
*p
;
1396 unsigned int dw_sect
;
1402 dw_sect
= DW_SECT_TYPES
;
1408 dw_sect
= DW_SECT_INFO
;
1412 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1420 /* Add INC to HIGH_BITS:LOW_BITS. */
1422 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1424 dwarf_vma tmp
= * low_bits
;
1428 /* FIXME: There is probably a better way of handling this:
1430 We need to cope with dwarf_vma being a 32-bit or 64-bit
1431 type. Plus regardless of its size LOW_BITS is meant to
1432 only hold 32-bits, so if there is overflow or wrap around
1433 we must propagate into HIGH_BITS. */
1434 if (tmp
< * low_bits
)
1438 else if (sizeof (tmp
) > 8
1448 static unsigned char *
1449 read_and_display_attr_value (unsigned long attribute
,
1451 unsigned char * data
,
1452 unsigned char * end
,
1453 dwarf_vma cu_offset
,
1454 dwarf_vma pointer_size
,
1455 dwarf_vma offset_size
,
1457 debug_info
* debug_info_p
,
1459 struct dwarf_section
* section
,
1460 struct cu_tu_set
* this_set
)
1462 dwarf_vma uvalue
= 0;
1463 unsigned char *block_start
= NULL
;
1464 unsigned char * orig_data
= data
;
1465 unsigned int bytes_read
;
1467 if (data
== end
&& form
!= DW_FORM_flag_present
)
1469 warn (_("corrupt attribute\n"));
1478 case DW_FORM_ref_addr
:
1479 if (dwarf_version
== 2)
1480 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1481 else if (dwarf_version
== 3 || dwarf_version
== 4)
1482 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1484 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1489 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1493 case DW_FORM_sec_offset
:
1494 case DW_FORM_GNU_ref_alt
:
1495 case DW_FORM_GNU_strp_alt
:
1496 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1499 case DW_FORM_flag_present
:
1506 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1511 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1516 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1520 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1524 case DW_FORM_GNU_str_index
:
1525 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1529 case DW_FORM_ref_udata
:
1531 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1535 case DW_FORM_indirect
:
1536 form
= read_uleb128 (data
, & bytes_read
, end
);
1539 printf (" %s", get_FORM_name (form
));
1540 return read_and_display_attr_value (attribute
, form
, data
, end
,
1541 cu_offset
, pointer_size
,
1542 offset_size
, dwarf_version
,
1543 debug_info_p
, do_loc
,
1545 case DW_FORM_GNU_addr_index
:
1546 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1553 case DW_FORM_ref_addr
:
1555 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue
));
1558 case DW_FORM_GNU_ref_alt
:
1560 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue
));
1566 case DW_FORM_ref_udata
:
1568 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1573 case DW_FORM_sec_offset
:
1575 printf (" 0x%s", dwarf_vmatoa ("x", uvalue
));
1578 case DW_FORM_flag_present
:
1585 printf (" %s", dwarf_vmatoa ("d", uvalue
));
1592 dwarf_vma high_bits
;
1596 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1598 if (form
== DW_FORM_ref8
)
1599 add64 (& high_bits
, & utmp
, cu_offset
);
1601 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1604 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1605 && num_debug_info_entries
== 0)
1607 if (sizeof (uvalue
) == 8)
1608 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1610 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1616 case DW_FORM_string
:
1618 printf (" %.*s", (int) (end
- data
), data
);
1619 data
+= strnlen ((char *) data
, end
- data
) + 1;
1623 case DW_FORM_exprloc
:
1624 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1625 block_start
= data
+ bytes_read
;
1627 data
= block_start
+ uvalue
;
1629 data
= display_block (block_start
, uvalue
, end
);
1632 case DW_FORM_block1
:
1633 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1634 block_start
= data
+ 1;
1636 data
= block_start
+ uvalue
;
1638 data
= display_block (block_start
, uvalue
, end
);
1641 case DW_FORM_block2
:
1642 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1643 block_start
= data
+ 2;
1645 data
= block_start
+ uvalue
;
1647 data
= display_block (block_start
, uvalue
, end
);
1650 case DW_FORM_block4
:
1651 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1652 block_start
= data
+ 4;
1654 data
= block_start
+ uvalue
;
1656 data
= display_block (block_start
, uvalue
, end
);
1661 printf (_(" (indirect string, offset: 0x%s): %s"),
1662 dwarf_vmatoa ("x", uvalue
),
1663 fetch_indirect_string (uvalue
));
1666 case DW_FORM_GNU_str_index
:
1669 const char *suffix
= strrchr (section
->name
, '.');
1670 int dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? 1 : 0;
1672 printf (_(" (indexed string: 0x%s): %s"),
1673 dwarf_vmatoa ("x", uvalue
),
1674 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
1678 case DW_FORM_GNU_strp_alt
:
1680 printf (_(" (alt indirect string, offset: 0x%s)"),
1681 dwarf_vmatoa ("x", uvalue
));
1684 case DW_FORM_indirect
:
1685 /* Handled above. */
1688 case DW_FORM_ref_sig8
:
1691 dwarf_vma high_bits
;
1694 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1695 printf (" signature: 0x%s",
1696 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
1701 case DW_FORM_GNU_addr_index
:
1703 printf (_(" (addr_index: 0x%s): %s"),
1704 dwarf_vmatoa ("x", uvalue
),
1705 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
1709 warn (_("Unrecognized form: %lu\n"), form
);
1713 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1714 && num_debug_info_entries
== 0
1715 && debug_info_p
!= NULL
)
1719 case DW_AT_frame_base
:
1720 have_frame_base
= 1;
1721 case DW_AT_location
:
1722 case DW_AT_string_length
:
1723 case DW_AT_return_addr
:
1724 case DW_AT_data_member_location
:
1725 case DW_AT_vtable_elem_location
:
1727 case DW_AT_static_link
:
1728 case DW_AT_use_location
:
1729 case DW_AT_GNU_call_site_value
:
1730 case DW_AT_GNU_call_site_data_value
:
1731 case DW_AT_GNU_call_site_target
:
1732 case DW_AT_GNU_call_site_target_clobbered
:
1733 if ((dwarf_version
< 4
1734 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1735 || form
== DW_FORM_sec_offset
)
1737 /* Process location list. */
1738 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1739 unsigned int num
= debug_info_p
->num_loc_offsets
;
1741 if (lmax
== 0 || num
>= lmax
)
1744 debug_info_p
->loc_offsets
= (dwarf_vma
*)
1745 xcrealloc (debug_info_p
->loc_offsets
,
1746 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1747 debug_info_p
->have_frame_base
= (int *)
1748 xcrealloc (debug_info_p
->have_frame_base
,
1749 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1750 debug_info_p
->max_loc_offsets
= lmax
;
1752 if (this_set
!= NULL
)
1753 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
1754 debug_info_p
->loc_offsets
[num
] = uvalue
;
1755 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1756 debug_info_p
->num_loc_offsets
++;
1761 if (need_base_address
)
1762 debug_info_p
->base_address
= uvalue
;
1765 case DW_AT_GNU_addr_base
:
1766 debug_info_p
->addr_base
= uvalue
;
1769 case DW_AT_GNU_ranges_base
:
1770 debug_info_p
->ranges_base
= uvalue
;
1774 if ((dwarf_version
< 4
1775 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1776 || form
== DW_FORM_sec_offset
)
1778 /* Process range list. */
1779 unsigned int lmax
= debug_info_p
->max_range_lists
;
1780 unsigned int num
= debug_info_p
->num_range_lists
;
1782 if (lmax
== 0 || num
>= lmax
)
1785 debug_info_p
->range_lists
= (dwarf_vma
*)
1786 xcrealloc (debug_info_p
->range_lists
,
1787 lmax
, sizeof (*debug_info_p
->range_lists
));
1788 debug_info_p
->max_range_lists
= lmax
;
1790 debug_info_p
->range_lists
[num
] = uvalue
;
1791 debug_info_p
->num_range_lists
++;
1800 if (do_loc
|| attribute
== 0)
1803 /* For some attributes we can display further information. */
1810 case DW_INL_not_inlined
:
1811 printf (_("(not inlined)"));
1813 case DW_INL_inlined
:
1814 printf (_("(inlined)"));
1816 case DW_INL_declared_not_inlined
:
1817 printf (_("(declared as inline but ignored)"));
1819 case DW_INL_declared_inlined
:
1820 printf (_("(declared as inline and inlined)"));
1823 printf (_(" (Unknown inline attribute value: %s)"),
1824 dwarf_vmatoa ("x", uvalue
));
1829 case DW_AT_language
:
1833 /* Ordered by the numeric value of these constants. */
1834 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1835 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1836 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1837 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1838 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1839 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1840 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1841 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1842 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1843 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1844 /* DWARF 2.1 values. */
1845 case DW_LANG_Java
: printf ("(Java)"); break;
1846 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1847 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1848 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1849 /* DWARF 3 values. */
1850 case DW_LANG_PLI
: printf ("(PLI)"); break;
1851 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1852 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1853 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1854 case DW_LANG_D
: printf ("(D)"); break;
1855 /* DWARF 4 values. */
1856 case DW_LANG_Python
: printf ("(Python)"); break;
1857 /* DWARF 5 values. */
1858 case DW_LANG_Go
: printf ("(Go)"); break;
1859 /* MIPS extension. */
1860 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1861 /* UPC extension. */
1862 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1864 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1865 printf (_("(implementation defined: %s)"),
1866 dwarf_vmatoa ("x", uvalue
));
1868 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
1873 case DW_AT_encoding
:
1877 case DW_ATE_void
: printf ("(void)"); break;
1878 case DW_ATE_address
: printf ("(machine address)"); break;
1879 case DW_ATE_boolean
: printf ("(boolean)"); break;
1880 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1881 case DW_ATE_float
: printf ("(float)"); break;
1882 case DW_ATE_signed
: printf ("(signed)"); break;
1883 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1884 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1885 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1886 /* DWARF 2.1 values: */
1887 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1888 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1889 /* DWARF 3 values: */
1890 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1891 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1892 case DW_ATE_edited
: printf ("(edited)"); break;
1893 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1894 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1895 /* HP extensions: */
1896 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1897 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1898 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1899 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1900 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1901 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1902 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1905 if (uvalue
>= DW_ATE_lo_user
1906 && uvalue
<= DW_ATE_hi_user
)
1907 printf (_("(user defined type)"));
1909 printf (_("(unknown type)"));
1914 case DW_AT_accessibility
:
1918 case DW_ACCESS_public
: printf ("(public)"); break;
1919 case DW_ACCESS_protected
: printf ("(protected)"); break;
1920 case DW_ACCESS_private
: printf ("(private)"); break;
1922 printf (_("(unknown accessibility)"));
1927 case DW_AT_visibility
:
1931 case DW_VIS_local
: printf ("(local)"); break;
1932 case DW_VIS_exported
: printf ("(exported)"); break;
1933 case DW_VIS_qualified
: printf ("(qualified)"); break;
1934 default: printf (_("(unknown visibility)")); break;
1938 case DW_AT_virtuality
:
1942 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1943 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1944 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1945 default: printf (_("(unknown virtuality)")); break;
1949 case DW_AT_identifier_case
:
1953 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1954 case DW_ID_up_case
: printf ("(up_case)"); break;
1955 case DW_ID_down_case
: printf ("(down_case)"); break;
1956 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
1957 default: printf (_("(unknown case)")); break;
1961 case DW_AT_calling_convention
:
1965 case DW_CC_normal
: printf ("(normal)"); break;
1966 case DW_CC_program
: printf ("(program)"); break;
1967 case DW_CC_nocall
: printf ("(nocall)"); break;
1969 if (uvalue
>= DW_CC_lo_user
1970 && uvalue
<= DW_CC_hi_user
)
1971 printf (_("(user defined)"));
1973 printf (_("(unknown convention)"));
1977 case DW_AT_ordering
:
1981 case -1: printf (_("(undefined)")); break;
1982 case 0: printf ("(row major)"); break;
1983 case 1: printf ("(column major)"); break;
1987 case DW_AT_frame_base
:
1988 have_frame_base
= 1;
1989 case DW_AT_location
:
1990 case DW_AT_string_length
:
1991 case DW_AT_return_addr
:
1992 case DW_AT_data_member_location
:
1993 case DW_AT_vtable_elem_location
:
1995 case DW_AT_static_link
:
1996 case DW_AT_use_location
:
1997 case DW_AT_GNU_call_site_value
:
1998 case DW_AT_GNU_call_site_data_value
:
1999 case DW_AT_GNU_call_site_target
:
2000 case DW_AT_GNU_call_site_target_clobbered
:
2001 if ((dwarf_version
< 4
2002 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2003 || form
== DW_FORM_sec_offset
)
2004 printf (_(" (location list)"));
2006 case DW_AT_allocated
:
2007 case DW_AT_associated
:
2008 case DW_AT_data_location
:
2010 case DW_AT_upper_bound
:
2011 case DW_AT_lower_bound
:
2014 int need_frame_base
;
2017 need_frame_base
= decode_location_expression (block_start
,
2022 cu_offset
, section
);
2024 if (need_frame_base
&& !have_frame_base
)
2025 printf (_(" [without DW_AT_frame_base]"));
2031 if (form
== DW_FORM_ref_sig8
2032 || form
== DW_FORM_GNU_ref_alt
)
2035 if (form
== DW_FORM_ref1
2036 || form
== DW_FORM_ref2
2037 || form
== DW_FORM_ref4
2038 || form
== DW_FORM_ref_udata
)
2039 uvalue
+= cu_offset
;
2041 if (uvalue
>= section
->size
)
2042 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2043 dwarf_vmatoa ("x", uvalue
),
2044 (unsigned long) (orig_data
- section
->start
));
2047 unsigned long abbrev_number
;
2048 abbrev_entry
* entry
;
2050 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2052 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2053 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2054 use different abbrev table, and we don't track .debug_info chunks
2056 if (form
!= DW_FORM_ref_addr
)
2058 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2059 if (entry
->entry
== abbrev_number
)
2062 printf (" (%s)", get_TAG_name (entry
->tag
));
2077 get_AT_name (unsigned long attribute
)
2082 return "DW_AT value: 0";
2084 /* One value is shared by the MIPS and HP extensions: */
2085 if (attribute
== DW_AT_MIPS_fde
)
2086 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2088 name
= get_DW_AT_name (attribute
);
2092 static char buffer
[100];
2094 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2102 static unsigned char *
2103 read_and_display_attr (unsigned long attribute
,
2105 unsigned char * data
,
2106 unsigned char * end
,
2107 dwarf_vma cu_offset
,
2108 dwarf_vma pointer_size
,
2109 dwarf_vma offset_size
,
2111 debug_info
* debug_info_p
,
2113 struct dwarf_section
* section
,
2114 struct cu_tu_set
* this_set
)
2117 printf (" %-18s:", get_AT_name (attribute
));
2118 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2119 cu_offset
, pointer_size
, offset_size
,
2120 dwarf_version
, debug_info_p
,
2121 do_loc
, section
, this_set
);
2127 /* Process the contents of a .debug_info section. If do_loc is non-zero
2128 then we are scanning for location lists and we do not want to display
2129 anything to the user. If do_types is non-zero, we are processing
2130 a .debug_types section instead of a .debug_info section. */
2133 process_debug_info (struct dwarf_section
*section
,
2135 enum dwarf_section_display_enum abbrev_sec
,
2139 unsigned char *start
= section
->start
;
2140 unsigned char *end
= start
+ section
->size
;
2141 unsigned char *section_begin
;
2143 unsigned int num_units
= 0;
2145 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2146 && num_debug_info_entries
== 0
2151 /* First scan the section to get the number of comp units. */
2152 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2155 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2156 will be the length. For a 64-bit DWARF section, it'll be
2157 the escape code 0xffffffff followed by an 8 byte length. */
2158 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2160 if (length
== 0xffffffff)
2162 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2163 section_begin
+= length
+ 12;
2165 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2167 warn (_("Reserved length value (0x%s) found in section %s\n"),
2168 dwarf_vmatoa ("x", length
), section
->name
);
2172 section_begin
+= length
+ 4;
2174 /* Negative values are illegal, they may even cause infinite
2175 looping. This can happen if we can't accurately apply
2176 relocations to an object file. */
2177 if ((signed long) length
<= 0)
2179 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2180 dwarf_vmatoa ("x", length
), section
->name
);
2187 error (_("No comp units in %s section ?"), section
->name
);
2191 /* Then allocate an array to hold the information. */
2192 debug_information
= (debug_info
*) cmalloc (num_units
,
2193 sizeof (* debug_information
));
2194 if (debug_information
== NULL
)
2196 error (_("Not enough memory for a debug info array of %u entries"),
2204 if (dwarf_start_die
== 0)
2205 printf (_("Contents of the %s section:\n\n"), section
->name
);
2207 load_debug_section (str
, file
);
2208 load_debug_section (str_dwo
, file
);
2209 load_debug_section (str_index
, file
);
2210 load_debug_section (str_index_dwo
, file
);
2211 load_debug_section (debug_addr
, file
);
2214 load_debug_section (abbrev_sec
, file
);
2215 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2217 warn (_("Unable to locate %s section!\n"),
2218 debug_displays
[abbrev_sec
].section
.name
);
2222 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2224 DWARF2_Internal_CompUnit compunit
;
2225 unsigned char *hdrptr
;
2226 unsigned char *tags
;
2227 int level
, last_level
, saved_level
;
2228 dwarf_vma cu_offset
;
2229 unsigned int offset_size
;
2230 int initial_length_size
;
2231 dwarf_vma signature_high
= 0;
2232 dwarf_vma signature_low
= 0;
2233 dwarf_vma type_offset
= 0;
2234 struct cu_tu_set
*this_set
;
2235 dwarf_vma abbrev_base
;
2240 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2242 if (compunit
.cu_length
== 0xffffffff)
2244 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2246 initial_length_size
= 12;
2251 initial_length_size
= 4;
2254 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2256 cu_offset
= start
- section_begin
;
2258 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2260 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2262 if (this_set
== NULL
)
2265 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2269 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2270 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2273 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2277 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2279 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2282 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2283 && num_debug_info_entries
== 0
2286 debug_information
[unit
].cu_offset
= cu_offset
;
2287 debug_information
[unit
].pointer_size
2288 = compunit
.cu_pointer_size
;
2289 debug_information
[unit
].offset_size
= offset_size
;
2290 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2291 debug_information
[unit
].base_address
= 0;
2292 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2293 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2294 debug_information
[unit
].loc_offsets
= NULL
;
2295 debug_information
[unit
].have_frame_base
= NULL
;
2296 debug_information
[unit
].max_loc_offsets
= 0;
2297 debug_information
[unit
].num_loc_offsets
= 0;
2298 debug_information
[unit
].range_lists
= NULL
;
2299 debug_information
[unit
].max_range_lists
= 0;
2300 debug_information
[unit
].num_range_lists
= 0;
2303 if (!do_loc
&& dwarf_start_die
== 0)
2305 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2306 dwarf_vmatoa ("x", cu_offset
));
2307 printf (_(" Length: 0x%s (%s)\n"),
2308 dwarf_vmatoa ("x", compunit
.cu_length
),
2309 offset_size
== 8 ? "64-bit" : "32-bit");
2310 printf (_(" Version: %d\n"), compunit
.cu_version
);
2311 printf (_(" Abbrev Offset: 0x%s\n"),
2312 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2313 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2318 printf (_(" Signature: 0x%s\n"),
2319 dwarf_vmatoa64 (signature_high
, signature_low
,
2320 buf
, sizeof (buf
)));
2321 printf (_(" Type Offset: 0x%s\n"),
2322 dwarf_vmatoa ("x", type_offset
));
2324 if (this_set
!= NULL
)
2326 dwarf_vma
*offsets
= this_set
->section_offsets
;
2327 size_t *sizes
= this_set
->section_sizes
;
2329 printf (_(" Section contributions:\n"));
2330 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2331 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2332 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2333 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2334 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2335 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2336 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2337 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2338 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2339 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2340 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2341 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2345 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2348 warn (_("Debug info is corrupted, length of CU at %s"
2349 " extends beyond end of section (length = %s)\n"),
2350 dwarf_vmatoa ("x", cu_offset
),
2351 dwarf_vmatoa ("x", compunit
.cu_length
));
2355 start
+= compunit
.cu_length
+ initial_length_size
;
2357 if (compunit
.cu_version
!= 2
2358 && compunit
.cu_version
!= 3
2359 && compunit
.cu_version
!= 4)
2361 warn (_("CU at offset %s contains corrupt or "
2362 "unsupported version number: %d.\n"),
2363 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2369 /* Process the abbrevs used by this compilation unit. */
2370 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2371 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2372 (unsigned long) compunit
.cu_abbrev_offset
,
2373 (unsigned long) abbrev_size
);
2375 process_abbrev_section
2376 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2377 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2378 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2379 + abbrev_base
+ abbrev_size
));
2384 while (tags
< start
)
2386 unsigned int bytes_read
;
2387 unsigned long abbrev_number
;
2388 unsigned long die_offset
;
2389 abbrev_entry
*entry
;
2391 int do_printing
= 1;
2393 die_offset
= tags
- section_begin
;
2395 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2398 /* A null DIE marks the end of a list of siblings or it may also be
2399 a section padding. */
2400 if (abbrev_number
== 0)
2402 /* Check if it can be a section padding for the last CU. */
2403 if (level
== 0 && start
== end
)
2407 for (chk
= tags
; chk
< start
; chk
++)
2414 if (!do_loc
&& die_offset
>= dwarf_start_die
2415 && (dwarf_cutoff_level
== -1
2416 || level
< dwarf_cutoff_level
))
2417 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2423 static unsigned num_bogus_warns
= 0;
2425 if (num_bogus_warns
< 3)
2427 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2428 die_offset
, section
->name
);
2430 if (num_bogus_warns
== 3)
2431 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2434 if (dwarf_start_die
!= 0 && level
< saved_level
)
2441 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2445 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2446 saved_level
= level
;
2447 do_printing
= (dwarf_cutoff_level
== -1
2448 || level
< dwarf_cutoff_level
);
2450 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2451 level
, die_offset
, abbrev_number
);
2452 else if (dwarf_cutoff_level
== -1
2453 || last_level
< dwarf_cutoff_level
)
2454 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2459 /* Scan through the abbreviation list until we reach the
2461 for (entry
= first_abbrev
;
2462 entry
&& entry
->entry
!= abbrev_number
;
2463 entry
= entry
->next
)
2468 if (!do_loc
&& do_printing
)
2473 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2474 die_offset
, abbrev_number
);
2478 if (!do_loc
&& do_printing
)
2479 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2484 need_base_address
= 0;
2486 case DW_TAG_compile_unit
:
2487 need_base_address
= 1;
2489 case DW_TAG_entry_point
:
2490 case DW_TAG_subprogram
:
2491 need_base_address
= 0;
2492 /* Assuming that there is no DW_AT_frame_base. */
2493 have_frame_base
= 0;
2497 for (attr
= entry
->first_attr
;
2498 attr
&& attr
->attribute
;
2503 if (! do_loc
&& do_printing
)
2504 /* Show the offset from where the tag was extracted. */
2505 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2507 arg
= debug_information
;
2508 if (debug_information
)
2511 tags
= read_and_display_attr (attr
->attribute
,
2516 compunit
.cu_pointer_size
,
2518 compunit
.cu_version
,
2520 do_loc
|| ! do_printing
,
2525 if (entry
->children
)
2530 /* Set num_debug_info_entries here so that it can be used to check if
2531 we need to process .debug_loc and .debug_ranges sections. */
2532 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2533 && num_debug_info_entries
== 0
2535 num_debug_info_entries
= num_units
;
2543 /* Locate and scan the .debug_info section in the file and record the pointer
2544 sizes and offsets for the compilation units in it. Usually an executable
2545 will have just one pointer size, but this is not guaranteed, and so we try
2546 not to make any assumptions. Returns zero upon failure, or the number of
2547 compilation units upon success. */
2550 load_debug_info (void * file
)
2552 /* Reset the last pointer size so that we can issue correct error
2553 messages if we are displaying the contents of more than one section. */
2554 last_pointer_size
= 0;
2555 warned_about_missing_comp_units
= FALSE
;
2557 /* If we have already tried and failed to load the .debug_info
2558 section then do not bother to repeat the task. */
2559 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2562 /* If we already have the information there is nothing else to do. */
2563 if (num_debug_info_entries
> 0)
2564 return num_debug_info_entries
;
2566 /* If this is a DWARF package file, load the CU and TU indexes. */
2567 load_cu_tu_indexes (file
);
2569 if (load_debug_section (info
, file
)
2570 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2571 return num_debug_info_entries
;
2572 else if (load_debug_section (info_dwo
, file
)
2573 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2575 return num_debug_info_entries
;
2577 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2581 /* Read a DWARF .debug_line section header starting at DATA.
2582 Upon success returns an updated DATA pointer and the LINFO
2583 structure and the END_OF_SEQUENCE pointer will be filled in.
2584 Otherwise returns NULL. */
2586 static unsigned char *
2587 read_debug_line_header (struct dwarf_section
* section
,
2588 unsigned char * data
,
2589 unsigned char * end
,
2590 DWARF2_Internal_LineInfo
* linfo
,
2591 unsigned char ** end_of_sequence
)
2593 unsigned char *hdrptr
;
2594 unsigned int offset_size
;
2595 unsigned int initial_length_size
;
2597 /* Extract information from the Line Number Program Header.
2598 (section 6.2.4 in the Dwarf3 doc). */
2601 /* Get and check the length of the block. */
2602 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2604 if (linfo
->li_length
== 0xffffffff)
2606 /* This section is 64-bit DWARF 3. */
2607 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2609 initial_length_size
= 12;
2614 initial_length_size
= 4;
2617 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2619 /* If the length is just a bias against the initial_length_size then
2620 this means that the field has a relocation against it which has not
2621 been applied. (Ie we are dealing with an object file, not a linked
2622 binary). Do not complain but instead assume that the rest of the
2623 section applies to this particular header. */
2624 if (linfo
->li_length
== - initial_length_size
)
2626 linfo
->li_length
= section
->size
- initial_length_size
;
2630 warn (_("The line info appears to be corrupt - "
2631 "the section is too small\n"));
2636 /* Get and check the version number. */
2637 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2639 if (linfo
->li_version
!= 2
2640 && linfo
->li_version
!= 3
2641 && linfo
->li_version
!= 4)
2643 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2647 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2648 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2650 if (linfo
->li_version
>= 4)
2652 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2654 if (linfo
->li_max_ops_per_insn
== 0)
2656 warn (_("Invalid maximum operations per insn.\n"));
2661 linfo
->li_max_ops_per_insn
= 1;
2663 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2664 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2665 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2666 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2668 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2673 display_debug_lines_raw (struct dwarf_section
*section
,
2674 unsigned char *data
,
2677 unsigned char *start
= section
->start
;
2679 printf (_("Raw dump of debug contents of section %s:\n\n"),
2684 static DWARF2_Internal_LineInfo saved_linfo
;
2685 DWARF2_Internal_LineInfo linfo
;
2686 unsigned char *standard_opcodes
;
2687 unsigned char *end_of_sequence
;
2688 unsigned int last_dir_entry
= 0;
2691 if (const_strneq (section
->name
, ".debug_line.")
2692 /* Note: the following does not apply to .debug_line.dwo sections.
2693 These are full debug_line sections. */
2694 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2696 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2697 section containing just the Line Number Statements. They are
2698 created by the assembler and intended to be used alongside gcc's
2699 -ffunction-sections command line option. When the linker's
2700 garbage collection decides to discard a .text.<foo> section it
2701 can then also discard the line number information in .debug_line.<foo>.
2703 Since the section is a fragment it does not have the details
2704 needed to fill out a LineInfo structure, so instead we use the
2705 details from the last full debug_line section that we processed. */
2706 end_of_sequence
= end
;
2707 standard_opcodes
= NULL
;
2708 linfo
= saved_linfo
;
2709 reset_state_machine (linfo
.li_default_is_stmt
);
2713 unsigned char * hdrptr
;
2715 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2716 & end_of_sequence
)) == NULL
)
2719 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2720 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2721 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2722 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2723 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2724 if (linfo
.li_version
>= 4)
2725 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2726 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2727 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2728 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2729 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2731 reset_state_machine (linfo
.li_default_is_stmt
);
2733 /* Display the contents of the Opcodes table. */
2734 standard_opcodes
= hdrptr
;
2736 printf (_("\n Opcodes:\n"));
2738 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2739 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2741 /* Display the contents of the Directory table. */
2742 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2745 printf (_("\n The Directory Table is empty.\n"));
2748 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2749 (long)(data
- start
));
2753 printf (" %d\t%s\n", ++last_dir_entry
, data
);
2755 data
+= strnlen ((char *) data
, end
- data
) + 1;
2759 /* Skip the NUL at the end of the table. */
2762 /* Display the contents of the File Name table. */
2764 printf (_("\n The File Name Table is empty.\n"));
2767 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2768 (long)(data
- start
));
2769 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2773 unsigned char *name
;
2774 unsigned int bytes_read
;
2776 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2778 data
+= strnlen ((char *) data
, end
- data
) + 1;
2781 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2784 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2787 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2789 printf ("%s\n", name
);
2793 warn (_("Corrupt file name table entry\n"));
2799 /* Skip the NUL at the end of the table. */
2802 saved_linfo
= linfo
;
2805 /* Now display the statements. */
2806 if (data
>= end_of_sequence
)
2807 printf (_(" No Line Number Statements.\n"));
2810 printf (_(" Line Number Statements:\n"));
2812 while (data
< end_of_sequence
)
2814 unsigned char op_code
;
2815 dwarf_signed_vma adv
;
2817 unsigned int bytes_read
;
2819 printf (" [0x%08lx]", (long)(data
- start
));
2823 if (op_code
>= linfo
.li_opcode_base
)
2825 op_code
-= linfo
.li_opcode_base
;
2826 uladv
= (op_code
/ linfo
.li_line_range
);
2827 if (linfo
.li_max_ops_per_insn
== 1)
2829 uladv
*= linfo
.li_min_insn_length
;
2830 state_machine_regs
.address
+= uladv
;
2831 printf (_(" Special opcode %d: "
2832 "advance Address by %s to 0x%s"),
2833 op_code
, dwarf_vmatoa ("u", uladv
),
2834 dwarf_vmatoa ("x", state_machine_regs
.address
));
2838 state_machine_regs
.address
2839 += ((state_machine_regs
.op_index
+ uladv
)
2840 / linfo
.li_max_ops_per_insn
)
2841 * linfo
.li_min_insn_length
;
2842 state_machine_regs
.op_index
2843 = (state_machine_regs
.op_index
+ uladv
)
2844 % linfo
.li_max_ops_per_insn
;
2845 printf (_(" Special opcode %d: "
2846 "advance Address by %s to 0x%s[%d]"),
2847 op_code
, dwarf_vmatoa ("u", uladv
),
2848 dwarf_vmatoa ("x", state_machine_regs
.address
),
2849 state_machine_regs
.op_index
);
2851 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2852 state_machine_regs
.line
+= adv
;
2853 printf (_(" and Line by %s to %d\n"),
2854 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
2856 else switch (op_code
)
2858 case DW_LNS_extended_op
:
2859 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
2863 printf (_(" Copy\n"));
2866 case DW_LNS_advance_pc
:
2867 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2869 if (linfo
.li_max_ops_per_insn
== 1)
2871 uladv
*= linfo
.li_min_insn_length
;
2872 state_machine_regs
.address
+= uladv
;
2873 printf (_(" Advance PC by %s to 0x%s\n"),
2874 dwarf_vmatoa ("u", uladv
),
2875 dwarf_vmatoa ("x", state_machine_regs
.address
));
2879 state_machine_regs
.address
2880 += ((state_machine_regs
.op_index
+ uladv
)
2881 / linfo
.li_max_ops_per_insn
)
2882 * linfo
.li_min_insn_length
;
2883 state_machine_regs
.op_index
2884 = (state_machine_regs
.op_index
+ uladv
)
2885 % linfo
.li_max_ops_per_insn
;
2886 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
2887 dwarf_vmatoa ("u", uladv
),
2888 dwarf_vmatoa ("x", state_machine_regs
.address
),
2889 state_machine_regs
.op_index
);
2893 case DW_LNS_advance_line
:
2894 adv
= read_sleb128 (data
, & bytes_read
, end
);
2896 state_machine_regs
.line
+= adv
;
2897 printf (_(" Advance Line by %s to %d\n"),
2898 dwarf_vmatoa ("d", adv
),
2899 state_machine_regs
.line
);
2902 case DW_LNS_set_file
:
2903 adv
= read_uleb128 (data
, & bytes_read
, end
);
2905 printf (_(" Set File Name to entry %s in the File Name Table\n"),
2906 dwarf_vmatoa ("d", adv
));
2907 state_machine_regs
.file
= adv
;
2910 case DW_LNS_set_column
:
2911 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2913 printf (_(" Set column to %s\n"),
2914 dwarf_vmatoa ("u", uladv
));
2915 state_machine_regs
.column
= uladv
;
2918 case DW_LNS_negate_stmt
:
2919 adv
= state_machine_regs
.is_stmt
;
2921 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
2922 state_machine_regs
.is_stmt
= adv
;
2925 case DW_LNS_set_basic_block
:
2926 printf (_(" Set basic block\n"));
2927 state_machine_regs
.basic_block
= 1;
2930 case DW_LNS_const_add_pc
:
2931 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
2932 if (linfo
.li_max_ops_per_insn
)
2934 uladv
*= linfo
.li_min_insn_length
;
2935 state_machine_regs
.address
+= uladv
;
2936 printf (_(" Advance PC by constant %s to 0x%s\n"),
2937 dwarf_vmatoa ("u", uladv
),
2938 dwarf_vmatoa ("x", state_machine_regs
.address
));
2942 state_machine_regs
.address
2943 += ((state_machine_regs
.op_index
+ uladv
)
2944 / linfo
.li_max_ops_per_insn
)
2945 * linfo
.li_min_insn_length
;
2946 state_machine_regs
.op_index
2947 = (state_machine_regs
.op_index
+ uladv
)
2948 % linfo
.li_max_ops_per_insn
;
2949 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
2950 dwarf_vmatoa ("u", uladv
),
2951 dwarf_vmatoa ("x", state_machine_regs
.address
),
2952 state_machine_regs
.op_index
);
2956 case DW_LNS_fixed_advance_pc
:
2957 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
2958 state_machine_regs
.address
+= uladv
;
2959 state_machine_regs
.op_index
= 0;
2960 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
2961 dwarf_vmatoa ("u", uladv
),
2962 dwarf_vmatoa ("x", state_machine_regs
.address
));
2965 case DW_LNS_set_prologue_end
:
2966 printf (_(" Set prologue_end to true\n"));
2969 case DW_LNS_set_epilogue_begin
:
2970 printf (_(" Set epilogue_begin to true\n"));
2973 case DW_LNS_set_isa
:
2974 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2976 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
2980 printf (_(" Unknown opcode %d with operands: "), op_code
);
2982 if (standard_opcodes
!= NULL
)
2983 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
2985 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
2987 i
== 1 ? "" : ", ");
3003 unsigned char *name
;
3004 unsigned int directory_index
;
3005 unsigned int modification_date
;
3006 unsigned int length
;
3009 /* Output a decoded representation of the .debug_line section. */
3012 display_debug_lines_decoded (struct dwarf_section
*section
,
3013 unsigned char *data
,
3016 static DWARF2_Internal_LineInfo saved_linfo
;
3018 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3023 /* This loop amounts to one iteration per compilation unit. */
3024 DWARF2_Internal_LineInfo linfo
;
3025 unsigned char *standard_opcodes
;
3026 unsigned char *end_of_sequence
;
3028 File_Entry
*file_table
= NULL
;
3029 unsigned int n_files
= 0;
3030 unsigned char **directory_table
= NULL
;
3031 unsigned int n_directories
= 0;
3033 if (const_strneq (section
->name
, ".debug_line.")
3034 /* Note: the following does not apply to .debug_line.dwo sections.
3035 These are full debug_line sections. */
3036 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3038 /* See comment in display_debug_lines_raw(). */
3039 end_of_sequence
= end
;
3040 standard_opcodes
= NULL
;
3041 linfo
= saved_linfo
;
3042 reset_state_machine (linfo
.li_default_is_stmt
);
3046 unsigned char *hdrptr
;
3048 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3049 & end_of_sequence
)) == NULL
)
3052 reset_state_machine (linfo
.li_default_is_stmt
);
3054 /* Save a pointer to the contents of the Opcodes table. */
3055 standard_opcodes
= hdrptr
;
3057 /* Traverse the Directory table just to count entries. */
3058 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3061 unsigned char *ptr_directory_table
= data
;
3065 data
+= strnlen ((char *) data
, end
- data
) + 1;
3069 /* Go through the directory table again to save the directories. */
3070 directory_table
= (unsigned char **)
3071 xmalloc (n_directories
* sizeof (unsigned char *));
3074 while (*ptr_directory_table
!= 0)
3076 directory_table
[i
] = ptr_directory_table
;
3077 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3078 ptr_directory_table
- end
) + 1;
3082 /* Skip the NUL at the end of the table. */
3085 /* Traverse the File Name table just to count the entries. */
3088 unsigned char *ptr_file_name_table
= data
;
3092 unsigned int bytes_read
;
3094 /* Skip Name, directory index, last modification time and length
3096 data
+= strnlen ((char *) data
, end
- data
) + 1;
3097 read_uleb128 (data
, & bytes_read
, end
);
3099 read_uleb128 (data
, & bytes_read
, end
);
3101 read_uleb128 (data
, & bytes_read
, end
);
3107 /* Go through the file table again to save the strings. */
3108 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3111 while (*ptr_file_name_table
!= 0)
3113 unsigned int bytes_read
;
3115 file_table
[i
].name
= ptr_file_name_table
;
3116 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3117 end
- ptr_file_name_table
) + 1;
3119 /* We are not interested in directory, time or size. */
3120 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3122 ptr_file_name_table
+= bytes_read
;
3123 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3125 ptr_file_name_table
+= bytes_read
;
3126 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3127 ptr_file_name_table
+= bytes_read
;
3132 /* Print the Compilation Unit's name and a header. */
3133 if (directory_table
== NULL
)
3135 printf (_("CU: %s:\n"), file_table
[0].name
);
3136 printf (_("File name Line number Starting address\n"));
3140 unsigned int ix
= file_table
[0].directory_index
;
3141 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3143 if (do_wide
|| strlen (directory
) < 76)
3144 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3146 printf ("%s:\n", file_table
[0].name
);
3148 printf (_("File name Line number Starting address\n"));
3152 /* Skip the NUL at the end of the table. */
3155 saved_linfo
= linfo
;
3158 /* This loop iterates through the Dwarf Line Number Program. */
3159 while (data
< end_of_sequence
)
3161 unsigned char op_code
;
3163 unsigned long int uladv
;
3164 unsigned int bytes_read
;
3165 int is_special_opcode
= 0;
3169 if (op_code
>= linfo
.li_opcode_base
)
3171 op_code
-= linfo
.li_opcode_base
;
3172 uladv
= (op_code
/ linfo
.li_line_range
);
3173 if (linfo
.li_max_ops_per_insn
== 1)
3175 uladv
*= linfo
.li_min_insn_length
;
3176 state_machine_regs
.address
+= uladv
;
3180 state_machine_regs
.address
3181 += ((state_machine_regs
.op_index
+ uladv
)
3182 / linfo
.li_max_ops_per_insn
)
3183 * linfo
.li_min_insn_length
;
3184 state_machine_regs
.op_index
3185 = (state_machine_regs
.op_index
+ uladv
)
3186 % linfo
.li_max_ops_per_insn
;
3189 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3190 state_machine_regs
.line
+= adv
;
3191 is_special_opcode
= 1;
3193 else switch (op_code
)
3195 case DW_LNS_extended_op
:
3197 unsigned int ext_op_code_len
;
3198 unsigned char ext_op_code
;
3199 unsigned char *op_code_data
= data
;
3201 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3203 op_code_data
+= bytes_read
;
3205 if (ext_op_code_len
== 0)
3207 warn (_("badly formed extended line op encountered!\n"));
3210 ext_op_code_len
+= bytes_read
;
3211 ext_op_code
= *op_code_data
++;
3213 switch (ext_op_code
)
3215 case DW_LNE_end_sequence
:
3216 reset_state_machine (linfo
.li_default_is_stmt
);
3218 case DW_LNE_set_address
:
3219 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3221 ext_op_code_len
- bytes_read
- 1,
3223 state_machine_regs
.op_index
= 0;
3225 case DW_LNE_define_file
:
3227 file_table
= (File_Entry
*) xrealloc
3228 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3230 ++state_machine_regs
.last_file_entry
;
3231 /* Source file name. */
3232 file_table
[n_files
].name
= op_code_data
;
3233 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3234 /* Directory index. */
3235 file_table
[n_files
].directory_index
=
3236 read_uleb128 (op_code_data
, & bytes_read
,
3238 op_code_data
+= bytes_read
;
3239 /* Last modification time. */
3240 file_table
[n_files
].modification_date
=
3241 read_uleb128 (op_code_data
, & bytes_read
,
3243 op_code_data
+= bytes_read
;
3245 file_table
[n_files
].length
=
3246 read_uleb128 (op_code_data
, & bytes_read
,
3252 case DW_LNE_set_discriminator
:
3253 case DW_LNE_HP_set_sequence
:
3254 /* Simply ignored. */
3258 printf (_("UNKNOWN (%u): length %d\n"),
3259 ext_op_code
, ext_op_code_len
- bytes_read
);
3262 data
+= ext_op_code_len
;
3268 case DW_LNS_advance_pc
:
3269 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3271 if (linfo
.li_max_ops_per_insn
== 1)
3273 uladv
*= linfo
.li_min_insn_length
;
3274 state_machine_regs
.address
+= uladv
;
3278 state_machine_regs
.address
3279 += ((state_machine_regs
.op_index
+ uladv
)
3280 / linfo
.li_max_ops_per_insn
)
3281 * linfo
.li_min_insn_length
;
3282 state_machine_regs
.op_index
3283 = (state_machine_regs
.op_index
+ uladv
)
3284 % linfo
.li_max_ops_per_insn
;
3288 case DW_LNS_advance_line
:
3289 adv
= read_sleb128 (data
, & bytes_read
, end
);
3291 state_machine_regs
.line
+= adv
;
3294 case DW_LNS_set_file
:
3295 adv
= read_uleb128 (data
, & bytes_read
, end
);
3297 state_machine_regs
.file
= adv
;
3299 if (file_table
== NULL
)
3300 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3301 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3302 /* If directory index is 0, that means current directory. */
3303 printf ("\n./%s:[++]\n",
3304 file_table
[state_machine_regs
.file
- 1].name
);
3305 else if (directory_table
== NULL
)
3306 printf (_("\n [Use directory table entry %d]\n"),
3307 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3309 /* The directory index starts counting at 1. */
3310 printf ("\n%s/%s:\n",
3311 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3312 file_table
[state_machine_regs
.file
- 1].name
);
3315 case DW_LNS_set_column
:
3316 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3318 state_machine_regs
.column
= uladv
;
3321 case DW_LNS_negate_stmt
:
3322 adv
= state_machine_regs
.is_stmt
;
3324 state_machine_regs
.is_stmt
= adv
;
3327 case DW_LNS_set_basic_block
:
3328 state_machine_regs
.basic_block
= 1;
3331 case DW_LNS_const_add_pc
:
3332 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3333 if (linfo
.li_max_ops_per_insn
== 1)
3335 uladv
*= linfo
.li_min_insn_length
;
3336 state_machine_regs
.address
+= uladv
;
3340 state_machine_regs
.address
3341 += ((state_machine_regs
.op_index
+ uladv
)
3342 / linfo
.li_max_ops_per_insn
)
3343 * linfo
.li_min_insn_length
;
3344 state_machine_regs
.op_index
3345 = (state_machine_regs
.op_index
+ uladv
)
3346 % linfo
.li_max_ops_per_insn
;
3350 case DW_LNS_fixed_advance_pc
:
3351 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3352 state_machine_regs
.address
+= uladv
;
3353 state_machine_regs
.op_index
= 0;
3356 case DW_LNS_set_prologue_end
:
3359 case DW_LNS_set_epilogue_begin
:
3362 case DW_LNS_set_isa
:
3363 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3365 printf (_(" Set ISA to %lu\n"), uladv
);
3369 printf (_(" Unknown opcode %d with operands: "), op_code
);
3371 if (standard_opcodes
!= NULL
)
3372 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3374 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3376 i
== 1 ? "" : ", ");
3383 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3384 to the DWARF address/line matrix. */
3385 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3386 || (op_code
== DW_LNS_copy
))
3388 const unsigned int MAX_FILENAME_LENGTH
= 35;
3390 char *newFileName
= NULL
;
3391 size_t fileNameLength
;
3394 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3396 fileName
= "<unknown>";
3398 fileNameLength
= strlen (fileName
);
3400 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3402 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3403 /* Truncate file name */
3404 strncpy (newFileName
,
3405 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3406 MAX_FILENAME_LENGTH
+ 1);
3410 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3411 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3414 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3416 if (linfo
.li_max_ops_per_insn
== 1)
3417 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3418 newFileName
, state_machine_regs
.line
,
3419 state_machine_regs
.address
);
3421 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3422 newFileName
, state_machine_regs
.line
,
3423 state_machine_regs
.address
,
3424 state_machine_regs
.op_index
);
3428 if (linfo
.li_max_ops_per_insn
== 1)
3429 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3430 newFileName
, state_machine_regs
.line
,
3431 state_machine_regs
.address
);
3433 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3434 newFileName
, state_machine_regs
.line
,
3435 state_machine_regs
.address
,
3436 state_machine_regs
.op_index
);
3439 if (op_code
== DW_LNE_end_sequence
)
3453 if (directory_table
)
3455 free (directory_table
);
3456 directory_table
= NULL
;
3467 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3469 unsigned char *data
= section
->start
;
3470 unsigned char *end
= data
+ section
->size
;
3472 int retValDecoded
= 1;
3474 if (do_debug_lines
== 0)
3475 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3477 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3478 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3480 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3481 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3483 if (!retValRaw
|| !retValDecoded
)
3490 find_debug_info_for_offset (unsigned long offset
)
3494 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3497 for (i
= 0; i
< num_debug_info_entries
; i
++)
3498 if (debug_information
[i
].cu_offset
== offset
)
3499 return debug_information
+ i
;
3505 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
3507 /* See gdb/gdb-index.h. */
3508 static const char * const kinds
[] =
3520 return _ (kinds
[kind
]);
3524 display_debug_pubnames_worker (struct dwarf_section
*section
,
3525 void *file ATTRIBUTE_UNUSED
,
3528 DWARF2_Internal_PubNames names
;
3529 unsigned char *start
= section
->start
;
3530 unsigned char *end
= start
+ section
->size
;
3532 /* It does not matter if this load fails,
3533 we test for that later on. */
3534 load_debug_info (file
);
3536 printf (_("Contents of the %s section:\n\n"), section
->name
);
3540 unsigned char *data
;
3541 unsigned long offset
;
3542 unsigned int offset_size
, initial_length_size
;
3546 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3547 if (names
.pn_length
== 0xffffffff)
3549 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3551 initial_length_size
= 12;
3556 initial_length_size
= 4;
3559 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3560 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3562 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3563 && num_debug_info_entries
> 0
3564 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3565 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3566 (unsigned long) names
.pn_offset
, section
->name
);
3568 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3570 start
+= names
.pn_length
+ initial_length_size
;
3572 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3574 static int warned
= 0;
3578 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3585 printf (_(" Length: %ld\n"),
3586 (long) names
.pn_length
);
3587 printf (_(" Version: %d\n"),
3589 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3590 (unsigned long) names
.pn_offset
);
3591 printf (_(" Size of area in .debug_info section: %ld\n"),
3592 (long) names
.pn_size
);
3595 printf (_("\n Offset Kind Name\n"));
3597 printf (_("\n Offset\tName\n"));
3601 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3605 data
+= offset_size
;
3608 unsigned int kind_data
;
3609 gdb_index_symbol_kind kind
;
3610 const char *kind_name
;
3613 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
3615 /* GCC computes the kind as the upper byte in the CU index
3616 word, and then right shifts it by the CU index size.
3617 Left shift KIND to where the gdb-index.h accessor macros
3619 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
3620 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
3621 kind_name
= get_gdb_index_symbol_kind_name (kind
);
3622 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
3623 printf (" %-6lx %s,%-10s %s\n",
3624 offset
, is_static
? _("s") : _("g"),
3628 printf (" %-6lx\t%s\n", offset
, data
);
3629 data
+= strnlen ((char *) data
, end
- data
) + 1;
3632 while (offset
!= 0);
3640 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
3642 return display_debug_pubnames_worker (section
, file
, 0);
3646 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
3648 return display_debug_pubnames_worker (section
, file
, 1);
3652 display_debug_macinfo (struct dwarf_section
*section
,
3653 void *file ATTRIBUTE_UNUSED
)
3655 unsigned char *start
= section
->start
;
3656 unsigned char *end
= start
+ section
->size
;
3657 unsigned char *curr
= start
;
3658 unsigned int bytes_read
;
3659 enum dwarf_macinfo_record_type op
;
3661 printf (_("Contents of the %s section:\n\n"), section
->name
);
3665 unsigned int lineno
;
3666 const unsigned char *string
;
3668 op
= (enum dwarf_macinfo_record_type
) *curr
;
3673 case DW_MACINFO_start_file
:
3675 unsigned int filenum
;
3677 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3679 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3682 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3687 case DW_MACINFO_end_file
:
3688 printf (_(" DW_MACINFO_end_file\n"));
3691 case DW_MACINFO_define
:
3692 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3695 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3696 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3700 case DW_MACINFO_undef
:
3701 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3704 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3705 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3709 case DW_MACINFO_vendor_ext
:
3711 unsigned int constant
;
3713 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3716 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3717 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3727 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3728 filename and dirname corresponding to file name table entry with index
3729 FILEIDX. Return NULL on failure. */
3731 static unsigned char *
3732 get_line_filename_and_dirname (dwarf_vma line_offset
,
3734 unsigned char **dir_name
)
3736 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3737 unsigned char *hdrptr
, *dirtable
, *file_name
;
3738 unsigned int offset_size
, initial_length_size
;
3739 unsigned int version
, opcode_base
, bytes_read
;
3740 dwarf_vma length
, diridx
;
3741 const unsigned char * end
;
3744 if (section
->start
== NULL
3745 || line_offset
>= section
->size
3749 hdrptr
= section
->start
+ line_offset
;
3750 end
= section
->start
+ section
->size
;
3752 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3753 if (length
== 0xffffffff)
3755 /* This section is 64-bit DWARF 3. */
3756 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3758 initial_length_size
= 12;
3763 initial_length_size
= 4;
3765 if (length
+ initial_length_size
> section
->size
)
3768 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3769 if (version
!= 2 && version
!= 3 && version
!= 4)
3771 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3773 hdrptr
++; /* Skip max_ops_per_insn. */
3774 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3776 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3777 if (opcode_base
== 0)
3780 hdrptr
+= opcode_base
- 1;
3782 /* Skip over dirname table. */
3783 while (*hdrptr
!= '\0')
3784 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3785 hdrptr
++; /* Skip the NUL at the end of the table. */
3786 /* Now skip over preceding filename table entries. */
3787 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3789 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3790 read_uleb128 (hdrptr
, &bytes_read
, end
);
3791 hdrptr
+= bytes_read
;
3792 read_uleb128 (hdrptr
, &bytes_read
, end
);
3793 hdrptr
+= bytes_read
;
3794 read_uleb128 (hdrptr
, &bytes_read
, end
);
3795 hdrptr
+= bytes_read
;
3797 if (hdrptr
== end
|| *hdrptr
== '\0')
3800 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3801 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
3804 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
3805 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
3806 if (*dirtable
== '\0')
3808 *dir_name
= dirtable
;
3813 display_debug_macro (struct dwarf_section
*section
,
3816 unsigned char *start
= section
->start
;
3817 unsigned char *end
= start
+ section
->size
;
3818 unsigned char *curr
= start
;
3819 unsigned char *extended_op_buf
[256];
3820 unsigned int bytes_read
;
3822 load_debug_section (str
, file
);
3823 load_debug_section (line
, file
);
3825 printf (_("Contents of the %s section:\n\n"), section
->name
);
3829 unsigned int lineno
, version
, flags
;
3830 unsigned int offset_size
= 4;
3831 const unsigned char *string
;
3832 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
3833 unsigned char **extended_ops
= NULL
;
3835 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
3838 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3843 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
3846 printf (_(" Offset: 0x%lx\n"),
3847 (unsigned long) sec_offset
);
3848 printf (_(" Version: %d\n"), version
);
3849 printf (_(" Offset size: %d\n"), offset_size
);
3852 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
3853 printf (_(" Offset into .debug_line: 0x%lx\n"),
3854 (unsigned long) line_offset
);
3858 unsigned int i
, count
, op
;
3861 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
3863 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
3864 extended_ops
= extended_op_buf
;
3867 printf (_(" Extension opcode arguments:\n"));
3868 for (i
= 0; i
< count
; i
++)
3870 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3871 extended_ops
[op
] = curr
;
3872 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
3875 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
3878 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
3879 for (n
= 0; n
< nargs
; n
++)
3883 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
3884 printf ("%s%s", get_FORM_name (form
),
3885 n
== nargs
- 1 ? "\n" : ", ");
3895 case DW_FORM_block1
:
3896 case DW_FORM_block2
:
3897 case DW_FORM_block4
:
3899 case DW_FORM_string
:
3901 case DW_FORM_sec_offset
:
3904 error (_("Invalid extension opcode form %s\n"),
3905 get_FORM_name (form
));
3921 error (_(".debug_macro section not zero terminated\n"));
3925 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3931 case DW_MACRO_GNU_start_file
:
3933 unsigned int filenum
;
3934 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
3936 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3938 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
3941 if ((flags
& 2) == 0)
3942 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
3945 = get_line_filename_and_dirname (line_offset
, filenum
,
3947 if (file_name
== NULL
)
3948 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
3951 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
3953 dir_name
!= NULL
? (const char *) dir_name
: "",
3954 dir_name
!= NULL
? "/" : "", file_name
);
3958 case DW_MACRO_GNU_end_file
:
3959 printf (_(" DW_MACRO_GNU_end_file\n"));
3962 case DW_MACRO_GNU_define
:
3963 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3966 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3967 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
3971 case DW_MACRO_GNU_undef
:
3972 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3975 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3976 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
3980 case DW_MACRO_GNU_define_indirect
:
3981 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3983 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3984 string
= fetch_indirect_string (offset
);
3985 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
3989 case DW_MACRO_GNU_undef_indirect
:
3990 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
3992 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
3993 string
= fetch_indirect_string (offset
);
3994 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
3998 case DW_MACRO_GNU_transparent_include
:
3999 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4000 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4001 (unsigned long) offset
);
4004 case DW_MACRO_GNU_define_indirect_alt
:
4005 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4007 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4008 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4009 lineno
, (unsigned long) offset
);
4012 case DW_MACRO_GNU_undef_indirect_alt
:
4013 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4015 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4016 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4017 lineno
, (unsigned long) offset
);
4020 case DW_MACRO_GNU_transparent_include_alt
:
4021 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4022 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4023 (unsigned long) offset
);
4027 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
4029 error (_(" Unknown macro opcode %02x seen\n"), op
);
4034 /* Skip over unhandled opcodes. */
4036 unsigned char *desc
= extended_ops
[op
];
4037 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
4041 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
4044 printf (_(" DW_MACRO_GNU_%02x -"), op
);
4045 for (n
= 0; n
< nargs
; n
++)
4049 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
4051 = read_and_display_attr_value (0, val
,
4052 curr
, end
, 0, 0, offset_size
,
4053 version
, NULL
, 0, NULL
,
4071 display_debug_abbrev (struct dwarf_section
*section
,
4072 void *file ATTRIBUTE_UNUSED
)
4074 abbrev_entry
*entry
;
4075 unsigned char *start
= section
->start
;
4076 unsigned char *end
= start
+ section
->size
;
4078 printf (_("Contents of the %s section:\n\n"), section
->name
);
4082 unsigned char *last
;
4087 start
= process_abbrev_section (start
, end
);
4089 if (first_abbrev
== NULL
)
4092 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4094 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4098 printf (" %ld %s [%s]\n",
4100 get_TAG_name (entry
->tag
),
4101 entry
->children
? _("has children") : _("no children"));
4103 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4104 printf (" %-18s %s\n",
4105 get_AT_name (attr
->attribute
),
4106 get_FORM_name (attr
->form
));
4116 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4119 display_loc_list (struct dwarf_section
*section
,
4120 unsigned char **start_ptr
,
4121 int debug_info_entry
,
4122 unsigned long offset
,
4123 unsigned long base_address
,
4126 unsigned char *start
= *start_ptr
;
4127 unsigned char *section_end
= section
->start
+ section
->size
;
4128 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4129 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4130 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4131 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4135 unsigned short length
;
4136 int need_frame_base
;
4140 if (start
+ 2 * pointer_size
> section_end
)
4142 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4147 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4149 /* Note: we use sign extension here in order to be sure that we can detect
4150 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4151 address will not affect the values that we display since we always show
4152 hex values, and always the bottom 32-bits. */
4153 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4154 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4156 if (begin
== 0 && end
== 0)
4158 printf (_("<End of list>\n"));
4162 /* Check base address specifiers. */
4163 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4166 print_dwarf_vma (begin
, pointer_size
);
4167 print_dwarf_vma (end
, pointer_size
);
4168 printf (_("(base address)\n"));
4172 if (start
+ 2 > section_end
)
4174 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4179 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4181 if (start
+ length
> section_end
)
4183 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4188 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4189 print_dwarf_vma (end
+ base_address
, pointer_size
);
4192 need_frame_base
= decode_location_expression (start
,
4197 cu_offset
, section
);
4200 if (need_frame_base
&& !has_frame_base
)
4201 printf (_(" [without DW_AT_frame_base]"));
4204 fputs (_(" (start == end)"), stdout
);
4205 else if (begin
> end
)
4206 fputs (_(" (start > end)"), stdout
);
4216 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4217 right-adjusted in a field of length LEN, and followed by a space. */
4220 print_addr_index (unsigned int idx
, unsigned int len
)
4222 static char buf
[15];
4223 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4224 printf ("%*s ", len
, buf
);
4227 /* Display a location list from a .dwo section. It uses address indexes rather
4228 than embedded addresses. This code closely follows display_loc_list, but the
4229 two are sufficiently different that combining things is very ugly. */
4232 display_loc_list_dwo (struct dwarf_section
*section
,
4233 unsigned char **start_ptr
,
4234 int debug_info_entry
,
4235 unsigned long offset
,
4238 unsigned char *start
= *start_ptr
;
4239 unsigned char *section_end
= section
->start
+ section
->size
;
4240 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4241 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4242 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4243 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4245 unsigned short length
;
4246 int need_frame_base
;
4248 unsigned int bytes_read
;
4252 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4254 if (start
>= section_end
)
4256 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4261 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4264 case 0: /* A terminating entry. */
4266 printf (_("<End of list>\n"));
4268 case 1: /* A base-address entry. */
4269 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4270 start
+= bytes_read
;
4271 print_addr_index (idx
, 8);
4273 printf (_("(base address selection entry)\n"));
4275 case 2: /* A start/end entry. */
4276 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4277 start
+= bytes_read
;
4278 print_addr_index (idx
, 8);
4279 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4280 start
+= bytes_read
;
4281 print_addr_index (idx
, 8);
4283 case 3: /* A start/length entry. */
4284 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4285 start
+= bytes_read
;
4286 print_addr_index (idx
, 8);
4287 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4288 printf ("%08x ", idx
);
4290 case 4: /* An offset pair entry. */
4291 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4292 printf ("%08x ", idx
);
4293 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4294 printf ("%08x ", idx
);
4297 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4302 if (start
+ 2 > section_end
)
4304 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4309 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4310 if (start
+ length
> section_end
)
4312 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4318 need_frame_base
= decode_location_expression (start
,
4323 cu_offset
, section
);
4326 if (need_frame_base
&& !has_frame_base
)
4327 printf (_(" [without DW_AT_frame_base]"));
4337 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4339 static dwarf_vma
*loc_offsets
;
4342 loc_offsets_compar (const void *ap
, const void *bp
)
4344 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4345 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4347 return (a
> b
) - (b
> a
);
4351 display_debug_loc (struct dwarf_section
*section
, void *file
)
4353 unsigned char *start
= section
->start
;
4354 unsigned long bytes
;
4355 unsigned char *section_begin
= start
;
4356 unsigned int num_loc_list
= 0;
4357 unsigned long last_offset
= 0;
4358 unsigned int first
= 0;
4362 int seen_first_offset
= 0;
4363 int locs_sorted
= 1;
4364 unsigned char *next
;
4365 unsigned int *array
= NULL
;
4366 const char *suffix
= strrchr (section
->name
, '.');
4369 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4372 bytes
= section
->size
;
4376 printf (_("\nThe %s section is empty.\n"), section
->name
);
4380 if (load_debug_info (file
) == 0)
4382 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4387 /* Check the order of location list in .debug_info section. If
4388 offsets of location lists are in the ascending order, we can
4389 use `debug_information' directly. */
4390 for (i
= 0; i
< num_debug_info_entries
; i
++)
4394 num
= debug_information
[i
].num_loc_offsets
;
4395 if (num
> num_loc_list
)
4398 /* Check if we can use `debug_information' directly. */
4399 if (locs_sorted
&& num
!= 0)
4401 if (!seen_first_offset
)
4403 /* This is the first location list. */
4404 last_offset
= debug_information
[i
].loc_offsets
[0];
4406 seen_first_offset
= 1;
4412 for (; j
< num
; j
++)
4415 debug_information
[i
].loc_offsets
[j
])
4420 last_offset
= debug_information
[i
].loc_offsets
[j
];
4425 if (!seen_first_offset
)
4426 error (_("No location lists in .debug_info section!\n"));
4428 if (debug_information
[first
].num_loc_offsets
> 0
4429 && debug_information
[first
].loc_offsets
[0] != 0)
4430 warn (_("Location lists in %s section start at 0x%s\n"),
4432 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4435 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4436 printf (_("Contents of the %s section:\n\n"), section
->name
);
4437 printf (_(" Offset Begin End Expression\n"));
4439 seen_first_offset
= 0;
4440 for (i
= first
; i
< num_debug_info_entries
; i
++)
4442 unsigned long offset
;
4443 unsigned long base_address
;
4448 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4450 loc_offsets
= debug_information
[i
].loc_offsets
;
4451 qsort (array
, debug_information
[i
].num_loc_offsets
,
4452 sizeof (*array
), loc_offsets_compar
);
4455 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4457 j
= locs_sorted
? k
: array
[k
];
4459 && debug_information
[i
].loc_offsets
[locs_sorted
4460 ? k
- 1 : array
[k
- 1]]
4461 == debug_information
[i
].loc_offsets
[j
])
4463 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4464 offset
= debug_information
[i
].loc_offsets
[j
];
4465 next
= section_begin
+ offset
;
4466 base_address
= debug_information
[i
].base_address
;
4468 if (!seen_first_offset
)
4469 seen_first_offset
= 1;
4473 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4474 (unsigned long) (start
- section_begin
),
4475 (unsigned long) (next
- section_begin
));
4476 else if (start
> next
)
4477 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4478 (unsigned long) (start
- section_begin
),
4479 (unsigned long) (next
- section_begin
));
4483 if (offset
>= bytes
)
4485 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4491 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4493 display_loc_list (section
, &start
, i
, offset
, base_address
,
4498 if (start
< section
->start
+ section
->size
)
4499 warn (_("There are %ld unused bytes at the end of section %s\n"),
4500 (long) (section
->start
+ section
->size
- start
), section
->name
);
4507 display_debug_str (struct dwarf_section
*section
,
4508 void *file ATTRIBUTE_UNUSED
)
4510 unsigned char *start
= section
->start
;
4511 unsigned long bytes
= section
->size
;
4512 dwarf_vma addr
= section
->address
;
4516 printf (_("\nThe %s section is empty.\n"), section
->name
);
4520 printf (_("Contents of the %s section:\n\n"), section
->name
);
4528 lbytes
= (bytes
> 16 ? 16 : bytes
);
4530 printf (" 0x%8.8lx ", (unsigned long) addr
);
4532 for (j
= 0; j
< 16; j
++)
4535 printf ("%2.2x", start
[j
]);
4543 for (j
= 0; j
< lbytes
; j
++)
4546 if (k
>= ' ' && k
< 0x80)
4565 display_debug_info (struct dwarf_section
*section
, void *file
)
4567 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4571 display_debug_types (struct dwarf_section
*section
, void *file
)
4573 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4577 display_trace_info (struct dwarf_section
*section
, void *file
)
4579 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4583 display_debug_aranges (struct dwarf_section
*section
,
4584 void *file ATTRIBUTE_UNUSED
)
4586 unsigned char *start
= section
->start
;
4587 unsigned char *end
= start
+ section
->size
;
4589 printf (_("Contents of the %s section:\n\n"), section
->name
);
4591 /* It does not matter if this load fails,
4592 we test for that later on. */
4593 load_debug_info (file
);
4597 unsigned char *hdrptr
;
4598 DWARF2_Internal_ARange arange
;
4599 unsigned char *addr_ranges
;
4602 unsigned char address_size
;
4604 unsigned int offset_size
;
4605 unsigned int initial_length_size
;
4609 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4610 if (arange
.ar_length
== 0xffffffff)
4612 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4614 initial_length_size
= 12;
4619 initial_length_size
= 4;
4622 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4623 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4625 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4626 && num_debug_info_entries
> 0
4627 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4628 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4629 (unsigned long) arange
.ar_info_offset
, section
->name
);
4631 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4632 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4634 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4636 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4640 printf (_(" Length: %ld\n"),
4641 (long) arange
.ar_length
);
4642 printf (_(" Version: %d\n"), arange
.ar_version
);
4643 printf (_(" Offset into .debug_info: 0x%lx\n"),
4644 (unsigned long) arange
.ar_info_offset
);
4645 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4646 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4648 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4650 if (address_size
== 0)
4652 error (_("Invalid address size in %s section!\n"),
4657 /* The DWARF spec does not require that the address size be a power
4658 of two, but we do. This will have to change if we ever encounter
4659 an uneven architecture. */
4660 if ((address_size
& (address_size
- 1)) != 0)
4662 warn (_("Pointer size + Segment size is not a power of two.\n"));
4666 if (address_size
> 4)
4667 printf (_("\n Address Length\n"));
4669 printf (_("\n Address Length\n"));
4671 addr_ranges
= hdrptr
;
4673 /* Must pad to an alignment boundary that is twice the address size. */
4674 excess
= (hdrptr
- start
) % (2 * address_size
);
4676 addr_ranges
+= (2 * address_size
) - excess
;
4678 start
+= arange
.ar_length
+ initial_length_size
;
4680 while (addr_ranges
+ 2 * address_size
<= start
)
4682 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4683 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4686 print_dwarf_vma (address
, address_size
);
4687 print_dwarf_vma (length
, address_size
);
4697 /* Comparison function for qsort. */
4699 comp_addr_base (const void * v0
, const void * v1
)
4701 debug_info
* info0
= (debug_info
*) v0
;
4702 debug_info
* info1
= (debug_info
*) v1
;
4703 return info0
->addr_base
- info1
->addr_base
;
4706 /* Display the debug_addr section. */
4708 display_debug_addr (struct dwarf_section
*section
,
4711 debug_info
**debug_addr_info
;
4712 unsigned char *entry
;
4717 if (section
->size
== 0)
4719 printf (_("\nThe %s section is empty.\n"), section
->name
);
4723 if (load_debug_info (file
) == 0)
4725 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4730 printf (_("Contents of the %s section:\n\n"), section
->name
);
4732 debug_addr_info
= (debug_info
**) xmalloc ((num_debug_info_entries
+ 1)
4733 * sizeof (debug_info
*));
4736 for (i
= 0; i
< num_debug_info_entries
; i
++)
4738 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4739 debug_addr_info
[count
++] = &debug_information
[i
];
4742 /* Add a sentinel to make iteration convenient. */
4743 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
4744 debug_addr_info
[count
]->addr_base
= section
->size
;
4746 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
4747 for (i
= 0; i
< count
; i
++)
4750 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
4752 printf (_(" For compilation unit at offset 0x%s:\n"),
4753 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
4755 printf (_("\tIndex\tAddress\n"));
4756 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
4757 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
4761 dwarf_vma base
= byte_get (entry
, address_size
);
4762 printf (_("\t%d:\t"), idx
);
4763 print_dwarf_vma (base
, address_size
);
4765 entry
+= address_size
;
4771 free (debug_addr_info
);
4775 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4777 display_debug_str_offsets (struct dwarf_section
*section
,
4778 void *file ATTRIBUTE_UNUSED
)
4780 if (section
->size
== 0)
4782 printf (_("\nThe %s section is empty.\n"), section
->name
);
4785 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
4786 what the offset size is for this section. */
4790 /* Each debug_information[x].range_lists[y] gets this representation for
4791 sorting purposes. */
4795 /* The debug_information[x].range_lists[y] value. */
4796 unsigned long ranges_offset
;
4798 /* Original debug_information to find parameters of the data. */
4799 debug_info
*debug_info_p
;
4802 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4805 range_entry_compar (const void *ap
, const void *bp
)
4807 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
4808 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
4809 const unsigned long a
= a_re
->ranges_offset
;
4810 const unsigned long b
= b_re
->ranges_offset
;
4812 return (a
> b
) - (b
> a
);
4816 display_debug_ranges (struct dwarf_section
*section
,
4817 void *file ATTRIBUTE_UNUSED
)
4819 unsigned char *start
= section
->start
;
4820 unsigned char *last_start
= start
;
4821 unsigned long bytes
= section
->size
;
4822 unsigned char *section_begin
= start
;
4823 unsigned char *finish
= start
+ bytes
;
4824 unsigned int num_range_list
, i
;
4825 struct range_entry
*range_entries
, *range_entry_fill
;
4829 printf (_("\nThe %s section is empty.\n"), section
->name
);
4833 if (load_debug_info (file
) == 0)
4835 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4841 for (i
= 0; i
< num_debug_info_entries
; i
++)
4842 num_range_list
+= debug_information
[i
].num_range_lists
;
4844 if (num_range_list
== 0)
4846 /* This can happen when the file was compiled with -gsplit-debug
4847 which removes references to range lists from the primary .o file. */
4848 printf (_("No range lists in .debug_info section.\n"));
4852 range_entries
= (struct range_entry
*)
4853 xmalloc (sizeof (*range_entries
) * num_range_list
);
4854 range_entry_fill
= range_entries
;
4856 for (i
= 0; i
< num_debug_info_entries
; i
++)
4858 debug_info
*debug_info_p
= &debug_information
[i
];
4861 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
4863 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
4864 range_entry_fill
->debug_info_p
= debug_info_p
;
4869 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
4870 range_entry_compar
);
4872 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
4873 warn (_("Range lists in %s section start at 0x%lx\n"),
4874 section
->name
, range_entries
[0].ranges_offset
);
4876 printf (_("Contents of the %s section:\n\n"), section
->name
);
4877 printf (_(" Offset Begin End\n"));
4879 for (i
= 0; i
< num_range_list
; i
++)
4881 struct range_entry
*range_entry
= &range_entries
[i
];
4882 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
4883 unsigned int pointer_size
;
4884 unsigned long offset
;
4885 unsigned char *next
;
4886 unsigned long base_address
;
4888 pointer_size
= debug_info_p
->pointer_size
;
4890 offset
= range_entry
->ranges_offset
;
4891 next
= section_begin
+ offset
;
4892 base_address
= debug_info_p
->base_address
;
4894 if (dwarf_check
!= 0 && i
> 0)
4897 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4898 (unsigned long) (start
- section_begin
),
4899 (unsigned long) (next
- section_begin
), section
->name
);
4900 else if (start
> next
)
4902 if (next
== last_start
)
4904 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
4905 (unsigned long) (start
- section_begin
),
4906 (unsigned long) (next
- section_begin
), section
->name
);
4912 while (start
< finish
)
4917 /* Note: we use sign extension here in order to be sure that
4918 we can detect the -1 escape value. Sign extension into the
4919 top 32 bits of a 32-bit address will not affect the values
4920 that we display since we always show hex values, and always
4921 the bottom 32-bits. */
4922 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
4923 if (start
>= finish
)
4925 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
4927 printf (" %8.8lx ", offset
);
4929 if (begin
== 0 && end
== 0)
4931 printf (_("<End of list>\n"));
4935 /* Check base address specifiers. */
4936 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4939 print_dwarf_vma (begin
, pointer_size
);
4940 print_dwarf_vma (end
, pointer_size
);
4941 printf ("(base address)\n");
4945 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4946 print_dwarf_vma (end
+ base_address
, pointer_size
);
4949 fputs (_("(start == end)"), stdout
);
4950 else if (begin
> end
)
4951 fputs (_("(start > end)"), stdout
);
4958 free (range_entries
);
4963 typedef struct Frame_Chunk
4965 struct Frame_Chunk
*next
;
4966 unsigned char *chunk_start
;
4968 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
4969 short int *col_type
;
4972 unsigned int code_factor
;
4979 unsigned char fde_encoding
;
4980 unsigned char cfa_exp
;
4981 unsigned char ptr_size
;
4982 unsigned char segment_size
;
4986 static const char *const *dwarf_regnames
;
4987 static unsigned int dwarf_regnames_count
;
4989 /* A marker for a col_type that means this column was never referenced
4990 in the frame info. */
4991 #define DW_CFA_unreferenced (-1)
4993 /* Return 0 if not more space is needed, 1 if more space is needed,
4994 -1 for invalid reg. */
4997 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
4999 int prev
= fc
->ncols
;
5001 if (reg
< (unsigned int) fc
->ncols
)
5004 if (dwarf_regnames_count
5005 && reg
> dwarf_regnames_count
)
5008 fc
->ncols
= reg
+ 1;
5009 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
5010 sizeof (short int));
5011 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
5013 while (prev
< fc
->ncols
)
5015 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
5016 fc
->col_offset
[prev
] = 0;
5022 static const char *const dwarf_regnames_i386
[] =
5024 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5025 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5026 "eip", "eflags", NULL
, /* 8 - 10 */
5027 "st0", "st1", "st2", "st3", /* 11 - 14 */
5028 "st4", "st5", "st6", "st7", /* 15 - 18 */
5029 NULL
, NULL
, /* 19 - 20 */
5030 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5031 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5032 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5033 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5034 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5035 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5036 "tr", "ldtr", /* 48 - 49 */
5037 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5038 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5039 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5040 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5041 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5042 NULL
, NULL
, NULL
, /* 90 - 92 */
5043 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5047 init_dwarf_regnames_i386 (void)
5049 dwarf_regnames
= dwarf_regnames_i386
;
5050 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5053 static const char *const dwarf_regnames_x86_64
[] =
5055 "rax", "rdx", "rcx", "rbx",
5056 "rsi", "rdi", "rbp", "rsp",
5057 "r8", "r9", "r10", "r11",
5058 "r12", "r13", "r14", "r15",
5060 "xmm0", "xmm1", "xmm2", "xmm3",
5061 "xmm4", "xmm5", "xmm6", "xmm7",
5062 "xmm8", "xmm9", "xmm10", "xmm11",
5063 "xmm12", "xmm13", "xmm14", "xmm15",
5064 "st0", "st1", "st2", "st3",
5065 "st4", "st5", "st6", "st7",
5066 "mm0", "mm1", "mm2", "mm3",
5067 "mm4", "mm5", "mm6", "mm7",
5069 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5070 "fs.base", "gs.base", NULL
, NULL
,
5072 "mxcsr", "fcw", "fsw",
5073 "xmm16", "xmm17", "xmm18", "xmm19",
5074 "xmm20", "xmm21", "xmm22", "xmm23",
5075 "xmm24", "xmm25", "xmm26", "xmm27",
5076 "xmm28", "xmm29", "xmm30", "xmm31",
5077 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5078 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5079 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5080 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5081 NULL
, NULL
, NULL
, /* 115 - 117 */
5082 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5086 init_dwarf_regnames_x86_64 (void)
5088 dwarf_regnames
= dwarf_regnames_x86_64
;
5089 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5092 static const char *const dwarf_regnames_aarch64
[] =
5094 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5095 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5096 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5097 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5098 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5099 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5100 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5101 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5102 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5103 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5104 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5105 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5109 init_dwarf_regnames_aarch64 (void)
5111 dwarf_regnames
= dwarf_regnames_aarch64
;
5112 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
5116 init_dwarf_regnames (unsigned int e_machine
)
5122 init_dwarf_regnames_i386 ();
5128 init_dwarf_regnames_x86_64 ();
5132 init_dwarf_regnames_aarch64 ();
5141 regname (unsigned int regno
, int row
)
5143 static char reg
[64];
5145 && regno
< dwarf_regnames_count
5146 && dwarf_regnames
[regno
] != NULL
)
5149 return dwarf_regnames
[regno
];
5150 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5151 dwarf_regnames
[regno
]);
5154 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5159 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
5164 if (*max_regs
< fc
->ncols
)
5165 *max_regs
= fc
->ncols
;
5167 if (*need_col_headers
)
5169 static const char *sloc
= " LOC";
5171 *need_col_headers
= 0;
5173 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5175 for (r
= 0; r
< *max_regs
; r
++)
5176 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5181 printf ("%-5s ", regname (r
, 1));
5187 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5189 strcpy (tmp
, "exp");
5191 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5192 printf ("%-8s ", tmp
);
5194 for (r
= 0; r
< fc
->ncols
; r
++)
5196 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5198 switch (fc
->col_type
[r
])
5200 case DW_CFA_undefined
:
5203 case DW_CFA_same_value
:
5207 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5209 case DW_CFA_val_offset
:
5210 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5212 case DW_CFA_register
:
5213 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5215 case DW_CFA_expression
:
5216 strcpy (tmp
, "exp");
5218 case DW_CFA_val_expression
:
5219 strcpy (tmp
, "vexp");
5222 strcpy (tmp
, "n/a");
5225 printf ("%-5s ", tmp
);
5231 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5232 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5233 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5235 static unsigned char *
5236 read_cie (unsigned char *start
, unsigned char *end
,
5237 Frame_Chunk
**p_cie
, int *p_version
,
5238 unsigned long *p_aug_len
, unsigned char **p_aug
)
5242 unsigned int length_return
;
5243 unsigned char *augmentation_data
= NULL
;
5244 unsigned long augmentation_data_len
= 0;
5246 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5247 memset (fc
, 0, sizeof (Frame_Chunk
));
5249 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5250 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5254 fc
->augmentation
= (char *) start
;
5255 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
5257 if (strcmp (fc
->augmentation
, "eh") == 0)
5258 start
+= eh_addr_size
;
5262 GET (fc
->ptr_size
, 1);
5263 GET (fc
->segment_size
, 1);
5264 eh_addr_size
= fc
->ptr_size
;
5268 fc
->ptr_size
= eh_addr_size
;
5269 fc
->segment_size
= 0;
5271 fc
->code_factor
= LEB ();
5272 fc
->data_factor
= SLEB ();
5282 if (fc
->augmentation
[0] == 'z')
5284 augmentation_data_len
= LEB ();
5285 augmentation_data
= start
;
5286 start
+= augmentation_data_len
;
5289 if (augmentation_data_len
)
5291 unsigned char *p
, *q
;
5292 p
= (unsigned char *) fc
->augmentation
+ 1;
5293 q
= augmentation_data
;
5300 q
+= 1 + size_of_encoded_value (*q
);
5302 fc
->fde_encoding
= *q
++;
5313 *p_version
= version
;
5316 *p_aug_len
= augmentation_data_len
;
5317 *p_aug
= augmentation_data
;
5323 display_debug_frames (struct dwarf_section
*section
,
5324 void *file ATTRIBUTE_UNUSED
)
5326 unsigned char *start
= section
->start
;
5327 unsigned char *end
= start
+ section
->size
;
5328 unsigned char *section_start
= start
;
5329 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
5330 Frame_Chunk
*remembered_state
= 0;
5332 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5333 unsigned int length_return
;
5335 const char *bad_reg
= _("bad register: ");
5336 int saved_eh_addr_size
= eh_addr_size
;
5338 printf (_("Contents of the %s section:\n"), section
->name
);
5342 unsigned char *saved_start
;
5343 unsigned char *block_end
;
5348 int need_col_headers
= 1;
5349 unsigned char *augmentation_data
= NULL
;
5350 unsigned long augmentation_data_len
= 0;
5351 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5352 unsigned int offset_size
;
5353 unsigned int initial_length_size
;
5355 saved_start
= start
;
5357 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5360 printf ("\n%08lx ZERO terminator\n\n",
5361 (unsigned long)(saved_start
- section_start
));
5365 if (length
== 0xffffffff)
5367 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5369 initial_length_size
= 12;
5374 initial_length_size
= 4;
5377 block_end
= saved_start
+ length
+ initial_length_size
;
5378 if (block_end
> end
)
5380 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5381 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5382 (unsigned long) (saved_start
- section_start
));
5386 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5388 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5389 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5394 start
= read_cie (start
, end
, &cie
, &version
,
5395 &augmentation_data_len
, &augmentation_data
);
5399 fc
->chunk_start
= saved_start
;
5400 mreg
= max_regs
- 1;
5403 frame_need_space (fc
, mreg
);
5404 if (fc
->fde_encoding
)
5405 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5407 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5408 print_dwarf_vma (length
, fc
->ptr_size
);
5409 print_dwarf_vma (cie_id
, offset_size
);
5411 if (do_debug_frames_interp
)
5413 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5414 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5419 printf (" Version: %d\n", version
);
5420 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5423 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5424 printf (" Segment Size: %u\n", fc
->segment_size
);
5426 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5427 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5428 printf (" Return address column: %d\n", fc
->ra
);
5430 if (augmentation_data_len
)
5433 printf (" Augmentation data: ");
5434 for (i
= 0; i
< augmentation_data_len
; ++i
)
5435 printf (" %02x", augmentation_data
[i
]);
5443 unsigned char *look_for
;
5444 static Frame_Chunk fde_fc
;
5445 unsigned long segment_selector
;
5449 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
5450 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
5453 look_for
= section_start
+ cie_id
;
5455 if (look_for
<= saved_start
)
5457 for (cie
= chunks
; cie
; cie
= cie
->next
)
5458 if (cie
->chunk_start
== look_for
)
5463 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
5464 if (cie
->chunk_start
== look_for
)
5468 unsigned int off_size
;
5469 unsigned char *cie_scan
;
5471 cie_scan
= look_for
;
5473 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
5474 if (length
== 0xffffffff)
5476 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
5483 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
5486 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
5487 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
5492 read_cie (cie_scan
, end
, &cie
, &version
,
5493 &augmentation_data_len
, &augmentation_data
);
5494 cie
->next
= forward_refs
;
5496 cie
->chunk_start
= look_for
;
5497 mreg
= max_regs
- 1;
5500 frame_need_space (cie
, mreg
);
5501 if (cie
->fde_encoding
)
5503 = size_of_encoded_value (cie
->fde_encoding
);
5510 memset (fc
, 0, sizeof (Frame_Chunk
));
5514 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5515 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5516 (unsigned long) (saved_start
- section_start
));
5518 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5519 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5520 frame_need_space (fc
, max_regs
- 1);
5522 fc
->augmentation
= "";
5523 fc
->fde_encoding
= 0;
5524 fc
->ptr_size
= eh_addr_size
;
5525 fc
->segment_size
= 0;
5529 fc
->ncols
= cie
->ncols
;
5530 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5531 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5532 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5533 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5534 fc
->augmentation
= cie
->augmentation
;
5535 fc
->ptr_size
= cie
->ptr_size
;
5536 eh_addr_size
= cie
->ptr_size
;
5537 fc
->segment_size
= cie
->segment_size
;
5538 fc
->code_factor
= cie
->code_factor
;
5539 fc
->data_factor
= cie
->data_factor
;
5540 fc
->cfa_reg
= cie
->cfa_reg
;
5541 fc
->cfa_offset
= cie
->cfa_offset
;
5543 frame_need_space (fc
, max_regs
- 1);
5544 fc
->fde_encoding
= cie
->fde_encoding
;
5547 if (fc
->fde_encoding
)
5548 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5550 segment_selector
= 0;
5551 if (fc
->segment_size
)
5553 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5555 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
, section
);
5556 start
+= encoded_ptr_size
;
5558 /* FIXME: It appears that sometimes the final pc_range value is
5559 encoded in less than encoded_ptr_size bytes. See the x86_64
5560 run of the "objcopy on compressed debug sections" test for an
5562 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5564 if (cie
->augmentation
[0] == 'z')
5566 augmentation_data_len
= LEB ();
5567 augmentation_data
= start
;
5568 start
+= augmentation_data_len
;
5571 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5572 (unsigned long)(saved_start
- section_start
),
5573 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
5574 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5575 (unsigned long)(cie
->chunk_start
- section_start
));
5577 if (fc
->segment_size
)
5578 printf ("%04lx:", segment_selector
);
5581 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
5582 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
5584 if (! do_debug_frames_interp
&& augmentation_data_len
)
5588 printf (" Augmentation data: ");
5589 for (i
= 0; i
< augmentation_data_len
; ++i
)
5590 printf (" %02x", augmentation_data
[i
]);
5596 /* At this point, fc is the current chunk, cie (if any) is set, and
5597 we're about to interpret instructions for the chunk. */
5598 /* ??? At present we need to do this always, since this sizes the
5599 fc->col_type and fc->col_offset arrays, which we write into always.
5600 We should probably split the interpreted and non-interpreted bits
5601 into two different routines, since there's so much that doesn't
5602 really overlap between them. */
5603 if (1 || do_debug_frames_interp
)
5605 /* Start by making a pass over the chunk, allocating storage
5606 and taking note of what registers are used. */
5607 unsigned char *tmp
= start
;
5609 while (start
< block_end
)
5612 unsigned long reg
, temp
;
5619 /* Warning: if you add any more cases to this switch, be
5620 sure to add them to the corresponding switch below. */
5623 case DW_CFA_advance_loc
:
5627 if (frame_need_space (fc
, opa
) >= 0)
5628 fc
->col_type
[opa
] = DW_CFA_undefined
;
5630 case DW_CFA_restore
:
5631 if (frame_need_space (fc
, opa
) >= 0)
5632 fc
->col_type
[opa
] = DW_CFA_undefined
;
5634 case DW_CFA_set_loc
:
5635 start
+= encoded_ptr_size
;
5637 case DW_CFA_advance_loc1
:
5640 case DW_CFA_advance_loc2
:
5643 case DW_CFA_advance_loc4
:
5646 case DW_CFA_offset_extended
:
5647 case DW_CFA_val_offset
:
5648 reg
= LEB (); LEB ();
5649 if (frame_need_space (fc
, reg
) >= 0)
5650 fc
->col_type
[reg
] = DW_CFA_undefined
;
5652 case DW_CFA_restore_extended
:
5654 frame_need_space (fc
, reg
);
5655 if (frame_need_space (fc
, reg
) >= 0)
5656 fc
->col_type
[reg
] = DW_CFA_undefined
;
5658 case DW_CFA_undefined
:
5660 if (frame_need_space (fc
, reg
) >= 0)
5661 fc
->col_type
[reg
] = DW_CFA_undefined
;
5663 case DW_CFA_same_value
:
5665 if (frame_need_space (fc
, reg
) >= 0)
5666 fc
->col_type
[reg
] = DW_CFA_undefined
;
5668 case DW_CFA_register
:
5669 reg
= LEB (); LEB ();
5670 if (frame_need_space (fc
, reg
) >= 0)
5671 fc
->col_type
[reg
] = DW_CFA_undefined
;
5673 case DW_CFA_def_cfa
:
5676 case DW_CFA_def_cfa_register
:
5679 case DW_CFA_def_cfa_offset
:
5682 case DW_CFA_def_cfa_expression
:
5686 case DW_CFA_expression
:
5687 case DW_CFA_val_expression
:
5691 if (frame_need_space (fc
, reg
) >= 0)
5692 fc
->col_type
[reg
] = DW_CFA_undefined
;
5694 case DW_CFA_offset_extended_sf
:
5695 case DW_CFA_val_offset_sf
:
5696 reg
= LEB (); SLEB ();
5697 if (frame_need_space (fc
, reg
) >= 0)
5698 fc
->col_type
[reg
] = DW_CFA_undefined
;
5700 case DW_CFA_def_cfa_sf
:
5703 case DW_CFA_def_cfa_offset_sf
:
5706 case DW_CFA_MIPS_advance_loc8
:
5709 case DW_CFA_GNU_args_size
:
5712 case DW_CFA_GNU_negative_offset_extended
:
5713 reg
= LEB (); LEB ();
5714 if (frame_need_space (fc
, reg
) >= 0)
5715 fc
->col_type
[reg
] = DW_CFA_undefined
;
5724 /* Now we know what registers are used, make a second pass over
5725 the chunk, this time actually printing out the info. */
5727 while (start
< block_end
)
5730 unsigned long ul
, reg
, roffs
;
5734 const char *reg_prefix
= "";
5741 /* Warning: if you add any more cases to this switch, be
5742 sure to add them to the corresponding switch above. */
5745 case DW_CFA_advance_loc
:
5746 if (do_debug_frames_interp
)
5747 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5749 printf (" DW_CFA_advance_loc: %d to %s\n",
5750 opa
* fc
->code_factor
,
5751 dwarf_vmatoa_1 (NULL
,
5752 fc
->pc_begin
+ opa
* fc
->code_factor
,
5754 fc
->pc_begin
+= opa
* fc
->code_factor
;
5759 if (opa
>= (unsigned int) fc
->ncols
)
5760 reg_prefix
= bad_reg
;
5761 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5762 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
5763 reg_prefix
, regname (opa
, 0),
5764 roffs
* fc
->data_factor
);
5765 if (*reg_prefix
== '\0')
5767 fc
->col_type
[opa
] = DW_CFA_offset
;
5768 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
5772 case DW_CFA_restore
:
5773 if (opa
>= (unsigned int) cie
->ncols
5774 || opa
>= (unsigned int) fc
->ncols
)
5775 reg_prefix
= bad_reg
;
5776 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5777 printf (" DW_CFA_restore: %s%s\n",
5778 reg_prefix
, regname (opa
, 0));
5779 if (*reg_prefix
== '\0')
5781 fc
->col_type
[opa
] = cie
->col_type
[opa
];
5782 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
5783 if (do_debug_frames_interp
5784 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
5785 fc
->col_type
[opa
] = DW_CFA_undefined
;
5789 case DW_CFA_set_loc
:
5790 vma
= get_encoded_value (start
, fc
->fde_encoding
, section
);
5791 start
+= encoded_ptr_size
;
5792 if (do_debug_frames_interp
)
5793 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5795 printf (" DW_CFA_set_loc: %s\n",
5796 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
5800 case DW_CFA_advance_loc1
:
5801 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
5802 if (do_debug_frames_interp
)
5803 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5805 printf (" DW_CFA_advance_loc1: %ld to %s\n",
5806 (unsigned long) (ofs
* fc
->code_factor
),
5807 dwarf_vmatoa_1 (NULL
,
5808 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5810 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5813 case DW_CFA_advance_loc2
:
5814 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, end
);
5815 if (do_debug_frames_interp
)
5816 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5818 printf (" DW_CFA_advance_loc2: %ld to %s\n",
5819 (unsigned long) (ofs
* fc
->code_factor
),
5820 dwarf_vmatoa_1 (NULL
,
5821 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5823 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5826 case DW_CFA_advance_loc4
:
5827 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, end
);
5828 if (do_debug_frames_interp
)
5829 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5831 printf (" DW_CFA_advance_loc4: %ld to %s\n",
5832 (unsigned long) (ofs
* fc
->code_factor
),
5833 dwarf_vmatoa_1 (NULL
,
5834 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5836 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5839 case DW_CFA_offset_extended
:
5842 if (reg
>= (unsigned int) fc
->ncols
)
5843 reg_prefix
= bad_reg
;
5844 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5845 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5846 reg_prefix
, regname (reg
, 0),
5847 roffs
* fc
->data_factor
);
5848 if (*reg_prefix
== '\0')
5850 fc
->col_type
[reg
] = DW_CFA_offset
;
5851 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
5855 case DW_CFA_val_offset
:
5858 if (reg
>= (unsigned int) fc
->ncols
)
5859 reg_prefix
= bad_reg
;
5860 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5861 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
5862 reg_prefix
, regname (reg
, 0),
5863 roffs
* fc
->data_factor
);
5864 if (*reg_prefix
== '\0')
5866 fc
->col_type
[reg
] = DW_CFA_val_offset
;
5867 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
5871 case DW_CFA_restore_extended
:
5873 if (reg
>= (unsigned int) cie
->ncols
5874 || reg
>= (unsigned int) fc
->ncols
)
5875 reg_prefix
= bad_reg
;
5876 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5877 printf (" DW_CFA_restore_extended: %s%s\n",
5878 reg_prefix
, regname (reg
, 0));
5879 if (*reg_prefix
== '\0')
5881 fc
->col_type
[reg
] = cie
->col_type
[reg
];
5882 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
5886 case DW_CFA_undefined
:
5888 if (reg
>= (unsigned int) fc
->ncols
)
5889 reg_prefix
= bad_reg
;
5890 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5891 printf (" DW_CFA_undefined: %s%s\n",
5892 reg_prefix
, regname (reg
, 0));
5893 if (*reg_prefix
== '\0')
5895 fc
->col_type
[reg
] = DW_CFA_undefined
;
5896 fc
->col_offset
[reg
] = 0;
5900 case DW_CFA_same_value
:
5902 if (reg
>= (unsigned int) fc
->ncols
)
5903 reg_prefix
= bad_reg
;
5904 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5905 printf (" DW_CFA_same_value: %s%s\n",
5906 reg_prefix
, regname (reg
, 0));
5907 if (*reg_prefix
== '\0')
5909 fc
->col_type
[reg
] = DW_CFA_same_value
;
5910 fc
->col_offset
[reg
] = 0;
5914 case DW_CFA_register
:
5917 if (reg
>= (unsigned int) fc
->ncols
)
5918 reg_prefix
= bad_reg
;
5919 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5921 printf (" DW_CFA_register: %s%s in ",
5922 reg_prefix
, regname (reg
, 0));
5923 puts (regname (roffs
, 0));
5925 if (*reg_prefix
== '\0')
5927 fc
->col_type
[reg
] = DW_CFA_register
;
5928 fc
->col_offset
[reg
] = roffs
;
5932 case DW_CFA_remember_state
:
5933 if (! do_debug_frames_interp
)
5934 printf (" DW_CFA_remember_state\n");
5935 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5936 rs
->cfa_offset
= fc
->cfa_offset
;
5937 rs
->cfa_reg
= fc
->cfa_reg
;
5939 rs
->cfa_exp
= fc
->cfa_exp
;
5940 rs
->ncols
= fc
->ncols
;
5941 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
5942 sizeof (* rs
->col_type
));
5943 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
5944 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
5945 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
5946 rs
->next
= remembered_state
;
5947 remembered_state
= rs
;
5950 case DW_CFA_restore_state
:
5951 if (! do_debug_frames_interp
)
5952 printf (" DW_CFA_restore_state\n");
5953 rs
= remembered_state
;
5956 remembered_state
= rs
->next
;
5957 fc
->cfa_offset
= rs
->cfa_offset
;
5958 fc
->cfa_reg
= rs
->cfa_reg
;
5960 fc
->cfa_exp
= rs
->cfa_exp
;
5961 frame_need_space (fc
, rs
->ncols
- 1);
5962 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
5963 memcpy (fc
->col_offset
, rs
->col_offset
,
5964 rs
->ncols
* sizeof (* rs
->col_offset
));
5965 free (rs
->col_type
);
5966 free (rs
->col_offset
);
5969 else if (do_debug_frames_interp
)
5970 printf ("Mismatched DW_CFA_restore_state\n");
5973 case DW_CFA_def_cfa
:
5974 fc
->cfa_reg
= LEB ();
5975 fc
->cfa_offset
= LEB ();
5977 if (! do_debug_frames_interp
)
5978 printf (" DW_CFA_def_cfa: %s ofs %d\n",
5979 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
5982 case DW_CFA_def_cfa_register
:
5983 fc
->cfa_reg
= LEB ();
5985 if (! do_debug_frames_interp
)
5986 printf (" DW_CFA_def_cfa_register: %s\n",
5987 regname (fc
->cfa_reg
, 0));
5990 case DW_CFA_def_cfa_offset
:
5991 fc
->cfa_offset
= LEB ();
5992 if (! do_debug_frames_interp
)
5993 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
5997 if (! do_debug_frames_interp
)
5998 printf (" DW_CFA_nop\n");
6001 case DW_CFA_def_cfa_expression
:
6003 if (! do_debug_frames_interp
)
6005 printf (" DW_CFA_def_cfa_expression (");
6006 decode_location_expression (start
, eh_addr_size
, 0, -1,
6014 case DW_CFA_expression
:
6017 if (reg
>= (unsigned int) fc
->ncols
)
6018 reg_prefix
= bad_reg
;
6019 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6021 printf (" DW_CFA_expression: %s%s (",
6022 reg_prefix
, regname (reg
, 0));
6023 decode_location_expression (start
, eh_addr_size
, 0, -1,
6027 if (*reg_prefix
== '\0')
6028 fc
->col_type
[reg
] = DW_CFA_expression
;
6032 case DW_CFA_val_expression
:
6035 if (reg
>= (unsigned int) fc
->ncols
)
6036 reg_prefix
= bad_reg
;
6037 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6039 printf (" DW_CFA_val_expression: %s%s (",
6040 reg_prefix
, regname (reg
, 0));
6041 decode_location_expression (start
, eh_addr_size
, 0, -1,
6045 if (*reg_prefix
== '\0')
6046 fc
->col_type
[reg
] = DW_CFA_val_expression
;
6050 case DW_CFA_offset_extended_sf
:
6053 if (frame_need_space (fc
, reg
) < 0)
6054 reg_prefix
= bad_reg
;
6055 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6056 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6057 reg_prefix
, regname (reg
, 0),
6058 l
* fc
->data_factor
);
6059 if (*reg_prefix
== '\0')
6061 fc
->col_type
[reg
] = DW_CFA_offset
;
6062 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6066 case DW_CFA_val_offset_sf
:
6069 if (frame_need_space (fc
, reg
) < 0)
6070 reg_prefix
= bad_reg
;
6071 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6072 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6073 reg_prefix
, regname (reg
, 0),
6074 l
* fc
->data_factor
);
6075 if (*reg_prefix
== '\0')
6077 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6078 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6082 case DW_CFA_def_cfa_sf
:
6083 fc
->cfa_reg
= LEB ();
6084 fc
->cfa_offset
= SLEB ();
6085 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6087 if (! do_debug_frames_interp
)
6088 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6089 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6092 case DW_CFA_def_cfa_offset_sf
:
6093 fc
->cfa_offset
= SLEB ();
6094 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6095 if (! do_debug_frames_interp
)
6096 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
6099 case DW_CFA_MIPS_advance_loc8
:
6100 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, end
);
6101 if (do_debug_frames_interp
)
6102 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6104 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6105 (unsigned long) (ofs
* fc
->code_factor
),
6106 dwarf_vmatoa_1 (NULL
,
6107 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6109 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6112 case DW_CFA_GNU_window_save
:
6113 if (! do_debug_frames_interp
)
6114 printf (" DW_CFA_GNU_window_save\n");
6117 case DW_CFA_GNU_args_size
:
6119 if (! do_debug_frames_interp
)
6120 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
6123 case DW_CFA_GNU_negative_offset_extended
:
6126 if (frame_need_space (fc
, reg
) < 0)
6127 reg_prefix
= bad_reg
;
6128 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6129 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6130 reg_prefix
, regname (reg
, 0),
6131 l
* fc
->data_factor
);
6132 if (*reg_prefix
== '\0')
6134 fc
->col_type
[reg
] = DW_CFA_offset
;
6135 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6140 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
6141 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
6143 warn (_("unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
6148 if (do_debug_frames_interp
)
6149 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6152 eh_addr_size
= saved_eh_addr_size
;
6165 display_gdb_index (struct dwarf_section
*section
,
6166 void *file ATTRIBUTE_UNUSED
)
6168 unsigned char *start
= section
->start
;
6170 uint32_t cu_list_offset
, tu_list_offset
;
6171 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6172 unsigned int cu_list_elements
, tu_list_elements
;
6173 unsigned int address_table_size
, symbol_table_slots
;
6174 unsigned char *cu_list
, *tu_list
;
6175 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6178 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6180 printf (_("Contents of the %s section:\n"), section
->name
);
6182 if (section
->size
< 6 * sizeof (uint32_t))
6184 warn (_("Truncated header in the %s section.\n"), section
->name
);
6188 version
= byte_get_little_endian (start
, 4);
6189 printf (_("Version %ld\n"), (long) version
);
6191 /* Prior versions are obsolete, and future versions may not be
6192 backwards compatible. */
6193 if (version
< 3 || version
> 8)
6195 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6199 warn (_("The address table data in version 3 may be wrong.\n"));
6201 warn (_("Version 4 does not support case insensitive lookups.\n"));
6203 warn (_("Version 5 does not include inlined functions.\n"));
6205 warn (_("Version 6 does not include symbol attributes.\n"));
6206 /* Version 7 indices generated by Gold have bad type unit references,
6207 PR binutils/15021. But we don't know if the index was generated by
6208 Gold or not, so to avoid worrying users with gdb-generated indices
6209 we say nothing for version 7 here. */
6211 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6212 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6213 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6214 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6215 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6217 if (cu_list_offset
> section
->size
6218 || tu_list_offset
> section
->size
6219 || address_table_offset
> section
->size
6220 || symbol_table_offset
> section
->size
6221 || constant_pool_offset
> section
->size
)
6223 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6227 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6228 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6229 address_table_size
= symbol_table_offset
- address_table_offset
;
6230 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6232 cu_list
= start
+ cu_list_offset
;
6233 tu_list
= start
+ tu_list_offset
;
6234 address_table
= start
+ address_table_offset
;
6235 symbol_table
= start
+ symbol_table_offset
;
6236 constant_pool
= start
+ constant_pool_offset
;
6238 printf (_("\nCU table:\n"));
6239 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6241 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6242 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6244 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6245 (unsigned long) cu_offset
,
6246 (unsigned long) (cu_offset
+ cu_length
- 1));
6249 printf (_("\nTU table:\n"));
6250 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6252 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6253 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6254 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6256 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6257 (unsigned long) tu_offset
,
6258 (unsigned long) type_offset
);
6259 print_dwarf_vma (signature
, 8);
6263 printf (_("\nAddress table:\n"));
6264 for (i
= 0; i
< address_table_size
; i
+= 2 * 8 + 4)
6266 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6267 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6268 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6270 print_dwarf_vma (low
, 8);
6271 print_dwarf_vma (high
, 8);
6272 printf (_("%lu\n"), (unsigned long) cu_index
);
6275 printf (_("\nSymbol table:\n"));
6276 for (i
= 0; i
< symbol_table_slots
; ++i
)
6278 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6279 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6280 uint32_t num_cus
, cu
;
6282 if (name_offset
!= 0
6283 || cu_vector_offset
!= 0)
6287 printf ("[%3u] %s:", i
, constant_pool
+ name_offset
);
6288 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
6291 for (j
= 0; j
< num_cus
; ++j
)
6294 gdb_index_symbol_kind kind
;
6296 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6297 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6298 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6299 cu
= GDB_INDEX_CU_VALUE (cu
);
6300 /* Convert to TU number if it's for a type unit. */
6301 if (cu
>= cu_list_elements
/ 2)
6302 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6303 (unsigned long) (cu
- cu_list_elements
/ 2));
6305 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6307 printf (" [%s, %s]",
6308 is_static
? _("static") : _("global"),
6309 get_gdb_index_symbol_kind_name (kind
));
6321 /* Pre-allocate enough space for the CU/TU sets needed. */
6324 prealloc_cu_tu_list (unsigned int nshndx
)
6326 if (shndx_pool
== NULL
)
6328 shndx_pool_size
= nshndx
;
6329 shndx_pool_used
= 0;
6330 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6331 sizeof (unsigned int));
6335 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6336 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6337 sizeof (unsigned int));
6342 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6344 if (shndx_pool_used
>= shndx_pool_size
)
6346 error (_("Internal error: out of space in the shndx pool.\n"));
6349 shndx_pool
[shndx_pool_used
++] = shndx
;
6353 end_cu_tu_entry (void)
6355 if (shndx_pool_used
>= shndx_pool_size
)
6357 error (_("Internal error: out of space in the shndx pool.\n"));
6360 shndx_pool
[shndx_pool_used
++] = 0;
6363 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6366 get_DW_SECT_short_name (unsigned int dw_sect
)
6368 static char buf
[16];
6376 case DW_SECT_ABBREV
:
6382 case DW_SECT_STR_OFFSETS
:
6384 case DW_SECT_MACINFO
:
6392 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6396 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6397 These sections are extensions for Fission.
6398 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6401 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6403 unsigned char *phdr
= section
->start
;
6404 unsigned char *limit
= phdr
+ section
->size
;
6405 unsigned char *phash
;
6406 unsigned char *pindex
;
6407 unsigned char *ppool
;
6408 unsigned int version
;
6409 unsigned int ncols
= 0;
6411 unsigned int nslots
;
6414 dwarf_vma signature_high
;
6415 dwarf_vma signature_low
;
6418 version
= byte_get (phdr
, 4);
6420 ncols
= byte_get (phdr
+ 4, 4);
6421 nused
= byte_get (phdr
+ 8, 4);
6422 nslots
= byte_get (phdr
+ 12, 4);
6424 pindex
= phash
+ nslots
* 8;
6425 ppool
= pindex
+ nslots
* 4;
6429 printf (_("Contents of the %s section:\n\n"), section
->name
);
6430 printf (_(" Version: %d\n"), version
);
6432 printf (_(" Number of columns: %d\n"), ncols
);
6433 printf (_(" Number of used entries: %d\n"), nused
);
6434 printf (_(" Number of slots: %d\n\n"), nslots
);
6439 warn (_("Section %s too small for %d hash table entries\n"),
6440 section
->name
, nslots
);
6447 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6448 for (i
= 0; i
< nslots
; i
++)
6450 unsigned char *shndx_list
;
6453 byte_get_64 (phash
, &signature_high
, &signature_low
);
6454 if (signature_high
!= 0 || signature_low
!= 0)
6456 j
= byte_get (pindex
, 4);
6457 shndx_list
= ppool
+ j
* 4;
6459 printf (_(" [%3d] Signature: 0x%s Sections: "),
6460 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6461 buf
, sizeof (buf
)));
6464 if (shndx_list
>= limit
)
6466 warn (_("Section %s too small for shndx pool\n"),
6470 shndx
= byte_get (shndx_list
, 4);
6474 printf (" %d", shndx
);
6476 add_shndx_to_cu_tu_entry (shndx
);
6488 else if (version
== 2)
6491 unsigned int dw_sect
;
6492 unsigned char *ph
= phash
;
6493 unsigned char *pi
= pindex
;
6494 unsigned char *poffsets
= ppool
+ ncols
* 4;
6495 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
6496 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
6497 bfd_boolean is_tu_index
;
6498 struct cu_tu_set
*this_set
= NULL
;
6500 unsigned char *prow
;
6502 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
6506 warn (_("Section %s too small for offset and size tables\n"),
6513 printf (_(" Offset table\n"));
6514 printf (" slot %-16s ",
6515 is_tu_index
? _("signature") : _("dwo_id"));
6522 tu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6528 cu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6534 for (j
= 0; j
< ncols
; j
++)
6536 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6537 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
6541 for (i
= 0; i
< nslots
; i
++)
6543 byte_get_64 (ph
, &signature_high
, &signature_low
);
6544 row
= byte_get (pi
, 4);
6548 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
6549 prow
= poffsets
+ (row
- 1) * ncols
* 4;
6551 printf (_(" [%3d] 0x%s"),
6552 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6553 buf
, sizeof (buf
)));
6554 for (j
= 0; j
< ncols
; j
++)
6556 val
= byte_get (prow
+ j
* 4, 4);
6558 printf (" %8d", val
);
6561 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6562 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
6577 printf (_(" Size table\n"));
6578 printf (" slot %-16s ",
6579 is_tu_index
? _("signature") : _("dwo_id"));
6581 for (j
= 0; j
< ncols
; j
++)
6583 val
= byte_get (ppool
+ j
* 4, 4);
6585 printf (" %8s", get_DW_SECT_short_name (val
));
6589 for (i
= 0; i
< nslots
; i
++)
6591 byte_get_64 (ph
, &signature_high
, &signature_low
);
6592 row
= byte_get (pi
, 4);
6595 prow
= psizes
+ (row
- 1) * ncols
* 4;
6597 printf (_(" [%3d] 0x%s"),
6598 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6599 buf
, sizeof (buf
)));
6600 for (j
= 0; j
< ncols
; j
++)
6602 val
= byte_get (prow
+ j
* 4, 4);
6604 printf (" %8d", val
);
6607 dw_sect
= byte_get (ppool
+ j
* 4, 4);
6608 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
6618 else if (do_display
)
6619 printf (_(" Unsupported version\n"));
6627 /* Load the CU and TU indexes if present. This will build a list of
6628 section sets that we can use to associate a .debug_info.dwo section
6629 with its associated .debug_abbrev.dwo section in a .dwp file. */
6632 load_cu_tu_indexes (void *file
)
6634 /* If we have already loaded (or tried to load) the CU and TU indexes
6635 then do not bother to repeat the task. */
6636 if (cu_tu_indexes_read
)
6639 if (load_debug_section (dwp_cu_index
, file
))
6640 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
6642 if (load_debug_section (dwp_tu_index
, file
))
6643 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
6645 cu_tu_indexes_read
= 1;
6648 /* Find the set of sections that includes section SHNDX. */
6651 find_cu_tu_set (void *file
, unsigned int shndx
)
6655 load_cu_tu_indexes (file
);
6657 /* Find SHNDX in the shndx pool. */
6658 for (i
= 0; i
< shndx_pool_used
; i
++)
6659 if (shndx_pool
[i
] == shndx
)
6662 if (i
>= shndx_pool_used
)
6665 /* Now backup to find the first entry in the set. */
6666 while (i
> 0 && shndx_pool
[i
- 1] != 0)
6669 return shndx_pool
+ i
;
6672 /* Display a .debug_cu_index or .debug_tu_index section. */
6675 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
6677 return process_cu_tu_index (section
, 1);
6681 display_debug_not_supported (struct dwarf_section
*section
,
6682 void *file ATTRIBUTE_UNUSED
)
6684 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6691 cmalloc (size_t nmemb
, size_t size
)
6693 /* Check for overflow. */
6694 if (nmemb
>= ~(size_t) 0 / size
)
6697 return malloc (nmemb
* size
);
6701 xcmalloc (size_t nmemb
, size_t size
)
6703 /* Check for overflow. */
6704 if (nmemb
>= ~(size_t) 0 / size
)
6707 return xmalloc (nmemb
* size
);
6711 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
6713 /* Check for overflow. */
6714 if (nmemb
>= ~(size_t) 0 / size
)
6717 return xrealloc (ptr
, nmemb
* size
);
6721 free_debug_memory (void)
6727 for (i
= 0; i
< max
; i
++)
6728 free_debug_section ((enum dwarf_section_display_enum
) i
);
6730 if (debug_information
!= NULL
)
6732 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
6734 for (i
= 0; i
< num_debug_info_entries
; i
++)
6736 if (!debug_information
[i
].max_loc_offsets
)
6738 free (debug_information
[i
].loc_offsets
);
6739 free (debug_information
[i
].have_frame_base
);
6741 if (!debug_information
[i
].max_range_lists
)
6742 free (debug_information
[i
].range_lists
);
6746 free (debug_information
);
6747 debug_information
= NULL
;
6748 num_debug_info_entries
= 0;
6753 dwarf_select_sections_by_names (const char *names
)
6757 const char * option
;
6761 debug_dump_long_opts
;
6763 static const debug_dump_long_opts opts_table
[] =
6765 /* Please keep this table alpha- sorted. */
6766 { "Ranges", & do_debug_ranges
, 1 },
6767 { "abbrev", & do_debug_abbrevs
, 1 },
6768 { "addr", & do_debug_addr
, 1 },
6769 { "aranges", & do_debug_aranges
, 1 },
6770 { "cu_index", & do_debug_cu_index
, 1 },
6771 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
6772 { "frames", & do_debug_frames
, 1 },
6773 { "frames-interp", & do_debug_frames_interp
, 1 },
6774 /* The special .gdb_index section. */
6775 { "gdb_index", & do_gdb_index
, 1 },
6776 { "info", & do_debug_info
, 1 },
6777 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
6778 { "loc", & do_debug_loc
, 1 },
6779 { "macro", & do_debug_macinfo
, 1 },
6780 { "pubnames", & do_debug_pubnames
, 1 },
6781 { "pubtypes", & do_debug_pubtypes
, 1 },
6782 /* This entry is for compatability
6783 with earlier versions of readelf. */
6784 { "ranges", & do_debug_aranges
, 1 },
6785 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
6786 { "str", & do_debug_str
, 1 },
6787 /* These trace_* sections are used by Itanium VMS. */
6788 { "trace_abbrev", & do_trace_abbrevs
, 1 },
6789 { "trace_aranges", & do_trace_aranges
, 1 },
6790 { "trace_info", & do_trace_info
, 1 },
6799 const debug_dump_long_opts
* entry
;
6801 for (entry
= opts_table
; entry
->option
; entry
++)
6803 size_t len
= strlen (entry
->option
);
6805 if (strncmp (p
, entry
->option
, len
) == 0
6806 && (p
[len
] == ',' || p
[len
] == '\0'))
6808 * entry
->variable
|= entry
->val
;
6810 /* The --debug-dump=frames-interp option also
6811 enables the --debug-dump=frames option. */
6812 if (do_debug_frames_interp
)
6813 do_debug_frames
= 1;
6820 if (entry
->option
== NULL
)
6822 warn (_("Unrecognized debug option '%s'\n"), p
);
6823 p
= strchr (p
, ',');
6834 dwarf_select_sections_by_letters (const char *letters
)
6836 unsigned int lindex
= 0;
6838 while (letters
[lindex
])
6839 switch (letters
[lindex
++])
6846 do_debug_abbrevs
= 1;
6850 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
6854 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
6858 do_debug_pubnames
= 1;
6862 do_debug_pubtypes
= 1;
6866 do_debug_aranges
= 1;
6870 do_debug_ranges
= 1;
6874 do_debug_frames_interp
= 1;
6876 do_debug_frames
= 1;
6880 do_debug_macinfo
= 1;
6892 warn (_("Unrecognized debug option '%s'\n"), optarg
);
6898 dwarf_select_sections_all (void)
6901 do_debug_abbrevs
= 1;
6902 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
6903 do_debug_pubnames
= 1;
6904 do_debug_pubtypes
= 1;
6905 do_debug_aranges
= 1;
6906 do_debug_ranges
= 1;
6907 do_debug_frames
= 1;
6908 do_debug_macinfo
= 1;
6913 do_trace_abbrevs
= 1;
6914 do_trace_aranges
= 1;
6916 do_debug_cu_index
= 1;
6919 struct dwarf_section_display debug_displays
[] =
6921 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0 },
6922 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
6923 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0 },
6924 display_debug_aranges
, &do_debug_aranges
, 1 },
6925 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0 },
6926 display_debug_frames
, &do_debug_frames
, 1 },
6927 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
},
6928 display_debug_info
, &do_debug_info
, 1 },
6929 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0 },
6930 display_debug_lines
, &do_debug_lines
, 1 },
6931 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0 },
6932 display_debug_pubnames
, &do_debug_pubnames
, 0 },
6933 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0 },
6934 display_debug_gnu_pubnames
, &do_debug_pubnames
, 0 },
6935 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0 },
6936 display_debug_frames
, &do_debug_frames
, 1 },
6937 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0 },
6938 display_debug_macinfo
, &do_debug_macinfo
, 0 },
6939 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0 },
6940 display_debug_macro
, &do_debug_macinfo
, 1 },
6941 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0 },
6942 display_debug_str
, &do_debug_str
, 0 },
6943 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0 },
6944 display_debug_loc
, &do_debug_loc
, 1 },
6945 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0 },
6946 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
6947 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0 },
6948 display_debug_gnu_pubnames
, &do_debug_pubtypes
, 0 },
6949 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0 },
6950 display_debug_ranges
, &do_debug_ranges
, 1 },
6951 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0 },
6952 display_debug_not_supported
, NULL
, 0 },
6953 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0 },
6954 display_debug_not_supported
, NULL
, 0 },
6955 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
},
6956 display_debug_types
, &do_debug_info
, 1 },
6957 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0 },
6958 display_debug_not_supported
, NULL
, 0 },
6959 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0 },
6960 display_gdb_index
, &do_gdb_index
, 0 },
6961 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
},
6962 display_trace_info
, &do_trace_info
, 1 },
6963 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0 },
6964 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
6965 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0 },
6966 display_debug_aranges
, &do_trace_aranges
, 0 },
6967 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
6968 display_debug_info
, &do_debug_info
, 1 },
6969 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0 },
6970 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
6971 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
6972 display_debug_types
, &do_debug_info
, 1 },
6973 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0 },
6974 display_debug_lines
, &do_debug_lines
, 1 },
6975 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0 },
6976 display_debug_loc
, &do_debug_loc
, 1 },
6977 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0 },
6978 display_debug_macro
, &do_debug_macinfo
, 1 },
6979 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0 },
6980 display_debug_macinfo
, &do_debug_macinfo
, 0 },
6981 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0 },
6982 display_debug_str
, &do_debug_str
, 1 },
6983 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0 },
6984 display_debug_str_offsets
, NULL
, 0 },
6985 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0 },
6986 display_debug_str_offsets
, NULL
, 0 },
6987 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0 },
6988 display_debug_addr
, &do_debug_addr
, 1 },
6989 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0 },
6990 display_cu_index
, &do_debug_cu_index
, 0 },
6991 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0 },
6992 display_cu_index
, &do_debug_cu_index
, 0 },