1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2014 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 #include "libiberty.h"
24 #include "bfd_stdint.h"
27 #include "elf/common.h"
30 #include "gdb/gdb-index.h"
32 static const char *regname (unsigned int regno
, int row
);
34 static int have_frame_base
;
35 static int need_base_address
;
37 static unsigned int last_pointer_size
= 0;
38 static int warned_about_missing_comp_units
= FALSE
;
40 static unsigned int num_debug_info_entries
= 0;
41 static debug_info
*debug_information
= NULL
;
42 /* Special value for num_debug_info_entries to indicate
43 that the .debug_info section could not be loaded/parsed. */
44 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
51 int do_debug_pubnames
;
52 int do_debug_pubtypes
;
56 int do_debug_frames_interp
;
65 int do_debug_cu_index
;
68 int dwarf_cutoff_level
= -1;
69 unsigned long dwarf_start_die
;
73 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
74 sections. For version 1 package files, each set is stored in SHNDX_POOL
75 as a zero-terminated list of section indexes comprising one set of debug
76 sections from a .dwo file. */
78 static int cu_tu_indexes_read
= 0;
79 static unsigned int *shndx_pool
= NULL
;
80 static unsigned int shndx_pool_size
= 0;
81 static unsigned int shndx_pool_used
= 0;
83 /* For version 2 package files, each set contains an array of section offsets
84 and an array of section sizes, giving the offset and size of the
85 contribution from a CU or TU within one of the debug sections.
86 When displaying debug info from a package file, we need to use these
87 tables to locate the corresponding contributions to each section. */
92 dwarf_vma section_offsets
[DW_SECT_MAX
];
93 size_t section_sizes
[DW_SECT_MAX
];
96 static int cu_count
= 0;
97 static int tu_count
= 0;
98 static struct cu_tu_set
*cu_sets
= NULL
;
99 static struct cu_tu_set
*tu_sets
= NULL
;
101 static void load_cu_tu_indexes (void *file
);
103 /* Values for do_debug_lines. */
104 #define FLAG_DEBUG_LINES_RAW 1
105 #define FLAG_DEBUG_LINES_DECODED 2
108 size_of_encoded_value (int encoding
)
110 switch (encoding
& 0x7)
113 case 0: return eh_addr_size
;
121 get_encoded_value (unsigned char **pdata
,
123 struct dwarf_section
*section
,
126 unsigned char * data
= * pdata
;
127 unsigned int size
= size_of_encoded_value (encoding
);
130 if (data
+ size
>= end
)
132 warn (_("Encoded value extends past end of section\n"));
137 /* PR 17512: file: 002-829853-0.004. */
140 warn (_("Encoded size of %d is too large to read\n"), size
);
145 if (encoding
& DW_EH_PE_signed
)
146 val
= byte_get_signed (data
, size
);
148 val
= byte_get (data
, size
);
150 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
151 val
+= section
->address
+ (data
- section
->start
);
153 * pdata
= data
+ size
;
157 #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2)
159 #define DWARF_VMA_FMT "ll"
160 #define DWARF_VMA_FMT_LONG "%16.16llx"
162 #define DWARF_VMA_FMT "I64"
163 #define DWARF_VMA_FMT_LONG "%016I64x"
166 #define DWARF_VMA_FMT "l"
167 #define DWARF_VMA_FMT_LONG "%16.16lx"
170 /* Convert a dwarf vma value into a string. Returns a pointer to a static
171 buffer containing the converted VALUE. The value is converted according
172 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
173 it specifies the maximum number of bytes to be displayed in the converted
174 value and FMTCH is ignored - hex is always used. */
177 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
179 /* As dwarf_vmatoa is used more then once in a printf call
180 for output, we are cycling through an fixed array of pointers
181 for return address. */
182 static int buf_pos
= 0;
183 static struct dwarf_vmatoa_buf
189 ret
= buf
[buf_pos
++].place
;
190 buf_pos
%= ARRAY_SIZE (buf
);
194 /* Printf does not have a way of specifiying a maximum field width for an
195 integer value, so we print the full value into a buffer and then select
196 the precision we need. */
197 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
200 return ret
+ (16 - 2 * num_bytes
);
206 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
207 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
212 static inline const char *
213 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
215 return dwarf_vmatoa_1 (fmtch
, value
, 0);
218 /* Print a dwarf_vma value (typically an address, offset or length) in
219 hexadecimal format, followed by a space. The length of the VALUE (and
220 hence the precision displayed) is determined by the NUM_BYTES parameter. */
223 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
225 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
228 /* Format a 64-bit value, given as two 32-bit values, in hex.
229 For reentrancy, this uses a buffer provided by the caller. */
232 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
233 unsigned int buf_len
)
238 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
241 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
242 snprintf (buf
+ len
, buf_len
- len
,
243 "%08" DWARF_VMA_FMT
"x", lvalue
);
249 /* Read in a LEB128 encoded value starting at address DATA.
250 If SIGN is true, return a signed LEB128 value.
251 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
252 No bytes will be read at address END or beyond. */
255 read_leb128 (unsigned char *data
,
256 unsigned int *length_return
,
258 const unsigned char * const end
)
260 dwarf_vma result
= 0;
261 unsigned int num_read
= 0;
262 unsigned int shift
= 0;
263 unsigned char byte
= 0;
270 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
273 if ((byte
& 0x80) == 0)
277 if (length_return
!= NULL
)
278 *length_return
= num_read
;
280 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
281 result
|= (dwarf_vma
) -1 << shift
;
286 /* Create a signed version to avoid painful typecasts. */
287 static inline dwarf_signed_vma
288 read_sleb128 (unsigned char * data
,
289 unsigned int * length_return
,
290 const unsigned char * const end
)
292 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
295 static inline dwarf_vma
296 read_uleb128 (unsigned char * data
,
297 unsigned int * length_return
,
298 const unsigned char * const end
)
300 return read_leb128 (data
, length_return
, FALSE
, end
);
303 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
306 int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
307 unsigned int amount = (AMOUNT); \
308 if (((PTR) + amount) >= (END)) \
311 amount = (END) - (PTR); \
315 if (amount == 0 || amount > 8) \
318 VAL = byte_get ((PTR), amount); \
322 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
325 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
330 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
333 unsigned int amount = (AMOUNT); \
334 if (((PTR) + amount) >= (END)) \
337 amount = (END) - (PTR); \
342 VAL = byte_get_signed ((PTR), amount); \
348 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
351 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
356 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
359 if (((PTR) + 8) <= (END)) \
361 byte_get_64 ((PTR), (HIGH), (LOW)); \
365 * (LOW) = * (HIGH) = 0; \
370 typedef struct State_Machine_Registers
378 unsigned char op_index
;
379 unsigned char end_sequence
;
380 /* This variable hold the number of the last entry seen
381 in the File Table. */
382 unsigned int last_file_entry
;
385 static SMR state_machine_regs
;
388 reset_state_machine (int is_stmt
)
390 state_machine_regs
.address
= 0;
391 state_machine_regs
.op_index
= 0;
392 state_machine_regs
.file
= 1;
393 state_machine_regs
.line
= 1;
394 state_machine_regs
.column
= 0;
395 state_machine_regs
.is_stmt
= is_stmt
;
396 state_machine_regs
.basic_block
= 0;
397 state_machine_regs
.end_sequence
= 0;
398 state_machine_regs
.last_file_entry
= 0;
401 /* Handled an extend line op.
402 Returns the number of bytes read. */
405 process_extended_line_op (unsigned char * data
,
409 unsigned char op_code
;
410 unsigned int bytes_read
;
413 unsigned char *orig_data
= data
;
416 len
= read_uleb128 (data
, & bytes_read
, end
);
419 if (len
== 0 || data
== end
|| len
> (end
- data
))
421 warn (_("Badly formed extended line op encountered!\n"));
428 printf (_(" Extended opcode %d: "), op_code
);
432 case DW_LNE_end_sequence
:
433 printf (_("End of Sequence\n\n"));
434 reset_state_machine (is_stmt
);
437 case DW_LNE_set_address
:
438 /* PR 17512: file: 002-100480-0.004. */
439 if (len
- bytes_read
- 1 > 8)
440 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
441 len
- bytes_read
- 1);
442 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
443 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
444 state_machine_regs
.address
= adr
;
445 state_machine_regs
.op_index
= 0;
448 case DW_LNE_define_file
:
449 printf (_("define new File Table entry\n"));
450 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
451 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
454 data
+= strnlen ((char *) data
, end
- data
) + 1;
455 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
457 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
459 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
461 printf ("%s\n\n", name
);
463 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
464 warn (_("DW_LNE_define_file: Bad opcode length\n"));
467 case DW_LNE_set_discriminator
:
468 printf (_("set Discriminator to %s\n"),
469 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
473 case DW_LNE_HP_negate_is_UV_update
:
474 printf ("DW_LNE_HP_negate_is_UV_update\n");
476 case DW_LNE_HP_push_context
:
477 printf ("DW_LNE_HP_push_context\n");
479 case DW_LNE_HP_pop_context
:
480 printf ("DW_LNE_HP_pop_context\n");
482 case DW_LNE_HP_set_file_line_column
:
483 printf ("DW_LNE_HP_set_file_line_column\n");
485 case DW_LNE_HP_set_routine_name
:
486 printf ("DW_LNE_HP_set_routine_name\n");
488 case DW_LNE_HP_set_sequence
:
489 printf ("DW_LNE_HP_set_sequence\n");
491 case DW_LNE_HP_negate_post_semantics
:
492 printf ("DW_LNE_HP_negate_post_semantics\n");
494 case DW_LNE_HP_negate_function_exit
:
495 printf ("DW_LNE_HP_negate_function_exit\n");
497 case DW_LNE_HP_negate_front_end_logical
:
498 printf ("DW_LNE_HP_negate_front_end_logical\n");
500 case DW_LNE_HP_define_proc
:
501 printf ("DW_LNE_HP_define_proc\n");
503 case DW_LNE_HP_source_file_correlation
:
505 unsigned char *edata
= data
+ len
- bytes_read
- 1;
507 printf ("DW_LNE_HP_source_file_correlation\n");
513 opc
= read_uleb128 (data
, & bytes_read
, edata
);
518 case DW_LNE_HP_SFC_formfeed
:
519 printf (" DW_LNE_HP_SFC_formfeed\n");
521 case DW_LNE_HP_SFC_set_listing_line
:
522 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
524 read_uleb128 (data
, & bytes_read
, edata
)));
527 case DW_LNE_HP_SFC_associate
:
528 printf (" DW_LNE_HP_SFC_associate ");
531 read_uleb128 (data
, & bytes_read
, edata
)));
535 read_uleb128 (data
, & bytes_read
, edata
)));
539 read_uleb128 (data
, & bytes_read
, edata
)));
543 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
553 unsigned int rlen
= len
- bytes_read
- 1;
555 if (op_code
>= DW_LNE_lo_user
556 /* The test against DW_LNW_hi_user is redundant due to
557 the limited range of the unsigned char data type used
559 /*&& op_code <= DW_LNE_hi_user*/)
560 printf (_("user defined: "));
562 printf (_("UNKNOWN: "));
563 printf (_("length %d ["), rlen
);
565 printf (" %02x", *data
++);
574 static const unsigned char *
575 fetch_indirect_string (dwarf_vma offset
)
577 struct dwarf_section
*section
= &debug_displays
[str
].section
;
579 if (section
->start
== NULL
)
580 return (const unsigned char *) _("<no .debug_str section>");
582 if (offset
> section
->size
)
584 warn (_("DW_FORM_strp offset too big: %s\n"),
585 dwarf_vmatoa ("x", offset
));
586 return (const unsigned char *) _("<offset is too big>");
589 return (const unsigned char *) section
->start
+ offset
;
593 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
594 dwarf_vma offset_size
, int dwo
)
596 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
597 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
598 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
599 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
600 dwarf_vma index_offset
= idx
* offset_size
;
601 dwarf_vma str_offset
;
603 if (index_section
->start
== NULL
)
604 return (dwo
? _("<no .debug_str_offsets.dwo section>")
605 : _("<no .debug_str_offsets section>"));
607 if (this_set
!= NULL
)
608 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
609 if (index_offset
> index_section
->size
)
611 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
612 dwarf_vmatoa ("x", index_offset
));
613 return _("<index offset is too big>");
616 if (str_section
->start
== NULL
)
617 return (dwo
? _("<no .debug_str.dwo section>")
618 : _("<no .debug_str section>"));
620 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
621 str_offset
-= str_section
->address
;
622 if (str_offset
> str_section
->size
)
624 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
625 dwarf_vmatoa ("x", str_offset
));
626 return _("<indirect index offset is too big>");
629 return (const char *) str_section
->start
+ str_offset
;
633 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
635 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
637 if (section
->start
== NULL
)
638 return (_("<no .debug_addr section>"));
640 if (offset
+ bytes
> section
->size
)
642 warn (_("Offset into section %s too big: %s\n"),
643 section
->name
, dwarf_vmatoa ("x", offset
));
644 return "<offset too big>";
647 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
651 /* FIXME: There are better and more efficient ways to handle
652 these structures. For now though, I just want something that
653 is simple to implement. */
654 typedef struct abbrev_attr
656 unsigned long attribute
;
658 struct abbrev_attr
*next
;
662 typedef struct abbrev_entry
667 struct abbrev_attr
*first_attr
;
668 struct abbrev_attr
*last_attr
;
669 struct abbrev_entry
*next
;
673 static abbrev_entry
*first_abbrev
= NULL
;
674 static abbrev_entry
*last_abbrev
= NULL
;
681 for (abbrv
= first_abbrev
; abbrv
;)
683 abbrev_entry
*next_abbrev
= abbrv
->next
;
686 for (attr
= abbrv
->first_attr
; attr
;)
688 abbrev_attr
*next_attr
= attr
->next
;
698 last_abbrev
= first_abbrev
= NULL
;
702 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
706 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
711 entry
->entry
= number
;
713 entry
->children
= children
;
714 entry
->first_attr
= NULL
;
715 entry
->last_attr
= NULL
;
718 if (first_abbrev
== NULL
)
719 first_abbrev
= entry
;
721 last_abbrev
->next
= entry
;
727 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
731 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
736 attr
->attribute
= attribute
;
740 if (last_abbrev
->first_attr
== NULL
)
741 last_abbrev
->first_attr
= attr
;
743 last_abbrev
->last_attr
->next
= attr
;
745 last_abbrev
->last_attr
= attr
;
748 /* Processes the (partial) contents of a .debug_abbrev section.
749 Returns NULL if the end of the section was encountered.
750 Returns the address after the last byte read if the end of
751 an abbreviation set was found. */
753 static unsigned char *
754 process_abbrev_section (unsigned char *start
, unsigned char *end
)
756 if (first_abbrev
!= NULL
)
761 unsigned int bytes_read
;
764 unsigned long attribute
;
767 entry
= read_uleb128 (start
, & bytes_read
, end
);
770 /* A single zero is supposed to end the section according
771 to the standard. If there's more, then signal that to
778 tag
= read_uleb128 (start
, & bytes_read
, end
);
785 add_abbrev (entry
, tag
, children
);
791 attribute
= read_uleb128 (start
, & bytes_read
, end
);
796 form
= read_uleb128 (start
, & bytes_read
, end
);
801 add_abbrev_attr (attribute
, form
);
803 while (attribute
!= 0);
806 /* Report the missing single zero which ends the section. */
807 error (_(".debug_abbrev section not zero terminated\n"));
813 get_TAG_name (unsigned long tag
)
815 const char *name
= get_DW_TAG_name ((unsigned int)tag
);
819 static char buffer
[100];
821 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
829 get_FORM_name (unsigned long form
)
834 return "DW_FORM value: 0";
836 name
= get_DW_FORM_name (form
);
839 static char buffer
[100];
841 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
848 static unsigned char *
849 display_block (unsigned char *data
,
851 const unsigned char * const end
)
855 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length
));
857 maxlen
= (dwarf_vma
) (end
- data
);
858 length
= length
> maxlen
? maxlen
: length
;
861 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
867 decode_location_expression (unsigned char * data
,
868 unsigned int pointer_size
,
869 unsigned int offset_size
,
873 struct dwarf_section
* section
)
876 unsigned int bytes_read
;
878 dwarf_signed_vma svalue
;
879 unsigned char *end
= data
+ length
;
880 int need_frame_base
= 0;
889 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
890 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
893 printf ("DW_OP_deref");
896 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
897 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
900 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
901 printf ("DW_OP_const1s: %ld", (long) svalue
);
904 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
905 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
908 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
909 printf ("DW_OP_const2s: %ld", (long) svalue
);
912 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
913 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
916 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
917 printf ("DW_OP_const4s: %ld", (long) svalue
);
920 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
921 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
922 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
923 printf ("%lu", (unsigned long) uvalue
);
926 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
927 printf ("DW_OP_const8s: %ld ", (long) svalue
);
928 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
929 printf ("%ld", (long) svalue
);
932 printf ("DW_OP_constu: %s",
933 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
937 printf ("DW_OP_consts: %s",
938 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
942 printf ("DW_OP_dup");
945 printf ("DW_OP_drop");
948 printf ("DW_OP_over");
951 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
952 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
955 printf ("DW_OP_swap");
958 printf ("DW_OP_rot");
961 printf ("DW_OP_xderef");
964 printf ("DW_OP_abs");
967 printf ("DW_OP_and");
970 printf ("DW_OP_div");
973 printf ("DW_OP_minus");
976 printf ("DW_OP_mod");
979 printf ("DW_OP_mul");
982 printf ("DW_OP_neg");
985 printf ("DW_OP_not");
991 printf ("DW_OP_plus");
993 case DW_OP_plus_uconst
:
994 printf ("DW_OP_plus_uconst: %s",
995 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
999 printf ("DW_OP_shl");
1002 printf ("DW_OP_shr");
1005 printf ("DW_OP_shra");
1008 printf ("DW_OP_xor");
1011 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1012 printf ("DW_OP_bra: %ld", (long) svalue
);
1015 printf ("DW_OP_eq");
1018 printf ("DW_OP_ge");
1021 printf ("DW_OP_gt");
1024 printf ("DW_OP_le");
1027 printf ("DW_OP_lt");
1030 printf ("DW_OP_ne");
1033 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1034 printf ("DW_OP_skip: %ld", (long) svalue
);
1069 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1104 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1105 regname (op
- DW_OP_reg0
, 1));
1140 printf ("DW_OP_breg%d (%s): %s",
1142 regname (op
- DW_OP_breg0
, 1),
1143 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1148 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1150 printf ("DW_OP_regx: %s (%s)",
1151 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1154 need_frame_base
= 1;
1155 printf ("DW_OP_fbreg: %s",
1156 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1160 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1162 printf ("DW_OP_bregx: %s (%s) %s",
1163 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1164 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1168 printf ("DW_OP_piece: %s",
1169 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1172 case DW_OP_deref_size
:
1173 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1174 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1176 case DW_OP_xderef_size
:
1177 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1178 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1181 printf ("DW_OP_nop");
1184 /* DWARF 3 extensions. */
1185 case DW_OP_push_object_address
:
1186 printf ("DW_OP_push_object_address");
1189 /* XXX: Strictly speaking for 64-bit DWARF3 files
1190 this ought to be an 8-byte wide computation. */
1191 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1192 printf ("DW_OP_call2: <0x%s>",
1193 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1196 /* XXX: Strictly speaking for 64-bit DWARF3 files
1197 this ought to be an 8-byte wide computation. */
1198 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1199 printf ("DW_OP_call4: <0x%s>",
1200 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1202 case DW_OP_call_ref
:
1203 /* XXX: Strictly speaking for 64-bit DWARF3 files
1204 this ought to be an 8-byte wide computation. */
1205 if (dwarf_version
== -1)
1207 printf (_("(DW_OP_call_ref in frame info)"));
1208 /* No way to tell where the next op is, so just bail. */
1209 return need_frame_base
;
1211 if (dwarf_version
== 2)
1213 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1217 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1219 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1221 case DW_OP_form_tls_address
:
1222 printf ("DW_OP_form_tls_address");
1224 case DW_OP_call_frame_cfa
:
1225 printf ("DW_OP_call_frame_cfa");
1227 case DW_OP_bit_piece
:
1228 printf ("DW_OP_bit_piece: ");
1229 printf (_("size: %s "),
1230 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1232 printf (_("offset: %s "),
1233 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1237 /* DWARF 4 extensions. */
1238 case DW_OP_stack_value
:
1239 printf ("DW_OP_stack_value");
1242 case DW_OP_implicit_value
:
1243 printf ("DW_OP_implicit_value");
1244 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1246 data
= display_block (data
, uvalue
, end
);
1249 /* GNU extensions. */
1250 case DW_OP_GNU_push_tls_address
:
1251 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1253 case DW_OP_GNU_uninit
:
1254 printf ("DW_OP_GNU_uninit");
1255 /* FIXME: Is there data associated with this OP ? */
1257 case DW_OP_GNU_encoded_addr
:
1264 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1266 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1267 print_dwarf_vma (addr
, pointer_size
);
1270 case DW_OP_GNU_implicit_pointer
:
1271 /* XXX: Strictly speaking for 64-bit DWARF3 files
1272 this ought to be an 8-byte wide computation. */
1273 if (dwarf_version
== -1)
1275 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1276 /* No way to tell where the next op is, so just bail. */
1277 return need_frame_base
;
1279 if (dwarf_version
== 2)
1281 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1285 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1287 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1288 dwarf_vmatoa ("x", uvalue
),
1289 dwarf_vmatoa ("d", read_sleb128 (data
,
1290 &bytes_read
, end
)));
1293 case DW_OP_GNU_entry_value
:
1294 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1296 printf ("DW_OP_GNU_entry_value: (");
1297 if (decode_location_expression (data
, pointer_size
, offset_size
,
1298 dwarf_version
, uvalue
,
1299 cu_offset
, section
))
1300 need_frame_base
= 1;
1306 case DW_OP_GNU_const_type
:
1307 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1309 printf ("DW_OP_GNU_const_type: <0x%s> ",
1310 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1311 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1312 data
= display_block (data
, uvalue
, end
);
1314 case DW_OP_GNU_regval_type
:
1315 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1317 printf ("DW_OP_GNU_regval_type: %s (%s)",
1318 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1319 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1321 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1323 case DW_OP_GNU_deref_type
:
1324 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1325 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue
);
1326 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1328 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1330 case DW_OP_GNU_convert
:
1331 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1333 printf ("DW_OP_GNU_convert <0x%s>",
1334 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1336 case DW_OP_GNU_reinterpret
:
1337 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1339 printf ("DW_OP_GNU_reinterpret <0x%s>",
1340 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1342 case DW_OP_GNU_parameter_ref
:
1343 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1344 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1345 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1347 case DW_OP_GNU_addr_index
:
1348 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1350 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1352 case DW_OP_GNU_const_index
:
1353 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1355 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1358 /* HP extensions. */
1359 case DW_OP_HP_is_value
:
1360 printf ("DW_OP_HP_is_value");
1361 /* FIXME: Is there data associated with this OP ? */
1363 case DW_OP_HP_fltconst4
:
1364 printf ("DW_OP_HP_fltconst4");
1365 /* FIXME: Is there data associated with this OP ? */
1367 case DW_OP_HP_fltconst8
:
1368 printf ("DW_OP_HP_fltconst8");
1369 /* FIXME: Is there data associated with this OP ? */
1371 case DW_OP_HP_mod_range
:
1372 printf ("DW_OP_HP_mod_range");
1373 /* FIXME: Is there data associated with this OP ? */
1375 case DW_OP_HP_unmod_range
:
1376 printf ("DW_OP_HP_unmod_range");
1377 /* FIXME: Is there data associated with this OP ? */
1380 printf ("DW_OP_HP_tls");
1381 /* FIXME: Is there data associated with this OP ? */
1384 /* PGI (STMicroelectronics) extensions. */
1385 case DW_OP_PGI_omp_thread_num
:
1386 /* Pushes the thread number for the current thread as it would be
1387 returned by the standard OpenMP library function:
1388 omp_get_thread_num(). The "current thread" is the thread for
1389 which the expression is being evaluated. */
1390 printf ("DW_OP_PGI_omp_thread_num");
1394 if (op
>= DW_OP_lo_user
1395 && op
<= DW_OP_hi_user
)
1396 printf (_("(User defined location op)"));
1398 printf (_("(Unknown location op)"));
1399 /* No way to tell where the next op is, so just bail. */
1400 return need_frame_base
;
1403 /* Separate the ops. */
1408 return need_frame_base
;
1411 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1412 This is used for DWARF package files. */
1414 static struct cu_tu_set
*
1415 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1417 struct cu_tu_set
*p
;
1419 unsigned int dw_sect
;
1425 dw_sect
= DW_SECT_TYPES
;
1431 dw_sect
= DW_SECT_INFO
;
1435 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1443 /* Add INC to HIGH_BITS:LOW_BITS. */
1445 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1447 dwarf_vma tmp
= * low_bits
;
1451 /* FIXME: There is probably a better way of handling this:
1453 We need to cope with dwarf_vma being a 32-bit or 64-bit
1454 type. Plus regardless of its size LOW_BITS is meant to
1455 only hold 32-bits, so if there is overflow or wrap around
1456 we must propagate into HIGH_BITS. */
1457 if (tmp
< * low_bits
)
1461 else if (sizeof (tmp
) > 8
1471 static unsigned char *
1472 read_and_display_attr_value (unsigned long attribute
,
1474 unsigned char * data
,
1475 unsigned char * end
,
1476 dwarf_vma cu_offset
,
1477 dwarf_vma pointer_size
,
1478 dwarf_vma offset_size
,
1480 debug_info
* debug_info_p
,
1482 struct dwarf_section
* section
,
1483 struct cu_tu_set
* this_set
)
1485 dwarf_vma uvalue
= 0;
1486 unsigned char *block_start
= NULL
;
1487 unsigned char * orig_data
= data
;
1488 unsigned int bytes_read
;
1490 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
1492 warn (_("Corrupt attribute\n"));
1501 case DW_FORM_ref_addr
:
1502 if (dwarf_version
== 2)
1503 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1504 else if (dwarf_version
== 3 || dwarf_version
== 4)
1505 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1507 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1512 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1516 case DW_FORM_sec_offset
:
1517 case DW_FORM_GNU_ref_alt
:
1518 case DW_FORM_GNU_strp_alt
:
1519 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1522 case DW_FORM_flag_present
:
1529 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1534 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1539 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1543 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1547 case DW_FORM_GNU_str_index
:
1548 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1552 case DW_FORM_ref_udata
:
1554 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1558 case DW_FORM_indirect
:
1559 form
= read_uleb128 (data
, & bytes_read
, end
);
1562 printf (" %s", get_FORM_name (form
));
1563 return read_and_display_attr_value (attribute
, form
, data
, end
,
1564 cu_offset
, pointer_size
,
1565 offset_size
, dwarf_version
,
1566 debug_info_p
, do_loc
,
1568 case DW_FORM_GNU_addr_index
:
1569 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1576 case DW_FORM_ref_addr
:
1578 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue
));
1581 case DW_FORM_GNU_ref_alt
:
1583 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue
));
1589 case DW_FORM_ref_udata
:
1591 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1596 case DW_FORM_sec_offset
:
1598 printf (" 0x%s", dwarf_vmatoa ("x", uvalue
));
1601 case DW_FORM_flag_present
:
1608 printf (" %s", dwarf_vmatoa ("d", uvalue
));
1615 dwarf_vma high_bits
;
1619 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1621 if (form
== DW_FORM_ref8
)
1622 add64 (& high_bits
, & utmp
, cu_offset
);
1624 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1627 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1628 && num_debug_info_entries
== 0)
1630 if (sizeof (uvalue
) == 8)
1631 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1633 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1639 case DW_FORM_string
:
1641 printf (" %.*s", (int) (end
- data
), data
);
1642 data
+= strnlen ((char *) data
, end
- data
) + 1;
1646 case DW_FORM_exprloc
:
1647 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1648 block_start
= data
+ bytes_read
;
1649 /* PR 17512: file: 008-103549-0.001:0.1. */
1650 if (block_start
+ uvalue
> end
)
1652 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1653 uvalue
= end
- block_start
;
1656 data
= block_start
+ uvalue
;
1658 data
= display_block (block_start
, uvalue
, end
);
1661 case DW_FORM_block1
:
1662 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1663 block_start
= data
+ 1;
1664 if (block_start
+ uvalue
> end
)
1666 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1667 uvalue
= end
- block_start
;
1670 data
= block_start
+ uvalue
;
1672 data
= display_block (block_start
, uvalue
, end
);
1675 case DW_FORM_block2
:
1676 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1677 block_start
= data
+ 2;
1678 if (block_start
+ uvalue
> end
)
1680 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1681 uvalue
= end
- block_start
;
1684 data
= block_start
+ uvalue
;
1686 data
= display_block (block_start
, uvalue
, end
);
1689 case DW_FORM_block4
:
1690 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1691 block_start
= data
+ 4;
1692 if (block_start
+ uvalue
> end
)
1694 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1695 uvalue
= end
- block_start
;
1698 data
= block_start
+ uvalue
;
1700 data
= display_block (block_start
, uvalue
, end
);
1705 printf (_(" (indirect string, offset: 0x%s): %s"),
1706 dwarf_vmatoa ("x", uvalue
),
1707 fetch_indirect_string (uvalue
));
1710 case DW_FORM_GNU_str_index
:
1713 const char *suffix
= strrchr (section
->name
, '.');
1714 int dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? 1 : 0;
1716 printf (_(" (indexed string: 0x%s): %s"),
1717 dwarf_vmatoa ("x", uvalue
),
1718 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
1722 case DW_FORM_GNU_strp_alt
:
1724 printf (_(" (alt indirect string, offset: 0x%s)"),
1725 dwarf_vmatoa ("x", uvalue
));
1728 case DW_FORM_indirect
:
1729 /* Handled above. */
1732 case DW_FORM_ref_sig8
:
1735 dwarf_vma high_bits
;
1738 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1739 printf (" signature: 0x%s",
1740 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
1745 case DW_FORM_GNU_addr_index
:
1747 printf (_(" (addr_index: 0x%s): %s"),
1748 dwarf_vmatoa ("x", uvalue
),
1749 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
1753 warn (_("Unrecognized form: %lu\n"), form
);
1757 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1758 && num_debug_info_entries
== 0
1759 && debug_info_p
!= NULL
)
1763 case DW_AT_frame_base
:
1764 have_frame_base
= 1;
1765 case DW_AT_location
:
1766 case DW_AT_string_length
:
1767 case DW_AT_return_addr
:
1768 case DW_AT_data_member_location
:
1769 case DW_AT_vtable_elem_location
:
1771 case DW_AT_static_link
:
1772 case DW_AT_use_location
:
1773 case DW_AT_GNU_call_site_value
:
1774 case DW_AT_GNU_call_site_data_value
:
1775 case DW_AT_GNU_call_site_target
:
1776 case DW_AT_GNU_call_site_target_clobbered
:
1777 if ((dwarf_version
< 4
1778 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1779 || form
== DW_FORM_sec_offset
)
1781 /* Process location list. */
1782 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1783 unsigned int num
= debug_info_p
->num_loc_offsets
;
1785 if (lmax
== 0 || num
>= lmax
)
1788 debug_info_p
->loc_offsets
= (dwarf_vma
*)
1789 xcrealloc (debug_info_p
->loc_offsets
,
1790 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1791 debug_info_p
->have_frame_base
= (int *)
1792 xcrealloc (debug_info_p
->have_frame_base
,
1793 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1794 debug_info_p
->max_loc_offsets
= lmax
;
1796 if (this_set
!= NULL
)
1797 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
1798 debug_info_p
->loc_offsets
[num
] = uvalue
;
1799 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1800 debug_info_p
->num_loc_offsets
++;
1805 if (need_base_address
)
1806 debug_info_p
->base_address
= uvalue
;
1809 case DW_AT_GNU_addr_base
:
1810 debug_info_p
->addr_base
= uvalue
;
1813 case DW_AT_GNU_ranges_base
:
1814 debug_info_p
->ranges_base
= uvalue
;
1818 if ((dwarf_version
< 4
1819 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1820 || form
== DW_FORM_sec_offset
)
1822 /* Process range list. */
1823 unsigned int lmax
= debug_info_p
->max_range_lists
;
1824 unsigned int num
= debug_info_p
->num_range_lists
;
1826 if (lmax
== 0 || num
>= lmax
)
1829 debug_info_p
->range_lists
= (dwarf_vma
*)
1830 xcrealloc (debug_info_p
->range_lists
,
1831 lmax
, sizeof (*debug_info_p
->range_lists
));
1832 debug_info_p
->max_range_lists
= lmax
;
1834 debug_info_p
->range_lists
[num
] = uvalue
;
1835 debug_info_p
->num_range_lists
++;
1844 if (do_loc
|| attribute
== 0)
1847 /* For some attributes we can display further information. */
1854 case DW_INL_not_inlined
:
1855 printf (_("(not inlined)"));
1857 case DW_INL_inlined
:
1858 printf (_("(inlined)"));
1860 case DW_INL_declared_not_inlined
:
1861 printf (_("(declared as inline but ignored)"));
1863 case DW_INL_declared_inlined
:
1864 printf (_("(declared as inline and inlined)"));
1867 printf (_(" (Unknown inline attribute value: %s)"),
1868 dwarf_vmatoa ("x", uvalue
));
1873 case DW_AT_language
:
1877 /* Ordered by the numeric value of these constants. */
1878 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1879 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1880 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1881 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1882 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1883 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1884 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1885 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1886 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1887 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1888 /* DWARF 2.1 values. */
1889 case DW_LANG_Java
: printf ("(Java)"); break;
1890 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1891 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1892 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1893 /* DWARF 3 values. */
1894 case DW_LANG_PLI
: printf ("(PLI)"); break;
1895 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1896 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1897 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1898 case DW_LANG_D
: printf ("(D)"); break;
1899 /* DWARF 4 values. */
1900 case DW_LANG_Python
: printf ("(Python)"); break;
1901 /* DWARF 5 values. */
1902 case DW_LANG_Go
: printf ("(Go)"); break;
1903 /* MIPS extension. */
1904 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1905 /* UPC extension. */
1906 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1908 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1909 printf (_("(implementation defined: %s)"),
1910 dwarf_vmatoa ("x", uvalue
));
1912 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
1917 case DW_AT_encoding
:
1921 case DW_ATE_void
: printf ("(void)"); break;
1922 case DW_ATE_address
: printf ("(machine address)"); break;
1923 case DW_ATE_boolean
: printf ("(boolean)"); break;
1924 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1925 case DW_ATE_float
: printf ("(float)"); break;
1926 case DW_ATE_signed
: printf ("(signed)"); break;
1927 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1928 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1929 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1930 /* DWARF 2.1 values: */
1931 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1932 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1933 /* DWARF 3 values: */
1934 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1935 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1936 case DW_ATE_edited
: printf ("(edited)"); break;
1937 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
1938 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
1939 /* HP extensions: */
1940 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
1941 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
1942 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
1943 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
1944 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
1945 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
1946 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
1949 if (uvalue
>= DW_ATE_lo_user
1950 && uvalue
<= DW_ATE_hi_user
)
1951 printf (_("(user defined type)"));
1953 printf (_("(unknown type)"));
1958 case DW_AT_accessibility
:
1962 case DW_ACCESS_public
: printf ("(public)"); break;
1963 case DW_ACCESS_protected
: printf ("(protected)"); break;
1964 case DW_ACCESS_private
: printf ("(private)"); break;
1966 printf (_("(unknown accessibility)"));
1971 case DW_AT_visibility
:
1975 case DW_VIS_local
: printf ("(local)"); break;
1976 case DW_VIS_exported
: printf ("(exported)"); break;
1977 case DW_VIS_qualified
: printf ("(qualified)"); break;
1978 default: printf (_("(unknown visibility)")); break;
1982 case DW_AT_virtuality
:
1986 case DW_VIRTUALITY_none
: printf ("(none)"); break;
1987 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
1988 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
1989 default: printf (_("(unknown virtuality)")); break;
1993 case DW_AT_identifier_case
:
1997 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
1998 case DW_ID_up_case
: printf ("(up_case)"); break;
1999 case DW_ID_down_case
: printf ("(down_case)"); break;
2000 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2001 default: printf (_("(unknown case)")); break;
2005 case DW_AT_calling_convention
:
2009 case DW_CC_normal
: printf ("(normal)"); break;
2010 case DW_CC_program
: printf ("(program)"); break;
2011 case DW_CC_nocall
: printf ("(nocall)"); break;
2013 if (uvalue
>= DW_CC_lo_user
2014 && uvalue
<= DW_CC_hi_user
)
2015 printf (_("(user defined)"));
2017 printf (_("(unknown convention)"));
2021 case DW_AT_ordering
:
2025 case -1: printf (_("(undefined)")); break;
2026 case 0: printf ("(row major)"); break;
2027 case 1: printf ("(column major)"); break;
2031 case DW_AT_frame_base
:
2032 have_frame_base
= 1;
2033 case DW_AT_location
:
2034 case DW_AT_string_length
:
2035 case DW_AT_return_addr
:
2036 case DW_AT_data_member_location
:
2037 case DW_AT_vtable_elem_location
:
2039 case DW_AT_static_link
:
2040 case DW_AT_use_location
:
2041 case DW_AT_GNU_call_site_value
:
2042 case DW_AT_GNU_call_site_data_value
:
2043 case DW_AT_GNU_call_site_target
:
2044 case DW_AT_GNU_call_site_target_clobbered
:
2045 if ((dwarf_version
< 4
2046 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2047 || form
== DW_FORM_sec_offset
)
2048 printf (_(" (location list)"));
2050 case DW_AT_allocated
:
2051 case DW_AT_associated
:
2052 case DW_AT_data_location
:
2054 case DW_AT_upper_bound
:
2055 case DW_AT_lower_bound
:
2058 int need_frame_base
;
2061 need_frame_base
= decode_location_expression (block_start
,
2066 cu_offset
, section
);
2068 if (need_frame_base
&& !have_frame_base
)
2069 printf (_(" [without DW_AT_frame_base]"));
2075 if (form
== DW_FORM_ref_sig8
2076 || form
== DW_FORM_GNU_ref_alt
)
2079 if (form
== DW_FORM_ref1
2080 || form
== DW_FORM_ref2
2081 || form
== DW_FORM_ref4
2082 || form
== DW_FORM_ref_udata
)
2083 uvalue
+= cu_offset
;
2085 if (uvalue
>= section
->size
)
2086 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"),
2087 dwarf_vmatoa ("x", uvalue
),
2088 (unsigned long) (orig_data
- section
->start
));
2091 unsigned long abbrev_number
;
2092 abbrev_entry
* entry
;
2094 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2096 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2097 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2098 use different abbrev table, and we don't track .debug_info chunks
2100 if (form
!= DW_FORM_ref_addr
)
2102 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2103 if (entry
->entry
== abbrev_number
)
2106 printf (" (%s)", get_TAG_name (entry
->tag
));
2121 get_AT_name (unsigned long attribute
)
2126 return "DW_AT value: 0";
2128 /* One value is shared by the MIPS and HP extensions: */
2129 if (attribute
== DW_AT_MIPS_fde
)
2130 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2132 name
= get_DW_AT_name (attribute
);
2136 static char buffer
[100];
2138 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2146 static unsigned char *
2147 read_and_display_attr (unsigned long attribute
,
2149 unsigned char * data
,
2150 unsigned char * end
,
2151 dwarf_vma cu_offset
,
2152 dwarf_vma pointer_size
,
2153 dwarf_vma offset_size
,
2155 debug_info
* debug_info_p
,
2157 struct dwarf_section
* section
,
2158 struct cu_tu_set
* this_set
)
2161 printf (" %-18s:", get_AT_name (attribute
));
2162 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2163 cu_offset
, pointer_size
, offset_size
,
2164 dwarf_version
, debug_info_p
,
2165 do_loc
, section
, this_set
);
2171 /* Process the contents of a .debug_info section. If do_loc is non-zero
2172 then we are scanning for location lists and we do not want to display
2173 anything to the user. If do_types is non-zero, we are processing
2174 a .debug_types section instead of a .debug_info section. */
2177 process_debug_info (struct dwarf_section
*section
,
2179 enum dwarf_section_display_enum abbrev_sec
,
2183 unsigned char *start
= section
->start
;
2184 unsigned char *end
= start
+ section
->size
;
2185 unsigned char *section_begin
;
2187 unsigned int num_units
= 0;
2189 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2190 && num_debug_info_entries
== 0
2195 /* First scan the section to get the number of comp units. */
2196 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2199 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2200 will be the length. For a 64-bit DWARF section, it'll be
2201 the escape code 0xffffffff followed by an 8 byte length. */
2202 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2204 if (length
== 0xffffffff)
2206 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2207 section_begin
+= length
+ 12;
2209 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2211 warn (_("Reserved length value (0x%s) found in section %s\n"),
2212 dwarf_vmatoa ("x", length
), section
->name
);
2216 section_begin
+= length
+ 4;
2218 /* Negative values are illegal, they may even cause infinite
2219 looping. This can happen if we can't accurately apply
2220 relocations to an object file. */
2221 if ((signed long) length
<= 0)
2223 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2224 dwarf_vmatoa ("x", length
), section
->name
);
2231 error (_("No comp units in %s section ?\n"), section
->name
);
2235 /* Then allocate an array to hold the information. */
2236 debug_information
= (debug_info
*) cmalloc (num_units
,
2237 sizeof (* debug_information
));
2238 if (debug_information
== NULL
)
2240 error (_("Not enough memory for a debug info array of %u entries\n"),
2248 if (dwarf_start_die
== 0)
2249 printf (_("Contents of the %s section:\n\n"), section
->name
);
2251 load_debug_section (str
, file
);
2252 load_debug_section (str_dwo
, file
);
2253 load_debug_section (str_index
, file
);
2254 load_debug_section (str_index_dwo
, file
);
2255 load_debug_section (debug_addr
, file
);
2258 load_debug_section (abbrev_sec
, file
);
2259 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2261 warn (_("Unable to locate %s section!\n"),
2262 debug_displays
[abbrev_sec
].section
.name
);
2266 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2268 DWARF2_Internal_CompUnit compunit
;
2269 unsigned char *hdrptr
;
2270 unsigned char *tags
;
2271 int level
, last_level
, saved_level
;
2272 dwarf_vma cu_offset
;
2273 unsigned int offset_size
;
2274 int initial_length_size
;
2275 dwarf_vma signature_high
= 0;
2276 dwarf_vma signature_low
= 0;
2277 dwarf_vma type_offset
= 0;
2278 struct cu_tu_set
*this_set
;
2279 dwarf_vma abbrev_base
;
2284 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2286 if (compunit
.cu_length
== 0xffffffff)
2288 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2290 initial_length_size
= 12;
2295 initial_length_size
= 4;
2298 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2300 cu_offset
= start
- section_begin
;
2302 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2304 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2306 if (this_set
== NULL
)
2309 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2313 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2314 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2317 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2318 /* PR 17512: file: 001-108546-0.001:0.1. */
2319 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2321 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2322 compunit
.cu_pointer_size
, offset_size
);
2323 compunit
.cu_pointer_size
= offset_size
;
2328 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2330 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2333 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2334 && num_debug_info_entries
== 0
2337 debug_information
[unit
].cu_offset
= cu_offset
;
2338 debug_information
[unit
].pointer_size
2339 = compunit
.cu_pointer_size
;
2340 debug_information
[unit
].offset_size
= offset_size
;
2341 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2342 debug_information
[unit
].base_address
= 0;
2343 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2344 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2345 debug_information
[unit
].loc_offsets
= NULL
;
2346 debug_information
[unit
].have_frame_base
= NULL
;
2347 debug_information
[unit
].max_loc_offsets
= 0;
2348 debug_information
[unit
].num_loc_offsets
= 0;
2349 debug_information
[unit
].range_lists
= NULL
;
2350 debug_information
[unit
].max_range_lists
= 0;
2351 debug_information
[unit
].num_range_lists
= 0;
2354 if (!do_loc
&& dwarf_start_die
== 0)
2356 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2357 dwarf_vmatoa ("x", cu_offset
));
2358 printf (_(" Length: 0x%s (%s)\n"),
2359 dwarf_vmatoa ("x", compunit
.cu_length
),
2360 offset_size
== 8 ? "64-bit" : "32-bit");
2361 printf (_(" Version: %d\n"), compunit
.cu_version
);
2362 printf (_(" Abbrev Offset: 0x%s\n"),
2363 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2364 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2369 printf (_(" Signature: 0x%s\n"),
2370 dwarf_vmatoa64 (signature_high
, signature_low
,
2371 buf
, sizeof (buf
)));
2372 printf (_(" Type Offset: 0x%s\n"),
2373 dwarf_vmatoa ("x", type_offset
));
2375 if (this_set
!= NULL
)
2377 dwarf_vma
*offsets
= this_set
->section_offsets
;
2378 size_t *sizes
= this_set
->section_sizes
;
2380 printf (_(" Section contributions:\n"));
2381 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2382 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2383 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2384 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2385 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2386 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2387 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2388 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2389 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2390 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2391 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2392 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2396 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2399 warn (_("Debug info is corrupted, length of CU at %s"
2400 " extends beyond end of section (length = %s)\n"),
2401 dwarf_vmatoa ("x", cu_offset
),
2402 dwarf_vmatoa ("x", compunit
.cu_length
));
2406 start
+= compunit
.cu_length
+ initial_length_size
;
2408 if (compunit
.cu_version
!= 2
2409 && compunit
.cu_version
!= 3
2410 && compunit
.cu_version
!= 4)
2412 warn (_("CU at offset %s contains corrupt or "
2413 "unsupported version number: %d.\n"),
2414 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2420 /* Process the abbrevs used by this compilation unit. */
2421 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2422 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2423 (unsigned long) compunit
.cu_abbrev_offset
,
2424 (unsigned long) abbrev_size
);
2426 process_abbrev_section
2427 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2428 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2429 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2430 + abbrev_base
+ abbrev_size
));
2435 while (tags
< start
)
2437 unsigned int bytes_read
;
2438 unsigned long abbrev_number
;
2439 unsigned long die_offset
;
2440 abbrev_entry
*entry
;
2442 int do_printing
= 1;
2444 die_offset
= tags
- section_begin
;
2446 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2449 /* A null DIE marks the end of a list of siblings or it may also be
2450 a section padding. */
2451 if (abbrev_number
== 0)
2453 /* Check if it can be a section padding for the last CU. */
2454 if (level
== 0 && start
== end
)
2458 for (chk
= tags
; chk
< start
; chk
++)
2465 if (!do_loc
&& die_offset
>= dwarf_start_die
2466 && (dwarf_cutoff_level
== -1
2467 || level
< dwarf_cutoff_level
))
2468 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2474 static unsigned num_bogus_warns
= 0;
2476 if (num_bogus_warns
< 3)
2478 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2479 die_offset
, section
->name
);
2481 if (num_bogus_warns
== 3)
2482 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2485 if (dwarf_start_die
!= 0 && level
< saved_level
)
2492 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2496 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2497 saved_level
= level
;
2498 do_printing
= (dwarf_cutoff_level
== -1
2499 || level
< dwarf_cutoff_level
);
2501 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2502 level
, die_offset
, abbrev_number
);
2503 else if (dwarf_cutoff_level
== -1
2504 || last_level
< dwarf_cutoff_level
)
2505 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2510 /* Scan through the abbreviation list until we reach the
2512 for (entry
= first_abbrev
;
2513 entry
&& entry
->entry
!= abbrev_number
;
2514 entry
= entry
->next
)
2519 if (!do_loc
&& do_printing
)
2524 warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"),
2525 die_offset
, abbrev_number
);
2529 if (!do_loc
&& do_printing
)
2530 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2535 need_base_address
= 0;
2537 case DW_TAG_compile_unit
:
2538 need_base_address
= 1;
2540 case DW_TAG_entry_point
:
2541 case DW_TAG_subprogram
:
2542 need_base_address
= 0;
2543 /* Assuming that there is no DW_AT_frame_base. */
2544 have_frame_base
= 0;
2548 for (attr
= entry
->first_attr
;
2549 attr
&& attr
->attribute
;
2554 if (! do_loc
&& do_printing
)
2555 /* Show the offset from where the tag was extracted. */
2556 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2558 arg
= debug_information
;
2559 if (debug_information
)
2562 tags
= read_and_display_attr (attr
->attribute
,
2567 compunit
.cu_pointer_size
,
2569 compunit
.cu_version
,
2571 do_loc
|| ! do_printing
,
2576 if (entry
->children
)
2581 /* Set num_debug_info_entries here so that it can be used to check if
2582 we need to process .debug_loc and .debug_ranges sections. */
2583 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2584 && num_debug_info_entries
== 0
2586 num_debug_info_entries
= num_units
;
2594 /* Locate and scan the .debug_info section in the file and record the pointer
2595 sizes and offsets for the compilation units in it. Usually an executable
2596 will have just one pointer size, but this is not guaranteed, and so we try
2597 not to make any assumptions. Returns zero upon failure, or the number of
2598 compilation units upon success. */
2601 load_debug_info (void * file
)
2603 /* Reset the last pointer size so that we can issue correct error
2604 messages if we are displaying the contents of more than one section. */
2605 last_pointer_size
= 0;
2606 warned_about_missing_comp_units
= FALSE
;
2608 /* If we have already tried and failed to load the .debug_info
2609 section then do not bother to repeat the task. */
2610 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2613 /* If we already have the information there is nothing else to do. */
2614 if (num_debug_info_entries
> 0)
2615 return num_debug_info_entries
;
2617 /* If this is a DWARF package file, load the CU and TU indexes. */
2618 load_cu_tu_indexes (file
);
2620 if (load_debug_section (info
, file
)
2621 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2622 return num_debug_info_entries
;
2623 else if (load_debug_section (info_dwo
, file
)
2624 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2626 return num_debug_info_entries
;
2628 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2632 /* Read a DWARF .debug_line section header starting at DATA.
2633 Upon success returns an updated DATA pointer and the LINFO
2634 structure and the END_OF_SEQUENCE pointer will be filled in.
2635 Otherwise returns NULL. */
2637 static unsigned char *
2638 read_debug_line_header (struct dwarf_section
* section
,
2639 unsigned char * data
,
2640 unsigned char * end
,
2641 DWARF2_Internal_LineInfo
* linfo
,
2642 unsigned char ** end_of_sequence
)
2644 unsigned char *hdrptr
;
2645 unsigned int offset_size
;
2646 unsigned int initial_length_size
;
2648 /* Extract information from the Line Number Program Header.
2649 (section 6.2.4 in the Dwarf3 doc). */
2652 /* Get and check the length of the block. */
2653 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2655 if (linfo
->li_length
== 0xffffffff)
2657 /* This section is 64-bit DWARF 3. */
2658 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2660 initial_length_size
= 12;
2665 initial_length_size
= 4;
2668 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2670 /* If the length is just a bias against the initial_length_size then
2671 this means that the field has a relocation against it which has not
2672 been applied. (Ie we are dealing with an object file, not a linked
2673 binary). Do not complain but instead assume that the rest of the
2674 section applies to this particular header. */
2675 if (linfo
->li_length
== - initial_length_size
)
2677 linfo
->li_length
= section
->size
- initial_length_size
;
2681 warn (_("The line info appears to be corrupt - the section is too small\n"));
2686 /* Get and check the version number. */
2687 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2689 if (linfo
->li_version
!= 2
2690 && linfo
->li_version
!= 3
2691 && linfo
->li_version
!= 4)
2693 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2697 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2698 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2700 if (linfo
->li_version
>= 4)
2702 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2704 if (linfo
->li_max_ops_per_insn
== 0)
2706 warn (_("Invalid maximum operations per insn.\n"));
2711 linfo
->li_max_ops_per_insn
= 1;
2713 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2714 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2715 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2716 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2718 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2719 /* PR 17512: file:002-117414-0.004. */
2720 if (* end_of_sequence
> end
)
2722 warn (_("Line length %lld extends beyond end of section\n"), linfo
->li_length
);
2723 * end_of_sequence
= end
;
2731 display_debug_lines_raw (struct dwarf_section
*section
,
2732 unsigned char *data
,
2735 unsigned char *start
= section
->start
;
2737 printf (_("Raw dump of debug contents of section %s:\n\n"),
2742 static DWARF2_Internal_LineInfo saved_linfo
;
2743 DWARF2_Internal_LineInfo linfo
;
2744 unsigned char *standard_opcodes
;
2745 unsigned char *end_of_sequence
;
2746 unsigned int last_dir_entry
= 0;
2749 if (const_strneq (section
->name
, ".debug_line.")
2750 /* Note: the following does not apply to .debug_line.dwo sections.
2751 These are full debug_line sections. */
2752 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2754 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2755 section containing just the Line Number Statements. They are
2756 created by the assembler and intended to be used alongside gcc's
2757 -ffunction-sections command line option. When the linker's
2758 garbage collection decides to discard a .text.<foo> section it
2759 can then also discard the line number information in .debug_line.<foo>.
2761 Since the section is a fragment it does not have the details
2762 needed to fill out a LineInfo structure, so instead we use the
2763 details from the last full debug_line section that we processed. */
2764 end_of_sequence
= end
;
2765 standard_opcodes
= NULL
;
2766 linfo
= saved_linfo
;
2767 reset_state_machine (linfo
.li_default_is_stmt
);
2771 unsigned char * hdrptr
;
2773 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2774 & end_of_sequence
)) == NULL
)
2777 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2778 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2779 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2780 printf (_(" Prologue Length: %d\n"), linfo
.li_prologue_length
);
2781 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2782 if (linfo
.li_version
>= 4)
2783 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2784 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2785 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2786 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2787 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2789 reset_state_machine (linfo
.li_default_is_stmt
);
2791 /* Display the contents of the Opcodes table. */
2792 standard_opcodes
= hdrptr
;
2794 /* PR 17512: file: 002-417945-0.004. */
2795 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
2797 warn (_("Line Base extends beyond end of section\n"));
2801 printf (_("\n Opcodes:\n"));
2803 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2804 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2806 /* Display the contents of the Directory table. */
2807 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2810 printf (_("\n The Directory Table is empty.\n"));
2813 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2814 (long)(data
- start
));
2816 while (data
< end
&& *data
!= 0)
2818 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
2820 data
+= strnlen ((char *) data
, end
- data
) + 1;
2823 /* PR 17512: file: 002-132094-0.004. */
2824 if (data
>= end
- 1)
2828 /* Skip the NUL at the end of the table. */
2831 /* Display the contents of the File Name table. */
2833 printf (_("\n The File Name Table is empty.\n"));
2836 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2837 (long)(data
- start
));
2838 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2840 while (data
< end
&& *data
!= 0)
2842 unsigned char *name
;
2843 unsigned int bytes_read
;
2845 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2847 data
+= strnlen ((char *) data
, end
- data
) + 1;
2850 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2853 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2856 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2858 printf ("%.*s\n", (int)(end
- name
), name
);
2862 warn (_("Corrupt file name table entry\n"));
2868 /* Skip the NUL at the end of the table. */
2871 saved_linfo
= linfo
;
2874 /* Now display the statements. */
2875 if (data
>= end_of_sequence
)
2876 printf (_(" No Line Number Statements.\n"));
2879 printf (_(" Line Number Statements:\n"));
2881 while (data
< end_of_sequence
)
2883 unsigned char op_code
;
2884 dwarf_signed_vma adv
;
2886 unsigned int bytes_read
;
2888 printf (" [0x%08lx]", (long)(data
- start
));
2892 if (op_code
>= linfo
.li_opcode_base
)
2894 op_code
-= linfo
.li_opcode_base
;
2895 uladv
= (op_code
/ linfo
.li_line_range
);
2896 if (linfo
.li_max_ops_per_insn
== 1)
2898 uladv
*= linfo
.li_min_insn_length
;
2899 state_machine_regs
.address
+= uladv
;
2900 printf (_(" Special opcode %d: "
2901 "advance Address by %s to 0x%s"),
2902 op_code
, dwarf_vmatoa ("u", uladv
),
2903 dwarf_vmatoa ("x", state_machine_regs
.address
));
2907 state_machine_regs
.address
2908 += ((state_machine_regs
.op_index
+ uladv
)
2909 / linfo
.li_max_ops_per_insn
)
2910 * linfo
.li_min_insn_length
;
2911 state_machine_regs
.op_index
2912 = (state_machine_regs
.op_index
+ uladv
)
2913 % linfo
.li_max_ops_per_insn
;
2914 printf (_(" Special opcode %d: "
2915 "advance Address by %s to 0x%s[%d]"),
2916 op_code
, dwarf_vmatoa ("u", uladv
),
2917 dwarf_vmatoa ("x", state_machine_regs
.address
),
2918 state_machine_regs
.op_index
);
2920 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
2921 state_machine_regs
.line
+= adv
;
2922 printf (_(" and Line by %s to %d\n"),
2923 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
2925 else switch (op_code
)
2927 case DW_LNS_extended_op
:
2928 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
2932 printf (_(" Copy\n"));
2935 case DW_LNS_advance_pc
:
2936 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2938 if (linfo
.li_max_ops_per_insn
== 1)
2940 uladv
*= linfo
.li_min_insn_length
;
2941 state_machine_regs
.address
+= uladv
;
2942 printf (_(" Advance PC by %s to 0x%s\n"),
2943 dwarf_vmatoa ("u", uladv
),
2944 dwarf_vmatoa ("x", state_machine_regs
.address
));
2948 state_machine_regs
.address
2949 += ((state_machine_regs
.op_index
+ uladv
)
2950 / linfo
.li_max_ops_per_insn
)
2951 * linfo
.li_min_insn_length
;
2952 state_machine_regs
.op_index
2953 = (state_machine_regs
.op_index
+ uladv
)
2954 % linfo
.li_max_ops_per_insn
;
2955 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
2956 dwarf_vmatoa ("u", uladv
),
2957 dwarf_vmatoa ("x", state_machine_regs
.address
),
2958 state_machine_regs
.op_index
);
2962 case DW_LNS_advance_line
:
2963 adv
= read_sleb128 (data
, & bytes_read
, end
);
2965 state_machine_regs
.line
+= adv
;
2966 printf (_(" Advance Line by %s to %d\n"),
2967 dwarf_vmatoa ("d", adv
),
2968 state_machine_regs
.line
);
2971 case DW_LNS_set_file
:
2972 adv
= read_uleb128 (data
, & bytes_read
, end
);
2974 printf (_(" Set File Name to entry %s in the File Name Table\n"),
2975 dwarf_vmatoa ("d", adv
));
2976 state_machine_regs
.file
= adv
;
2979 case DW_LNS_set_column
:
2980 uladv
= read_uleb128 (data
, & bytes_read
, end
);
2982 printf (_(" Set column to %s\n"),
2983 dwarf_vmatoa ("u", uladv
));
2984 state_machine_regs
.column
= uladv
;
2987 case DW_LNS_negate_stmt
:
2988 adv
= state_machine_regs
.is_stmt
;
2990 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
2991 state_machine_regs
.is_stmt
= adv
;
2994 case DW_LNS_set_basic_block
:
2995 printf (_(" Set basic block\n"));
2996 state_machine_regs
.basic_block
= 1;
2999 case DW_LNS_const_add_pc
:
3000 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3001 if (linfo
.li_max_ops_per_insn
)
3003 uladv
*= linfo
.li_min_insn_length
;
3004 state_machine_regs
.address
+= uladv
;
3005 printf (_(" Advance PC by constant %s to 0x%s\n"),
3006 dwarf_vmatoa ("u", uladv
),
3007 dwarf_vmatoa ("x", state_machine_regs
.address
));
3011 state_machine_regs
.address
3012 += ((state_machine_regs
.op_index
+ uladv
)
3013 / linfo
.li_max_ops_per_insn
)
3014 * linfo
.li_min_insn_length
;
3015 state_machine_regs
.op_index
3016 = (state_machine_regs
.op_index
+ uladv
)
3017 % linfo
.li_max_ops_per_insn
;
3018 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3019 dwarf_vmatoa ("u", uladv
),
3020 dwarf_vmatoa ("x", state_machine_regs
.address
),
3021 state_machine_regs
.op_index
);
3025 case DW_LNS_fixed_advance_pc
:
3026 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3027 state_machine_regs
.address
+= uladv
;
3028 state_machine_regs
.op_index
= 0;
3029 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3030 dwarf_vmatoa ("u", uladv
),
3031 dwarf_vmatoa ("x", state_machine_regs
.address
));
3034 case DW_LNS_set_prologue_end
:
3035 printf (_(" Set prologue_end to true\n"));
3038 case DW_LNS_set_epilogue_begin
:
3039 printf (_(" Set epilogue_begin to true\n"));
3042 case DW_LNS_set_isa
:
3043 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3045 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3049 printf (_(" Unknown opcode %d with operands: "), op_code
);
3051 if (standard_opcodes
!= NULL
)
3052 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3054 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3056 i
== 1 ? "" : ", ");
3072 unsigned char *name
;
3073 unsigned int directory_index
;
3074 unsigned int modification_date
;
3075 unsigned int length
;
3078 /* Output a decoded representation of the .debug_line section. */
3081 display_debug_lines_decoded (struct dwarf_section
*section
,
3082 unsigned char *data
,
3085 static DWARF2_Internal_LineInfo saved_linfo
;
3087 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3092 /* This loop amounts to one iteration per compilation unit. */
3093 DWARF2_Internal_LineInfo linfo
;
3094 unsigned char *standard_opcodes
;
3095 unsigned char *end_of_sequence
;
3097 File_Entry
*file_table
= NULL
;
3098 unsigned int n_files
= 0;
3099 unsigned char **directory_table
= NULL
;
3100 unsigned int n_directories
= 0;
3102 if (const_strneq (section
->name
, ".debug_line.")
3103 /* Note: the following does not apply to .debug_line.dwo sections.
3104 These are full debug_line sections. */
3105 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3107 /* See comment in display_debug_lines_raw(). */
3108 end_of_sequence
= end
;
3109 standard_opcodes
= NULL
;
3110 linfo
= saved_linfo
;
3111 reset_state_machine (linfo
.li_default_is_stmt
);
3115 unsigned char *hdrptr
;
3117 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3118 & end_of_sequence
)) == NULL
)
3121 reset_state_machine (linfo
.li_default_is_stmt
);
3123 /* Save a pointer to the contents of the Opcodes table. */
3124 standard_opcodes
= hdrptr
;
3126 /* Traverse the Directory table just to count entries. */
3127 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3130 unsigned char *ptr_directory_table
= data
;
3134 data
+= strnlen ((char *) data
, end
- data
) + 1;
3138 /* Go through the directory table again to save the directories. */
3139 directory_table
= (unsigned char **)
3140 xmalloc (n_directories
* sizeof (unsigned char *));
3143 while (*ptr_directory_table
!= 0)
3145 directory_table
[i
] = ptr_directory_table
;
3146 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3147 ptr_directory_table
- end
) + 1;
3151 /* Skip the NUL at the end of the table. */
3154 /* Traverse the File Name table just to count the entries. */
3157 unsigned char *ptr_file_name_table
= data
;
3161 unsigned int bytes_read
;
3163 /* Skip Name, directory index, last modification time and length
3165 data
+= strnlen ((char *) data
, end
- data
) + 1;
3166 read_uleb128 (data
, & bytes_read
, end
);
3168 read_uleb128 (data
, & bytes_read
, end
);
3170 read_uleb128 (data
, & bytes_read
, end
);
3176 /* Go through the file table again to save the strings. */
3177 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3180 while (*ptr_file_name_table
!= 0)
3182 unsigned int bytes_read
;
3184 file_table
[i
].name
= ptr_file_name_table
;
3185 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3186 end
- ptr_file_name_table
) + 1;
3188 /* We are not interested in directory, time or size. */
3189 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3191 ptr_file_name_table
+= bytes_read
;
3192 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3194 ptr_file_name_table
+= bytes_read
;
3195 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3196 ptr_file_name_table
+= bytes_read
;
3201 /* Print the Compilation Unit's name and a header. */
3202 if (directory_table
== NULL
)
3204 printf (_("CU: %s:\n"), file_table
[0].name
);
3205 printf (_("File name Line number Starting address\n"));
3209 unsigned int ix
= file_table
[0].directory_index
;
3210 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3212 if (do_wide
|| strlen (directory
) < 76)
3213 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3215 printf ("%s:\n", file_table
[0].name
);
3217 printf (_("File name Line number Starting address\n"));
3221 /* Skip the NUL at the end of the table. */
3224 saved_linfo
= linfo
;
3227 /* This loop iterates through the Dwarf Line Number Program. */
3228 while (data
< end_of_sequence
)
3230 unsigned char op_code
;
3232 unsigned long int uladv
;
3233 unsigned int bytes_read
;
3234 int is_special_opcode
= 0;
3238 if (op_code
>= linfo
.li_opcode_base
)
3240 op_code
-= linfo
.li_opcode_base
;
3241 uladv
= (op_code
/ linfo
.li_line_range
);
3242 if (linfo
.li_max_ops_per_insn
== 1)
3244 uladv
*= linfo
.li_min_insn_length
;
3245 state_machine_regs
.address
+= uladv
;
3249 state_machine_regs
.address
3250 += ((state_machine_regs
.op_index
+ uladv
)
3251 / linfo
.li_max_ops_per_insn
)
3252 * linfo
.li_min_insn_length
;
3253 state_machine_regs
.op_index
3254 = (state_machine_regs
.op_index
+ uladv
)
3255 % linfo
.li_max_ops_per_insn
;
3258 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3259 state_machine_regs
.line
+= adv
;
3260 is_special_opcode
= 1;
3262 else switch (op_code
)
3264 case DW_LNS_extended_op
:
3266 unsigned int ext_op_code_len
;
3267 unsigned char ext_op_code
;
3268 unsigned char *op_code_data
= data
;
3270 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3272 op_code_data
+= bytes_read
;
3274 if (ext_op_code_len
== 0)
3276 warn (_("Badly formed extended line op encountered!\n"));
3279 ext_op_code_len
+= bytes_read
;
3280 ext_op_code
= *op_code_data
++;
3282 switch (ext_op_code
)
3284 case DW_LNE_end_sequence
:
3285 reset_state_machine (linfo
.li_default_is_stmt
);
3287 case DW_LNE_set_address
:
3288 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3290 ext_op_code_len
- bytes_read
- 1,
3292 state_machine_regs
.op_index
= 0;
3294 case DW_LNE_define_file
:
3296 file_table
= (File_Entry
*) xrealloc
3297 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3299 ++state_machine_regs
.last_file_entry
;
3300 /* Source file name. */
3301 file_table
[n_files
].name
= op_code_data
;
3302 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3303 /* Directory index. */
3304 file_table
[n_files
].directory_index
=
3305 read_uleb128 (op_code_data
, & bytes_read
,
3307 op_code_data
+= bytes_read
;
3308 /* Last modification time. */
3309 file_table
[n_files
].modification_date
=
3310 read_uleb128 (op_code_data
, & bytes_read
,
3312 op_code_data
+= bytes_read
;
3314 file_table
[n_files
].length
=
3315 read_uleb128 (op_code_data
, & bytes_read
,
3321 case DW_LNE_set_discriminator
:
3322 case DW_LNE_HP_set_sequence
:
3323 /* Simply ignored. */
3327 printf (_("UNKNOWN (%u): length %d\n"),
3328 ext_op_code
, ext_op_code_len
- bytes_read
);
3331 data
+= ext_op_code_len
;
3337 case DW_LNS_advance_pc
:
3338 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3340 if (linfo
.li_max_ops_per_insn
== 1)
3342 uladv
*= linfo
.li_min_insn_length
;
3343 state_machine_regs
.address
+= uladv
;
3347 state_machine_regs
.address
3348 += ((state_machine_regs
.op_index
+ uladv
)
3349 / linfo
.li_max_ops_per_insn
)
3350 * linfo
.li_min_insn_length
;
3351 state_machine_regs
.op_index
3352 = (state_machine_regs
.op_index
+ uladv
)
3353 % linfo
.li_max_ops_per_insn
;
3357 case DW_LNS_advance_line
:
3358 adv
= read_sleb128 (data
, & bytes_read
, end
);
3360 state_machine_regs
.line
+= adv
;
3363 case DW_LNS_set_file
:
3364 adv
= read_uleb128 (data
, & bytes_read
, end
);
3366 state_machine_regs
.file
= adv
;
3368 if (file_table
== NULL
)
3369 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3370 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3371 /* If directory index is 0, that means current directory. */
3372 printf ("\n./%s:[++]\n",
3373 file_table
[state_machine_regs
.file
- 1].name
);
3374 else if (directory_table
== NULL
)
3375 printf (_("\n [Use directory table entry %d]\n"),
3376 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3378 /* The directory index starts counting at 1. */
3379 printf ("\n%s/%s:\n",
3380 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3381 file_table
[state_machine_regs
.file
- 1].name
);
3384 case DW_LNS_set_column
:
3385 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3387 state_machine_regs
.column
= uladv
;
3390 case DW_LNS_negate_stmt
:
3391 adv
= state_machine_regs
.is_stmt
;
3393 state_machine_regs
.is_stmt
= adv
;
3396 case DW_LNS_set_basic_block
:
3397 state_machine_regs
.basic_block
= 1;
3400 case DW_LNS_const_add_pc
:
3401 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3402 if (linfo
.li_max_ops_per_insn
== 1)
3404 uladv
*= linfo
.li_min_insn_length
;
3405 state_machine_regs
.address
+= uladv
;
3409 state_machine_regs
.address
3410 += ((state_machine_regs
.op_index
+ uladv
)
3411 / linfo
.li_max_ops_per_insn
)
3412 * linfo
.li_min_insn_length
;
3413 state_machine_regs
.op_index
3414 = (state_machine_regs
.op_index
+ uladv
)
3415 % linfo
.li_max_ops_per_insn
;
3419 case DW_LNS_fixed_advance_pc
:
3420 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3421 state_machine_regs
.address
+= uladv
;
3422 state_machine_regs
.op_index
= 0;
3425 case DW_LNS_set_prologue_end
:
3428 case DW_LNS_set_epilogue_begin
:
3431 case DW_LNS_set_isa
:
3432 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3434 printf (_(" Set ISA to %lu\n"), uladv
);
3438 printf (_(" Unknown opcode %d with operands: "), op_code
);
3440 if (standard_opcodes
!= NULL
)
3441 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3443 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3445 i
== 1 ? "" : ", ");
3452 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3453 to the DWARF address/line matrix. */
3454 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3455 || (op_code
== DW_LNS_copy
))
3457 const unsigned int MAX_FILENAME_LENGTH
= 35;
3459 char *newFileName
= NULL
;
3460 size_t fileNameLength
;
3463 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3465 fileName
= "<unknown>";
3467 fileNameLength
= strlen (fileName
);
3469 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3471 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3472 /* Truncate file name */
3473 strncpy (newFileName
,
3474 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3475 MAX_FILENAME_LENGTH
+ 1);
3479 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3480 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3483 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3485 if (linfo
.li_max_ops_per_insn
== 1)
3486 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3487 newFileName
, state_machine_regs
.line
,
3488 state_machine_regs
.address
);
3490 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3491 newFileName
, state_machine_regs
.line
,
3492 state_machine_regs
.address
,
3493 state_machine_regs
.op_index
);
3497 if (linfo
.li_max_ops_per_insn
== 1)
3498 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3499 newFileName
, state_machine_regs
.line
,
3500 state_machine_regs
.address
);
3502 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3503 newFileName
, state_machine_regs
.line
,
3504 state_machine_regs
.address
,
3505 state_machine_regs
.op_index
);
3508 if (op_code
== DW_LNE_end_sequence
)
3522 if (directory_table
)
3524 free (directory_table
);
3525 directory_table
= NULL
;
3536 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3538 unsigned char *data
= section
->start
;
3539 unsigned char *end
= data
+ section
->size
;
3541 int retValDecoded
= 1;
3543 if (do_debug_lines
== 0)
3544 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3546 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3547 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3549 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3550 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3552 if (!retValRaw
|| !retValDecoded
)
3559 find_debug_info_for_offset (unsigned long offset
)
3563 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3566 for (i
= 0; i
< num_debug_info_entries
; i
++)
3567 if (debug_information
[i
].cu_offset
== offset
)
3568 return debug_information
+ i
;
3574 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
3576 /* See gdb/gdb-index.h. */
3577 static const char * const kinds
[] =
3589 return _ (kinds
[kind
]);
3593 display_debug_pubnames_worker (struct dwarf_section
*section
,
3594 void *file ATTRIBUTE_UNUSED
,
3597 DWARF2_Internal_PubNames names
;
3598 unsigned char *start
= section
->start
;
3599 unsigned char *end
= start
+ section
->size
;
3601 /* It does not matter if this load fails,
3602 we test for that later on. */
3603 load_debug_info (file
);
3605 printf (_("Contents of the %s section:\n\n"), section
->name
);
3609 unsigned char *data
;
3610 unsigned long offset
;
3611 unsigned int offset_size
, initial_length_size
;
3615 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3616 if (names
.pn_length
== 0xffffffff)
3618 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3620 initial_length_size
= 12;
3625 initial_length_size
= 4;
3628 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3629 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3631 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3632 && num_debug_info_entries
> 0
3633 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3634 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3635 (unsigned long) names
.pn_offset
, section
->name
);
3637 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3639 start
+= names
.pn_length
+ initial_length_size
;
3641 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3643 static int warned
= 0;
3647 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3654 printf (_(" Length: %ld\n"),
3655 (long) names
.pn_length
);
3656 printf (_(" Version: %d\n"),
3658 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3659 (unsigned long) names
.pn_offset
);
3660 printf (_(" Size of area in .debug_info section: %ld\n"),
3661 (long) names
.pn_size
);
3664 printf (_("\n Offset Kind Name\n"));
3666 printf (_("\n Offset\tName\n"));
3670 bfd_size_type maxprint
;
3672 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3676 data
+= offset_size
;
3679 maxprint
= (end
- data
) - 1;
3683 unsigned int kind_data
;
3684 gdb_index_symbol_kind kind
;
3685 const char *kind_name
;
3688 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
3691 /* GCC computes the kind as the upper byte in the CU index
3692 word, and then right shifts it by the CU index size.
3693 Left shift KIND to where the gdb-index.h accessor macros
3695 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
3696 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
3697 kind_name
= get_gdb_index_symbol_kind_name (kind
);
3698 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
3699 printf (" %-6lx %s,%-10s %.*s\n",
3700 offset
, is_static
? _("s") : _("g"),
3701 kind_name
, (int) maxprint
, data
);
3704 printf (" %-6lx\t%.*s\n", offset
, (int) maxprint
, data
);
3706 data
+= strnlen ((char *) data
, maxprint
) + 1;
3711 while (offset
!= 0);
3719 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
3721 return display_debug_pubnames_worker (section
, file
, 0);
3725 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
3727 return display_debug_pubnames_worker (section
, file
, 1);
3731 display_debug_macinfo (struct dwarf_section
*section
,
3732 void *file ATTRIBUTE_UNUSED
)
3734 unsigned char *start
= section
->start
;
3735 unsigned char *end
= start
+ section
->size
;
3736 unsigned char *curr
= start
;
3737 unsigned int bytes_read
;
3738 enum dwarf_macinfo_record_type op
;
3740 printf (_("Contents of the %s section:\n\n"), section
->name
);
3744 unsigned int lineno
;
3745 const unsigned char *string
;
3747 op
= (enum dwarf_macinfo_record_type
) *curr
;
3752 case DW_MACINFO_start_file
:
3754 unsigned int filenum
;
3756 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3758 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3761 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3766 case DW_MACINFO_end_file
:
3767 printf (_(" DW_MACINFO_end_file\n"));
3770 case DW_MACINFO_define
:
3771 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3774 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3775 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3779 case DW_MACINFO_undef
:
3780 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3783 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3784 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3788 case DW_MACINFO_vendor_ext
:
3790 unsigned int constant
;
3792 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3795 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3796 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3806 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3807 filename and dirname corresponding to file name table entry with index
3808 FILEIDX. Return NULL on failure. */
3810 static unsigned char *
3811 get_line_filename_and_dirname (dwarf_vma line_offset
,
3813 unsigned char **dir_name
)
3815 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3816 unsigned char *hdrptr
, *dirtable
, *file_name
;
3817 unsigned int offset_size
, initial_length_size
;
3818 unsigned int version
, opcode_base
, bytes_read
;
3819 dwarf_vma length
, diridx
;
3820 const unsigned char * end
;
3823 if (section
->start
== NULL
3824 || line_offset
>= section
->size
3828 hdrptr
= section
->start
+ line_offset
;
3829 end
= section
->start
+ section
->size
;
3831 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3832 if (length
== 0xffffffff)
3834 /* This section is 64-bit DWARF 3. */
3835 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3837 initial_length_size
= 12;
3842 initial_length_size
= 4;
3844 if (length
+ initial_length_size
> section
->size
)
3847 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3848 if (version
!= 2 && version
!= 3 && version
!= 4)
3850 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3852 hdrptr
++; /* Skip max_ops_per_insn. */
3853 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3855 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3856 if (opcode_base
== 0)
3859 hdrptr
+= opcode_base
- 1;
3861 /* Skip over dirname table. */
3862 while (*hdrptr
!= '\0')
3863 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3864 hdrptr
++; /* Skip the NUL at the end of the table. */
3865 /* Now skip over preceding filename table entries. */
3866 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3868 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3869 read_uleb128 (hdrptr
, &bytes_read
, end
);
3870 hdrptr
+= bytes_read
;
3871 read_uleb128 (hdrptr
, &bytes_read
, end
);
3872 hdrptr
+= bytes_read
;
3873 read_uleb128 (hdrptr
, &bytes_read
, end
);
3874 hdrptr
+= bytes_read
;
3876 if (hdrptr
== end
|| *hdrptr
== '\0')
3879 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3880 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
3883 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
3884 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
3885 if (*dirtable
== '\0')
3887 *dir_name
= dirtable
;
3892 display_debug_macro (struct dwarf_section
*section
,
3895 unsigned char *start
= section
->start
;
3896 unsigned char *end
= start
+ section
->size
;
3897 unsigned char *curr
= start
;
3898 unsigned char *extended_op_buf
[256];
3899 unsigned int bytes_read
;
3901 load_debug_section (str
, file
);
3902 load_debug_section (line
, file
);
3904 printf (_("Contents of the %s section:\n\n"), section
->name
);
3908 unsigned int lineno
, version
, flags
;
3909 unsigned int offset_size
= 4;
3910 const unsigned char *string
;
3911 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
3912 unsigned char **extended_ops
= NULL
;
3914 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
3917 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
3922 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
3925 printf (_(" Offset: 0x%lx\n"),
3926 (unsigned long) sec_offset
);
3927 printf (_(" Version: %d\n"), version
);
3928 printf (_(" Offset size: %d\n"), offset_size
);
3931 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
3932 printf (_(" Offset into .debug_line: 0x%lx\n"),
3933 (unsigned long) line_offset
);
3937 unsigned int i
, count
, op
;
3940 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
3942 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
3943 extended_ops
= extended_op_buf
;
3946 printf (_(" Extension opcode arguments:\n"));
3947 for (i
= 0; i
< count
; i
++)
3949 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
3950 extended_ops
[op
] = curr
;
3951 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
3954 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
3957 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
3958 for (n
= 0; n
< nargs
; n
++)
3962 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
3963 printf ("%s%s", get_FORM_name (form
),
3964 n
== nargs
- 1 ? "\n" : ", ");
3974 case DW_FORM_block1
:
3975 case DW_FORM_block2
:
3976 case DW_FORM_block4
:
3978 case DW_FORM_string
:
3980 case DW_FORM_sec_offset
:
3983 error (_("Invalid extension opcode form %s\n"),
3984 get_FORM_name (form
));
4000 error (_(".debug_macro section not zero terminated\n"));
4004 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4010 case DW_MACRO_GNU_start_file
:
4012 unsigned int filenum
;
4013 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4015 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4017 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4020 if ((flags
& 2) == 0)
4021 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4024 = get_line_filename_and_dirname (line_offset
, filenum
,
4026 if (file_name
== NULL
)
4027 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4030 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4032 dir_name
!= NULL
? (const char *) dir_name
: "",
4033 dir_name
!= NULL
? "/" : "", file_name
);
4037 case DW_MACRO_GNU_end_file
:
4038 printf (_(" DW_MACRO_GNU_end_file\n"));
4041 case DW_MACRO_GNU_define
:
4042 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4045 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4046 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4050 case DW_MACRO_GNU_undef
:
4051 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4054 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4055 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4059 case DW_MACRO_GNU_define_indirect
:
4060 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4062 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4063 string
= fetch_indirect_string (offset
);
4064 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4068 case DW_MACRO_GNU_undef_indirect
:
4069 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4071 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4072 string
= fetch_indirect_string (offset
);
4073 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4077 case DW_MACRO_GNU_transparent_include
:
4078 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4079 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4080 (unsigned long) offset
);
4083 case DW_MACRO_GNU_define_indirect_alt
:
4084 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4086 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4087 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4088 lineno
, (unsigned long) offset
);
4091 case DW_MACRO_GNU_undef_indirect_alt
:
4092 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4094 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4095 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4096 lineno
, (unsigned long) offset
);
4099 case DW_MACRO_GNU_transparent_include_alt
:
4100 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4101 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4102 (unsigned long) offset
);
4106 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
4108 error (_(" Unknown macro opcode %02x seen\n"), op
);
4113 /* Skip over unhandled opcodes. */
4115 unsigned char *desc
= extended_ops
[op
];
4116 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
4120 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
4123 printf (_(" DW_MACRO_GNU_%02x -"), op
);
4124 for (n
= 0; n
< nargs
; n
++)
4128 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
4130 = read_and_display_attr_value (0, val
,
4131 curr
, end
, 0, 0, offset_size
,
4132 version
, NULL
, 0, NULL
,
4150 display_debug_abbrev (struct dwarf_section
*section
,
4151 void *file ATTRIBUTE_UNUSED
)
4153 abbrev_entry
*entry
;
4154 unsigned char *start
= section
->start
;
4155 unsigned char *end
= start
+ section
->size
;
4157 printf (_("Contents of the %s section:\n\n"), section
->name
);
4161 unsigned char *last
;
4166 start
= process_abbrev_section (start
, end
);
4168 if (first_abbrev
== NULL
)
4171 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4173 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4177 printf (" %ld %s [%s]\n",
4179 get_TAG_name (entry
->tag
),
4180 entry
->children
? _("has children") : _("no children"));
4182 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4183 printf (" %-18s %s\n",
4184 get_AT_name (attr
->attribute
),
4185 get_FORM_name (attr
->form
));
4195 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4198 display_loc_list (struct dwarf_section
*section
,
4199 unsigned char **start_ptr
,
4200 int debug_info_entry
,
4201 unsigned long offset
,
4202 unsigned long base_address
,
4205 unsigned char *start
= *start_ptr
;
4206 unsigned char *section_end
= section
->start
+ section
->size
;
4207 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4208 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4209 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4210 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4214 unsigned short length
;
4215 int need_frame_base
;
4217 if (pointer_size
< 2 || pointer_size
> 8)
4219 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4220 pointer_size
, debug_info_entry
);
4226 if (start
+ 2 * pointer_size
> section_end
)
4228 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4233 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4235 /* Note: we use sign extension here in order to be sure that we can detect
4236 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4237 address will not affect the values that we display since we always show
4238 hex values, and always the bottom 32-bits. */
4239 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4240 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4242 if (begin
== 0 && end
== 0)
4244 printf (_("<End of list>\n"));
4248 /* Check base address specifiers. */
4249 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4252 print_dwarf_vma (begin
, pointer_size
);
4253 print_dwarf_vma (end
, pointer_size
);
4254 printf (_("(base address)\n"));
4258 if (start
+ 2 > section_end
)
4260 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4265 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4267 if (start
+ length
> section_end
)
4269 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4274 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4275 print_dwarf_vma (end
+ base_address
, pointer_size
);
4278 need_frame_base
= decode_location_expression (start
,
4283 cu_offset
, section
);
4286 if (need_frame_base
&& !has_frame_base
)
4287 printf (_(" [without DW_AT_frame_base]"));
4290 fputs (_(" (start == end)"), stdout
);
4291 else if (begin
> end
)
4292 fputs (_(" (start > end)"), stdout
);
4302 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4303 right-adjusted in a field of length LEN, and followed by a space. */
4306 print_addr_index (unsigned int idx
, unsigned int len
)
4308 static char buf
[15];
4309 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4310 printf ("%*s ", len
, buf
);
4313 /* Display a location list from a .dwo section. It uses address indexes rather
4314 than embedded addresses. This code closely follows display_loc_list, but the
4315 two are sufficiently different that combining things is very ugly. */
4318 display_loc_list_dwo (struct dwarf_section
*section
,
4319 unsigned char **start_ptr
,
4320 int debug_info_entry
,
4321 unsigned long offset
,
4324 unsigned char *start
= *start_ptr
;
4325 unsigned char *section_end
= section
->start
+ section
->size
;
4326 unsigned long cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4327 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4328 unsigned int offset_size
= debug_information
[debug_info_entry
].offset_size
;
4329 int dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4331 unsigned short length
;
4332 int need_frame_base
;
4334 unsigned int bytes_read
;
4336 if (pointer_size
< 2 || pointer_size
> 8)
4338 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4339 pointer_size
, debug_info_entry
);
4345 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4347 if (start
>= section_end
)
4349 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4354 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4357 case 0: /* A terminating entry. */
4359 printf (_("<End of list>\n"));
4361 case 1: /* A base-address entry. */
4362 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4363 start
+= bytes_read
;
4364 print_addr_index (idx
, 8);
4366 printf (_("(base address selection entry)\n"));
4368 case 2: /* A start/end entry. */
4369 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4370 start
+= bytes_read
;
4371 print_addr_index (idx
, 8);
4372 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4373 start
+= bytes_read
;
4374 print_addr_index (idx
, 8);
4376 case 3: /* A start/length entry. */
4377 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4378 start
+= bytes_read
;
4379 print_addr_index (idx
, 8);
4380 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4381 printf ("%08x ", idx
);
4383 case 4: /* An offset pair entry. */
4384 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4385 printf ("%08x ", idx
);
4386 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4387 printf ("%08x ", idx
);
4390 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4395 if (start
+ 2 > section_end
)
4397 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4402 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4403 if (start
+ length
> section_end
)
4405 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4411 need_frame_base
= decode_location_expression (start
,
4416 cu_offset
, section
);
4419 if (need_frame_base
&& !has_frame_base
)
4420 printf (_(" [without DW_AT_frame_base]"));
4430 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4432 static dwarf_vma
*loc_offsets
;
4435 loc_offsets_compar (const void *ap
, const void *bp
)
4437 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4438 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4440 return (a
> b
) - (b
> a
);
4444 display_debug_loc (struct dwarf_section
*section
, void *file
)
4446 unsigned char *start
= section
->start
;
4447 unsigned long bytes
;
4448 unsigned char *section_begin
= start
;
4449 unsigned int num_loc_list
= 0;
4450 unsigned long last_offset
= 0;
4451 unsigned int first
= 0;
4455 int seen_first_offset
= 0;
4456 int locs_sorted
= 1;
4457 unsigned char *next
;
4458 unsigned int *array
= NULL
;
4459 const char *suffix
= strrchr (section
->name
, '.');
4462 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4465 bytes
= section
->size
;
4469 printf (_("\nThe %s section is empty.\n"), section
->name
);
4473 if (load_debug_info (file
) == 0)
4475 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4480 /* Check the order of location list in .debug_info section. If
4481 offsets of location lists are in the ascending order, we can
4482 use `debug_information' directly. */
4483 for (i
= 0; i
< num_debug_info_entries
; i
++)
4487 num
= debug_information
[i
].num_loc_offsets
;
4488 if (num
> num_loc_list
)
4491 /* Check if we can use `debug_information' directly. */
4492 if (locs_sorted
&& num
!= 0)
4494 if (!seen_first_offset
)
4496 /* This is the first location list. */
4497 last_offset
= debug_information
[i
].loc_offsets
[0];
4499 seen_first_offset
= 1;
4505 for (; j
< num
; j
++)
4508 debug_information
[i
].loc_offsets
[j
])
4513 last_offset
= debug_information
[i
].loc_offsets
[j
];
4518 if (!seen_first_offset
)
4519 error (_("No location lists in .debug_info section!\n"));
4521 if (debug_information
[first
].num_loc_offsets
> 0
4522 && debug_information
[first
].loc_offsets
[0] != 0)
4523 warn (_("Location lists in %s section start at 0x%s\n"),
4525 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4528 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4529 printf (_("Contents of the %s section:\n\n"), section
->name
);
4530 printf (_(" Offset Begin End Expression\n"));
4532 seen_first_offset
= 0;
4533 for (i
= first
; i
< num_debug_info_entries
; i
++)
4535 unsigned long offset
;
4536 unsigned long base_address
;
4541 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4543 loc_offsets
= debug_information
[i
].loc_offsets
;
4544 qsort (array
, debug_information
[i
].num_loc_offsets
,
4545 sizeof (*array
), loc_offsets_compar
);
4548 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4550 j
= locs_sorted
? k
: array
[k
];
4552 && debug_information
[i
].loc_offsets
[locs_sorted
4553 ? k
- 1 : array
[k
- 1]]
4554 == debug_information
[i
].loc_offsets
[j
])
4556 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4557 offset
= debug_information
[i
].loc_offsets
[j
];
4558 next
= section_begin
+ offset
;
4559 base_address
= debug_information
[i
].base_address
;
4561 if (!seen_first_offset
)
4562 seen_first_offset
= 1;
4566 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4567 (unsigned long) (start
- section_begin
),
4568 (unsigned long) (next
- section_begin
));
4569 else if (start
> next
)
4570 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4571 (unsigned long) (start
- section_begin
),
4572 (unsigned long) (next
- section_begin
));
4576 if (offset
>= bytes
)
4578 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4584 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4586 display_loc_list (section
, &start
, i
, offset
, base_address
,
4591 if (start
< section
->start
+ section
->size
)
4592 warn (_("There are %ld unused bytes at the end of section %s\n"),
4593 (long) (section
->start
+ section
->size
- start
), section
->name
);
4600 display_debug_str (struct dwarf_section
*section
,
4601 void *file ATTRIBUTE_UNUSED
)
4603 unsigned char *start
= section
->start
;
4604 unsigned long bytes
= section
->size
;
4605 dwarf_vma addr
= section
->address
;
4609 printf (_("\nThe %s section is empty.\n"), section
->name
);
4613 printf (_("Contents of the %s section:\n\n"), section
->name
);
4621 lbytes
= (bytes
> 16 ? 16 : bytes
);
4623 printf (" 0x%8.8lx ", (unsigned long) addr
);
4625 for (j
= 0; j
< 16; j
++)
4628 printf ("%2.2x", start
[j
]);
4636 for (j
= 0; j
< lbytes
; j
++)
4639 if (k
>= ' ' && k
< 0x80)
4658 display_debug_info (struct dwarf_section
*section
, void *file
)
4660 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4664 display_debug_types (struct dwarf_section
*section
, void *file
)
4666 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4670 display_trace_info (struct dwarf_section
*section
, void *file
)
4672 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4676 display_debug_aranges (struct dwarf_section
*section
,
4677 void *file ATTRIBUTE_UNUSED
)
4679 unsigned char *start
= section
->start
;
4680 unsigned char *end
= start
+ section
->size
;
4682 printf (_("Contents of the %s section:\n\n"), section
->name
);
4684 /* It does not matter if this load fails,
4685 we test for that later on. */
4686 load_debug_info (file
);
4690 unsigned char *hdrptr
;
4691 DWARF2_Internal_ARange arange
;
4692 unsigned char *addr_ranges
;
4695 unsigned char address_size
;
4697 unsigned int offset_size
;
4698 unsigned int initial_length_size
;
4702 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4703 if (arange
.ar_length
== 0xffffffff)
4705 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4707 initial_length_size
= 12;
4712 initial_length_size
= 4;
4715 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4716 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4718 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4719 && num_debug_info_entries
> 0
4720 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4721 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4722 (unsigned long) arange
.ar_info_offset
, section
->name
);
4724 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4725 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4727 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4729 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4733 printf (_(" Length: %ld\n"),
4734 (long) arange
.ar_length
);
4735 printf (_(" Version: %d\n"), arange
.ar_version
);
4736 printf (_(" Offset into .debug_info: 0x%lx\n"),
4737 (unsigned long) arange
.ar_info_offset
);
4738 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4739 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4741 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4743 /* PR 17512: file: 001-108546-0.001:0.1. */
4744 if (address_size
== 0 || address_size
> 8)
4746 error (_("Invalid address size in %s section!\n"),
4751 /* The DWARF spec does not require that the address size be a power
4752 of two, but we do. This will have to change if we ever encounter
4753 an uneven architecture. */
4754 if ((address_size
& (address_size
- 1)) != 0)
4756 warn (_("Pointer size + Segment size is not a power of two.\n"));
4760 if (address_size
> 4)
4761 printf (_("\n Address Length\n"));
4763 printf (_("\n Address Length\n"));
4765 addr_ranges
= hdrptr
;
4767 /* Must pad to an alignment boundary that is twice the address size. */
4768 excess
= (hdrptr
- start
) % (2 * address_size
);
4770 addr_ranges
+= (2 * address_size
) - excess
;
4772 start
+= arange
.ar_length
+ initial_length_size
;
4774 while (addr_ranges
+ 2 * address_size
<= start
)
4776 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4777 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4780 print_dwarf_vma (address
, address_size
);
4781 print_dwarf_vma (length
, address_size
);
4791 /* Comparison function for qsort. */
4793 comp_addr_base (const void * v0
, const void * v1
)
4795 debug_info
* info0
= (debug_info
*) v0
;
4796 debug_info
* info1
= (debug_info
*) v1
;
4797 return info0
->addr_base
- info1
->addr_base
;
4800 /* Display the debug_addr section. */
4802 display_debug_addr (struct dwarf_section
*section
,
4805 debug_info
**debug_addr_info
;
4806 unsigned char *entry
;
4811 if (section
->size
== 0)
4813 printf (_("\nThe %s section is empty.\n"), section
->name
);
4817 if (load_debug_info (file
) == 0)
4819 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4824 printf (_("Contents of the %s section:\n\n"), section
->name
);
4826 debug_addr_info
= (debug_info
**) xmalloc ((num_debug_info_entries
+ 1)
4827 * sizeof (debug_info
*));
4830 for (i
= 0; i
< num_debug_info_entries
; i
++)
4832 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4833 debug_addr_info
[count
++] = &debug_information
[i
];
4836 /* Add a sentinel to make iteration convenient. */
4837 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
4838 debug_addr_info
[count
]->addr_base
= section
->size
;
4840 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
4841 for (i
= 0; i
< count
; i
++)
4844 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
4846 printf (_(" For compilation unit at offset 0x%s:\n"),
4847 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
4849 printf (_("\tIndex\tAddress\n"));
4850 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
4851 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
4855 dwarf_vma base
= byte_get (entry
, address_size
);
4856 printf (_("\t%d:\t"), idx
);
4857 print_dwarf_vma (base
, address_size
);
4859 entry
+= address_size
;
4865 free (debug_addr_info
);
4869 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
4871 display_debug_str_offsets (struct dwarf_section
*section
,
4872 void *file ATTRIBUTE_UNUSED
)
4874 if (section
->size
== 0)
4876 printf (_("\nThe %s section is empty.\n"), section
->name
);
4879 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
4880 what the offset size is for this section. */
4884 /* Each debug_information[x].range_lists[y] gets this representation for
4885 sorting purposes. */
4889 /* The debug_information[x].range_lists[y] value. */
4890 unsigned long ranges_offset
;
4892 /* Original debug_information to find parameters of the data. */
4893 debug_info
*debug_info_p
;
4896 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
4899 range_entry_compar (const void *ap
, const void *bp
)
4901 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
4902 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
4903 const unsigned long a
= a_re
->ranges_offset
;
4904 const unsigned long b
= b_re
->ranges_offset
;
4906 return (a
> b
) - (b
> a
);
4910 display_debug_ranges (struct dwarf_section
*section
,
4911 void *file ATTRIBUTE_UNUSED
)
4913 unsigned char *start
= section
->start
;
4914 unsigned char *last_start
= start
;
4915 unsigned long bytes
= section
->size
;
4916 unsigned char *section_begin
= start
;
4917 unsigned char *finish
= start
+ bytes
;
4918 unsigned int num_range_list
, i
;
4919 struct range_entry
*range_entries
, *range_entry_fill
;
4923 printf (_("\nThe %s section is empty.\n"), section
->name
);
4927 if (load_debug_info (file
) == 0)
4929 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4935 for (i
= 0; i
< num_debug_info_entries
; i
++)
4936 num_range_list
+= debug_information
[i
].num_range_lists
;
4938 if (num_range_list
== 0)
4940 /* This can happen when the file was compiled with -gsplit-debug
4941 which removes references to range lists from the primary .o file. */
4942 printf (_("No range lists in .debug_info section.\n"));
4946 range_entries
= (struct range_entry
*)
4947 xmalloc (sizeof (*range_entries
) * num_range_list
);
4948 range_entry_fill
= range_entries
;
4950 for (i
= 0; i
< num_debug_info_entries
; i
++)
4952 debug_info
*debug_info_p
= &debug_information
[i
];
4955 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
4957 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
4958 range_entry_fill
->debug_info_p
= debug_info_p
;
4963 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
4964 range_entry_compar
);
4966 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
4967 warn (_("Range lists in %s section start at 0x%lx\n"),
4968 section
->name
, range_entries
[0].ranges_offset
);
4970 printf (_("Contents of the %s section:\n\n"), section
->name
);
4971 printf (_(" Offset Begin End\n"));
4973 for (i
= 0; i
< num_range_list
; i
++)
4975 struct range_entry
*range_entry
= &range_entries
[i
];
4976 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
4977 unsigned int pointer_size
;
4978 unsigned long offset
;
4979 unsigned char *next
;
4980 unsigned long base_address
;
4982 pointer_size
= debug_info_p
->pointer_size
;
4983 offset
= range_entry
->ranges_offset
;
4984 next
= section_begin
+ offset
;
4985 base_address
= debug_info_p
->base_address
;
4987 /* PR 17512: file: 001-101485-0.001:0.1. */
4988 if (pointer_size
< 2 || pointer_size
> 8)
4990 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
4991 pointer_size
, offset
);
4995 if (dwarf_check
!= 0 && i
> 0)
4998 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
4999 (unsigned long) (start
- section_begin
),
5000 (unsigned long) (next
- section_begin
), section
->name
);
5001 else if (start
> next
)
5003 if (next
== last_start
)
5005 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5006 (unsigned long) (start
- section_begin
),
5007 (unsigned long) (next
- section_begin
), section
->name
);
5013 while (start
< finish
)
5018 /* Note: we use sign extension here in order to be sure that
5019 we can detect the -1 escape value. Sign extension into the
5020 top 32 bits of a 32-bit address will not affect the values
5021 that we display since we always show hex values, and always
5022 the bottom 32-bits. */
5023 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
5024 if (start
>= finish
)
5026 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
5028 printf (" %8.8lx ", offset
);
5030 if (begin
== 0 && end
== 0)
5032 printf (_("<End of list>\n"));
5036 /* Check base address specifiers. */
5037 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
5040 print_dwarf_vma (begin
, pointer_size
);
5041 print_dwarf_vma (end
, pointer_size
);
5042 printf ("(base address)\n");
5046 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5047 print_dwarf_vma (end
+ base_address
, pointer_size
);
5050 fputs (_("(start == end)"), stdout
);
5051 else if (begin
> end
)
5052 fputs (_("(start > end)"), stdout
);
5059 free (range_entries
);
5064 typedef struct Frame_Chunk
5066 struct Frame_Chunk
*next
;
5067 unsigned char *chunk_start
;
5069 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5070 short int *col_type
;
5073 unsigned int code_factor
;
5080 unsigned char fde_encoding
;
5081 unsigned char cfa_exp
;
5082 unsigned char ptr_size
;
5083 unsigned char segment_size
;
5087 static const char *const *dwarf_regnames
;
5088 static unsigned int dwarf_regnames_count
;
5090 /* A marker for a col_type that means this column was never referenced
5091 in the frame info. */
5092 #define DW_CFA_unreferenced (-1)
5094 /* Return 0 if not more space is needed, 1 if more space is needed,
5095 -1 for invalid reg. */
5098 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
5100 int prev
= fc
->ncols
;
5102 if (reg
< (unsigned int) fc
->ncols
)
5105 if (dwarf_regnames_count
5106 && reg
> dwarf_regnames_count
)
5109 fc
->ncols
= reg
+ 1;
5110 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
5111 sizeof (short int));
5112 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
5113 /* PR 17512: file:002-10025-0.005. */
5114 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
5116 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5122 while (prev
< fc
->ncols
)
5124 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
5125 fc
->col_offset
[prev
] = 0;
5131 static const char *const dwarf_regnames_i386
[] =
5133 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5134 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5135 "eip", "eflags", NULL
, /* 8 - 10 */
5136 "st0", "st1", "st2", "st3", /* 11 - 14 */
5137 "st4", "st5", "st6", "st7", /* 15 - 18 */
5138 NULL
, NULL
, /* 19 - 20 */
5139 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5140 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5141 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5142 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5143 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5144 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5145 "tr", "ldtr", /* 48 - 49 */
5146 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5147 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5148 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5149 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5150 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5151 NULL
, NULL
, NULL
, /* 90 - 92 */
5152 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5156 init_dwarf_regnames_i386 (void)
5158 dwarf_regnames
= dwarf_regnames_i386
;
5159 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5162 static const char *const dwarf_regnames_x86_64
[] =
5164 "rax", "rdx", "rcx", "rbx",
5165 "rsi", "rdi", "rbp", "rsp",
5166 "r8", "r9", "r10", "r11",
5167 "r12", "r13", "r14", "r15",
5169 "xmm0", "xmm1", "xmm2", "xmm3",
5170 "xmm4", "xmm5", "xmm6", "xmm7",
5171 "xmm8", "xmm9", "xmm10", "xmm11",
5172 "xmm12", "xmm13", "xmm14", "xmm15",
5173 "st0", "st1", "st2", "st3",
5174 "st4", "st5", "st6", "st7",
5175 "mm0", "mm1", "mm2", "mm3",
5176 "mm4", "mm5", "mm6", "mm7",
5178 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5179 "fs.base", "gs.base", NULL
, NULL
,
5181 "mxcsr", "fcw", "fsw",
5182 "xmm16", "xmm17", "xmm18", "xmm19",
5183 "xmm20", "xmm21", "xmm22", "xmm23",
5184 "xmm24", "xmm25", "xmm26", "xmm27",
5185 "xmm28", "xmm29", "xmm30", "xmm31",
5186 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5187 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5188 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5189 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5190 NULL
, NULL
, NULL
, /* 115 - 117 */
5191 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5195 init_dwarf_regnames_x86_64 (void)
5197 dwarf_regnames
= dwarf_regnames_x86_64
;
5198 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5201 static const char *const dwarf_regnames_aarch64
[] =
5203 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5204 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5205 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5206 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5207 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5208 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5209 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5210 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5211 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5212 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5213 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5214 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5218 init_dwarf_regnames_aarch64 (void)
5220 dwarf_regnames
= dwarf_regnames_aarch64
;
5221 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
5225 init_dwarf_regnames (unsigned int e_machine
)
5231 init_dwarf_regnames_i386 ();
5237 init_dwarf_regnames_x86_64 ();
5241 init_dwarf_regnames_aarch64 ();
5250 regname (unsigned int regno
, int row
)
5252 static char reg
[64];
5254 && regno
< dwarf_regnames_count
5255 && dwarf_regnames
[regno
] != NULL
)
5258 return dwarf_regnames
[regno
];
5259 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5260 dwarf_regnames
[regno
]);
5263 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5268 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
5273 if (*max_regs
< fc
->ncols
)
5274 *max_regs
= fc
->ncols
;
5276 if (*need_col_headers
)
5278 static const char *sloc
= " LOC";
5280 *need_col_headers
= 0;
5282 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5284 for (r
= 0; r
< *max_regs
; r
++)
5285 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5290 printf ("%-5s ", regname (r
, 1));
5296 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5298 strcpy (tmp
, "exp");
5300 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5301 printf ("%-8s ", tmp
);
5303 for (r
= 0; r
< fc
->ncols
; r
++)
5305 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5307 switch (fc
->col_type
[r
])
5309 case DW_CFA_undefined
:
5312 case DW_CFA_same_value
:
5316 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5318 case DW_CFA_val_offset
:
5319 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5321 case DW_CFA_register
:
5322 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5324 case DW_CFA_expression
:
5325 strcpy (tmp
, "exp");
5327 case DW_CFA_val_expression
:
5328 strcpy (tmp
, "vexp");
5331 strcpy (tmp
, "n/a");
5334 printf ("%-5s ", tmp
);
5340 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5341 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5342 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5344 static unsigned char *
5345 read_cie (unsigned char *start
, unsigned char *end
,
5346 Frame_Chunk
**p_cie
, int *p_version
,
5347 unsigned long *p_aug_len
, unsigned char **p_aug
)
5351 unsigned int length_return
;
5352 unsigned char *augmentation_data
= NULL
;
5353 unsigned long augmentation_data_len
= 0;
5356 /* PR 17512: file: 001-228113-0.004. */
5360 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5361 memset (fc
, 0, sizeof (Frame_Chunk
));
5363 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5364 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5368 fc
->augmentation
= (char *) start
;
5369 /* PR 17512: file: 001-228113-0.004.
5370 Skip past augmentation name, but avoid running off the end of the data. */
5372 if (* start
++ == '\0')
5376 warn (_("No terminator for augmentation name\n"));
5380 if (strcmp (fc
->augmentation
, "eh") == 0)
5381 start
+= eh_addr_size
;
5385 GET (fc
->ptr_size
, 1);
5386 GET (fc
->segment_size
, 1);
5387 eh_addr_size
= fc
->ptr_size
;
5391 fc
->ptr_size
= eh_addr_size
;
5392 fc
->segment_size
= 0;
5394 fc
->code_factor
= LEB ();
5395 fc
->data_factor
= SLEB ();
5405 if (fc
->augmentation
[0] == 'z')
5407 augmentation_data_len
= LEB ();
5408 augmentation_data
= start
;
5409 start
+= augmentation_data_len
;
5412 if (augmentation_data_len
)
5414 unsigned char *p
, *q
;
5415 p
= (unsigned char *) fc
->augmentation
+ 1;
5416 q
= augmentation_data
;
5423 q
+= 1 + size_of_encoded_value (*q
);
5425 fc
->fde_encoding
= *q
++;
5436 *p_version
= version
;
5439 *p_aug_len
= augmentation_data_len
;
5440 *p_aug
= augmentation_data
;
5446 display_debug_frames (struct dwarf_section
*section
,
5447 void *file ATTRIBUTE_UNUSED
)
5449 unsigned char *start
= section
->start
;
5450 unsigned char *end
= start
+ section
->size
;
5451 unsigned char *section_start
= start
;
5452 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
5453 Frame_Chunk
*remembered_state
= 0;
5455 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5456 unsigned int length_return
;
5458 const char *bad_reg
= _("bad register: ");
5459 int saved_eh_addr_size
= eh_addr_size
;
5461 printf (_("Contents of the %s section:\n"), section
->name
);
5465 unsigned char *saved_start
;
5466 unsigned char *block_end
;
5471 int need_col_headers
= 1;
5472 unsigned char *augmentation_data
= NULL
;
5473 unsigned long augmentation_data_len
= 0;
5474 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5475 unsigned int offset_size
;
5476 unsigned int initial_length_size
;
5478 saved_start
= start
;
5480 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5484 printf ("\n%08lx ZERO terminator\n\n",
5485 (unsigned long)(saved_start
- section_start
));
5486 /* Skip any zero terminators that directly follow.
5487 A corrupt section size could have loaded a whole
5488 slew of zero filled memory bytes. eg
5489 PR 17512: file: 070-19381-0.004. */
5490 while (start
< end
&& * start
== 0)
5495 if (length
== 0xffffffff)
5497 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5499 initial_length_size
= 12;
5504 initial_length_size
= 4;
5507 block_end
= saved_start
+ length
+ initial_length_size
;
5508 if (block_end
> end
|| block_end
< start
)
5510 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5511 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5512 (unsigned long) (saved_start
- section_start
));
5516 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5518 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5519 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5524 start
= read_cie (start
, end
, &cie
, &version
,
5525 &augmentation_data_len
, &augmentation_data
);
5526 /* PR 17512: file: 027-135133-0.005. */
5532 fc
->chunk_start
= saved_start
;
5533 mreg
= max_regs
- 1;
5536 frame_need_space (fc
, mreg
);
5537 if (fc
->fde_encoding
)
5538 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5540 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5541 print_dwarf_vma (length
, fc
->ptr_size
);
5542 print_dwarf_vma (cie_id
, offset_size
);
5544 if (do_debug_frames_interp
)
5546 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5547 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5552 printf (" Version: %d\n", version
);
5553 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5556 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5557 printf (" Segment Size: %u\n", fc
->segment_size
);
5559 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5560 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5561 printf (" Return address column: %d\n", fc
->ra
);
5563 if (augmentation_data_len
)
5566 printf (" Augmentation data: ");
5567 for (i
= 0; i
< augmentation_data_len
; ++i
)
5568 printf (" %02x", augmentation_data
[i
]);
5576 unsigned char *look_for
;
5577 static Frame_Chunk fde_fc
;
5578 unsigned long segment_selector
;
5582 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
5583 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
5586 look_for
= section_start
+ cie_id
;
5588 if (look_for
<= saved_start
)
5590 for (cie
= chunks
; cie
; cie
= cie
->next
)
5591 if (cie
->chunk_start
== look_for
)
5596 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
5597 if (cie
->chunk_start
== look_for
)
5601 unsigned int off_size
;
5602 unsigned char *cie_scan
;
5604 cie_scan
= look_for
;
5606 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
5607 if (length
== 0xffffffff)
5609 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
5616 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
5619 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
5620 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
5625 read_cie (cie_scan
, end
, &cie
, &version
,
5626 &augmentation_data_len
, &augmentation_data
);
5627 cie
->next
= forward_refs
;
5629 cie
->chunk_start
= look_for
;
5630 mreg
= max_regs
- 1;
5633 frame_need_space (cie
, mreg
);
5634 if (cie
->fde_encoding
)
5636 = size_of_encoded_value (cie
->fde_encoding
);
5643 memset (fc
, 0, sizeof (Frame_Chunk
));
5647 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5648 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5649 (unsigned long) (saved_start
- section_start
));
5651 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5652 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5653 frame_need_space (fc
, max_regs
- 1);
5655 fc
->augmentation
= "";
5656 fc
->fde_encoding
= 0;
5657 fc
->ptr_size
= eh_addr_size
;
5658 fc
->segment_size
= 0;
5662 fc
->ncols
= cie
->ncols
;
5663 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5664 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5665 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5666 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5667 fc
->augmentation
= cie
->augmentation
;
5668 fc
->ptr_size
= cie
->ptr_size
;
5669 eh_addr_size
= cie
->ptr_size
;
5670 fc
->segment_size
= cie
->segment_size
;
5671 fc
->code_factor
= cie
->code_factor
;
5672 fc
->data_factor
= cie
->data_factor
;
5673 fc
->cfa_reg
= cie
->cfa_reg
;
5674 fc
->cfa_offset
= cie
->cfa_offset
;
5676 frame_need_space (fc
, max_regs
- 1);
5677 fc
->fde_encoding
= cie
->fde_encoding
;
5680 if (fc
->fde_encoding
)
5681 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5683 segment_selector
= 0;
5684 if (fc
->segment_size
)
5685 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5687 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
5689 /* FIXME: It appears that sometimes the final pc_range value is
5690 encoded in less than encoded_ptr_size bytes. See the x86_64
5691 run of the "objcopy on compressed debug sections" test for an
5693 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5695 if (cie
->augmentation
[0] == 'z')
5697 augmentation_data_len
= LEB ();
5698 augmentation_data
= start
;
5699 start
+= augmentation_data_len
;
5702 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5703 (unsigned long)(saved_start
- section_start
),
5704 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
5705 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5706 (unsigned long)(cie
->chunk_start
- section_start
));
5708 if (fc
->segment_size
)
5709 printf ("%04lx:", segment_selector
);
5712 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
5713 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
5715 if (! do_debug_frames_interp
&& augmentation_data_len
)
5719 printf (" Augmentation data: ");
5720 for (i
= 0; i
< augmentation_data_len
; ++i
)
5721 printf (" %02x", augmentation_data
[i
]);
5727 /* At this point, fc is the current chunk, cie (if any) is set, and
5728 we're about to interpret instructions for the chunk. */
5729 /* ??? At present we need to do this always, since this sizes the
5730 fc->col_type and fc->col_offset arrays, which we write into always.
5731 We should probably split the interpreted and non-interpreted bits
5732 into two different routines, since there's so much that doesn't
5733 really overlap between them. */
5734 if (1 || do_debug_frames_interp
)
5736 /* Start by making a pass over the chunk, allocating storage
5737 and taking note of what registers are used. */
5738 unsigned char *tmp
= start
;
5740 while (start
< block_end
)
5742 unsigned int reg
, op
, opa
;
5750 /* Warning: if you add any more cases to this switch, be
5751 sure to add them to the corresponding switch below. */
5754 case DW_CFA_advance_loc
:
5758 if (frame_need_space (fc
, opa
) >= 0)
5759 fc
->col_type
[opa
] = DW_CFA_undefined
;
5761 case DW_CFA_restore
:
5762 if (frame_need_space (fc
, opa
) >= 0)
5763 fc
->col_type
[opa
] = DW_CFA_undefined
;
5765 case DW_CFA_set_loc
:
5766 start
+= encoded_ptr_size
;
5768 case DW_CFA_advance_loc1
:
5771 case DW_CFA_advance_loc2
:
5774 case DW_CFA_advance_loc4
:
5777 case DW_CFA_offset_extended
:
5778 case DW_CFA_val_offset
:
5779 reg
= LEB (); LEB ();
5780 if (frame_need_space (fc
, reg
) >= 0)
5781 fc
->col_type
[reg
] = DW_CFA_undefined
;
5783 case DW_CFA_restore_extended
:
5785 frame_need_space (fc
, reg
);
5786 if (frame_need_space (fc
, reg
) >= 0)
5787 fc
->col_type
[reg
] = DW_CFA_undefined
;
5789 case DW_CFA_undefined
:
5791 if (frame_need_space (fc
, reg
) >= 0)
5792 fc
->col_type
[reg
] = DW_CFA_undefined
;
5794 case DW_CFA_same_value
:
5796 if (frame_need_space (fc
, reg
) >= 0)
5797 fc
->col_type
[reg
] = DW_CFA_undefined
;
5799 case DW_CFA_register
:
5800 reg
= LEB (); LEB ();
5801 if (frame_need_space (fc
, reg
) >= 0)
5802 fc
->col_type
[reg
] = DW_CFA_undefined
;
5804 case DW_CFA_def_cfa
:
5807 case DW_CFA_def_cfa_register
:
5810 case DW_CFA_def_cfa_offset
:
5813 case DW_CFA_def_cfa_expression
:
5815 if (start
+ temp
< start
)
5817 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
5823 case DW_CFA_expression
:
5824 case DW_CFA_val_expression
:
5827 if (start
+ temp
< start
)
5829 /* PR 17512: file:306-192417-0.005. */
5830 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
5835 if (frame_need_space (fc
, reg
) >= 0)
5836 fc
->col_type
[reg
] = DW_CFA_undefined
;
5838 case DW_CFA_offset_extended_sf
:
5839 case DW_CFA_val_offset_sf
:
5840 reg
= LEB (); SLEB ();
5841 if (frame_need_space (fc
, reg
) >= 0)
5842 fc
->col_type
[reg
] = DW_CFA_undefined
;
5844 case DW_CFA_def_cfa_sf
:
5847 case DW_CFA_def_cfa_offset_sf
:
5850 case DW_CFA_MIPS_advance_loc8
:
5853 case DW_CFA_GNU_args_size
:
5856 case DW_CFA_GNU_negative_offset_extended
:
5857 reg
= LEB (); LEB ();
5858 if (frame_need_space (fc
, reg
) >= 0)
5859 fc
->col_type
[reg
] = DW_CFA_undefined
;
5868 /* Now we know what registers are used, make a second pass over
5869 the chunk, this time actually printing out the info. */
5871 while (start
< block_end
)
5874 unsigned long ul
, reg
, roffs
;
5878 const char *reg_prefix
= "";
5885 /* Warning: if you add any more cases to this switch, be
5886 sure to add them to the corresponding switch above. */
5889 case DW_CFA_advance_loc
:
5890 if (do_debug_frames_interp
)
5891 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5893 printf (" DW_CFA_advance_loc: %d to %s\n",
5894 opa
* fc
->code_factor
,
5895 dwarf_vmatoa_1 (NULL
,
5896 fc
->pc_begin
+ opa
* fc
->code_factor
,
5898 fc
->pc_begin
+= opa
* fc
->code_factor
;
5903 if (opa
>= (unsigned int) fc
->ncols
)
5904 reg_prefix
= bad_reg
;
5905 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5906 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
5907 reg_prefix
, regname (opa
, 0),
5908 roffs
* fc
->data_factor
);
5909 if (*reg_prefix
== '\0')
5911 fc
->col_type
[opa
] = DW_CFA_offset
;
5912 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
5916 case DW_CFA_restore
:
5917 if (opa
>= (unsigned int) cie
->ncols
5918 || opa
>= (unsigned int) fc
->ncols
)
5919 reg_prefix
= bad_reg
;
5920 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5921 printf (" DW_CFA_restore: %s%s\n",
5922 reg_prefix
, regname (opa
, 0));
5923 if (*reg_prefix
== '\0')
5925 fc
->col_type
[opa
] = cie
->col_type
[opa
];
5926 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
5927 if (do_debug_frames_interp
5928 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
5929 fc
->col_type
[opa
] = DW_CFA_undefined
;
5933 case DW_CFA_set_loc
:
5934 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
5935 if (do_debug_frames_interp
)
5936 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5938 printf (" DW_CFA_set_loc: %s\n",
5939 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
5943 case DW_CFA_advance_loc1
:
5944 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
5945 if (do_debug_frames_interp
)
5946 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5948 printf (" DW_CFA_advance_loc1: %ld to %s\n",
5949 (unsigned long) (ofs
* fc
->code_factor
),
5950 dwarf_vmatoa_1 (NULL
,
5951 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5953 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5956 case DW_CFA_advance_loc2
:
5957 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
5958 if (do_debug_frames_interp
)
5959 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5961 printf (" DW_CFA_advance_loc2: %ld to %s\n",
5962 (unsigned long) (ofs
* fc
->code_factor
),
5963 dwarf_vmatoa_1 (NULL
,
5964 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5966 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5969 case DW_CFA_advance_loc4
:
5970 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
5971 if (do_debug_frames_interp
)
5972 frame_display_row (fc
, &need_col_headers
, &max_regs
);
5974 printf (" DW_CFA_advance_loc4: %ld to %s\n",
5975 (unsigned long) (ofs
* fc
->code_factor
),
5976 dwarf_vmatoa_1 (NULL
,
5977 fc
->pc_begin
+ ofs
* fc
->code_factor
,
5979 fc
->pc_begin
+= ofs
* fc
->code_factor
;
5982 case DW_CFA_offset_extended
:
5985 if (reg
>= (unsigned int) fc
->ncols
)
5986 reg_prefix
= bad_reg
;
5987 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
5988 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
5989 reg_prefix
, regname (reg
, 0),
5990 roffs
* fc
->data_factor
);
5991 if (*reg_prefix
== '\0')
5993 fc
->col_type
[reg
] = DW_CFA_offset
;
5994 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
5998 case DW_CFA_val_offset
:
6001 if (reg
>= (unsigned int) fc
->ncols
)
6002 reg_prefix
= bad_reg
;
6003 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6004 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6005 reg_prefix
, regname (reg
, 0),
6006 roffs
* fc
->data_factor
);
6007 if (*reg_prefix
== '\0')
6009 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6010 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6014 case DW_CFA_restore_extended
:
6016 if (reg
>= (unsigned int) cie
->ncols
6017 || reg
>= (unsigned int) fc
->ncols
)
6018 reg_prefix
= bad_reg
;
6019 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6020 printf (" DW_CFA_restore_extended: %s%s\n",
6021 reg_prefix
, regname (reg
, 0));
6022 if (*reg_prefix
== '\0')
6024 fc
->col_type
[reg
] = cie
->col_type
[reg
];
6025 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
6029 case DW_CFA_undefined
:
6031 if (reg
>= (unsigned int) fc
->ncols
)
6032 reg_prefix
= bad_reg
;
6033 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6034 printf (" DW_CFA_undefined: %s%s\n",
6035 reg_prefix
, regname (reg
, 0));
6036 if (*reg_prefix
== '\0')
6038 fc
->col_type
[reg
] = DW_CFA_undefined
;
6039 fc
->col_offset
[reg
] = 0;
6043 case DW_CFA_same_value
:
6045 if (reg
>= (unsigned int) fc
->ncols
)
6046 reg_prefix
= bad_reg
;
6047 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6048 printf (" DW_CFA_same_value: %s%s\n",
6049 reg_prefix
, regname (reg
, 0));
6050 if (*reg_prefix
== '\0')
6052 fc
->col_type
[reg
] = DW_CFA_same_value
;
6053 fc
->col_offset
[reg
] = 0;
6057 case DW_CFA_register
:
6060 if (reg
>= (unsigned int) fc
->ncols
)
6061 reg_prefix
= bad_reg
;
6062 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6064 printf (" DW_CFA_register: %s%s in ",
6065 reg_prefix
, regname (reg
, 0));
6066 puts (regname (roffs
, 0));
6068 if (*reg_prefix
== '\0')
6070 fc
->col_type
[reg
] = DW_CFA_register
;
6071 fc
->col_offset
[reg
] = roffs
;
6075 case DW_CFA_remember_state
:
6076 if (! do_debug_frames_interp
)
6077 printf (" DW_CFA_remember_state\n");
6078 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6079 rs
->cfa_offset
= fc
->cfa_offset
;
6080 rs
->cfa_reg
= fc
->cfa_reg
;
6082 rs
->cfa_exp
= fc
->cfa_exp
;
6083 rs
->ncols
= fc
->ncols
;
6084 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
6085 sizeof (* rs
->col_type
));
6086 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
6087 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
6088 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
6089 rs
->next
= remembered_state
;
6090 remembered_state
= rs
;
6093 case DW_CFA_restore_state
:
6094 if (! do_debug_frames_interp
)
6095 printf (" DW_CFA_restore_state\n");
6096 rs
= remembered_state
;
6099 remembered_state
= rs
->next
;
6100 fc
->cfa_offset
= rs
->cfa_offset
;
6101 fc
->cfa_reg
= rs
->cfa_reg
;
6103 fc
->cfa_exp
= rs
->cfa_exp
;
6104 frame_need_space (fc
, rs
->ncols
- 1);
6105 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
6106 memcpy (fc
->col_offset
, rs
->col_offset
,
6107 rs
->ncols
* sizeof (* rs
->col_offset
));
6108 free (rs
->col_type
);
6109 free (rs
->col_offset
);
6112 else if (do_debug_frames_interp
)
6113 printf ("Mismatched DW_CFA_restore_state\n");
6116 case DW_CFA_def_cfa
:
6117 fc
->cfa_reg
= LEB ();
6118 fc
->cfa_offset
= LEB ();
6120 if (! do_debug_frames_interp
)
6121 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6122 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6125 case DW_CFA_def_cfa_register
:
6126 fc
->cfa_reg
= LEB ();
6128 if (! do_debug_frames_interp
)
6129 printf (" DW_CFA_def_cfa_register: %s\n",
6130 regname (fc
->cfa_reg
, 0));
6133 case DW_CFA_def_cfa_offset
:
6134 fc
->cfa_offset
= LEB ();
6135 if (! do_debug_frames_interp
)
6136 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
6140 if (! do_debug_frames_interp
)
6141 printf (" DW_CFA_nop\n");
6144 case DW_CFA_def_cfa_expression
:
6146 if (start
>= block_end
)
6148 printf (" DW_CFA_def_cfa_expression: <corrupt>\n");
6149 warn (_("Corrupt length field in DW_CFA_def_cfa_expression\n"));
6152 if (! do_debug_frames_interp
)
6154 printf (" DW_CFA_def_cfa_expression (");
6155 decode_location_expression (start
, eh_addr_size
, 0, -1,
6163 case DW_CFA_expression
:
6166 if (reg
>= (unsigned int) fc
->ncols
)
6167 reg_prefix
= bad_reg
;
6168 /* PR 17512: file: 069-133014-0.006. */
6169 if (start
>= block_end
)
6171 printf (" DW_CFA_expression: <corrupt>\n");
6172 warn (_("Corrupt length field in DW_CFA_expression\n"));
6175 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6177 printf (" DW_CFA_expression: %s%s (",
6178 reg_prefix
, regname (reg
, 0));
6179 decode_location_expression (start
, eh_addr_size
, 0, -1,
6183 if (*reg_prefix
== '\0')
6184 fc
->col_type
[reg
] = DW_CFA_expression
;
6188 case DW_CFA_val_expression
:
6191 if (reg
>= (unsigned int) fc
->ncols
)
6192 reg_prefix
= bad_reg
;
6193 if (start
>= block_end
)
6195 printf (" DW_CFA_val_expression: <corrupt>\n");
6196 warn (_("Corrupt length field in DW_CFA_val_expression\n"));
6199 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6201 printf (" DW_CFA_val_expression: %s%s (",
6202 reg_prefix
, regname (reg
, 0));
6203 decode_location_expression (start
, eh_addr_size
, 0, -1,
6207 if (*reg_prefix
== '\0')
6208 fc
->col_type
[reg
] = DW_CFA_val_expression
;
6212 case DW_CFA_offset_extended_sf
:
6215 if (frame_need_space (fc
, reg
) < 0)
6216 reg_prefix
= bad_reg
;
6217 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6218 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6219 reg_prefix
, regname (reg
, 0),
6220 l
* fc
->data_factor
);
6221 if (*reg_prefix
== '\0')
6223 fc
->col_type
[reg
] = DW_CFA_offset
;
6224 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6228 case DW_CFA_val_offset_sf
:
6231 if (frame_need_space (fc
, reg
) < 0)
6232 reg_prefix
= bad_reg
;
6233 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6234 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6235 reg_prefix
, regname (reg
, 0),
6236 l
* fc
->data_factor
);
6237 if (*reg_prefix
== '\0')
6239 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6240 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6244 case DW_CFA_def_cfa_sf
:
6245 fc
->cfa_reg
= LEB ();
6246 fc
->cfa_offset
= SLEB ();
6247 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6249 if (! do_debug_frames_interp
)
6250 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6251 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6254 case DW_CFA_def_cfa_offset_sf
:
6255 fc
->cfa_offset
= SLEB ();
6256 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6257 if (! do_debug_frames_interp
)
6258 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
6261 case DW_CFA_MIPS_advance_loc8
:
6262 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
6263 if (do_debug_frames_interp
)
6264 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6266 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6267 (unsigned long) (ofs
* fc
->code_factor
),
6268 dwarf_vmatoa_1 (NULL
,
6269 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6271 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6274 case DW_CFA_GNU_window_save
:
6275 if (! do_debug_frames_interp
)
6276 printf (" DW_CFA_GNU_window_save\n");
6279 case DW_CFA_GNU_args_size
:
6281 if (! do_debug_frames_interp
)
6282 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
6285 case DW_CFA_GNU_negative_offset_extended
:
6288 if (frame_need_space (fc
, reg
) < 0)
6289 reg_prefix
= bad_reg
;
6290 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6291 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6292 reg_prefix
, regname (reg
, 0),
6293 l
* fc
->data_factor
);
6294 if (*reg_prefix
== '\0')
6296 fc
->col_type
[reg
] = DW_CFA_offset
;
6297 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6302 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
6303 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
6305 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
6310 if (do_debug_frames_interp
)
6311 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6314 eh_addr_size
= saved_eh_addr_size
;
6327 display_gdb_index (struct dwarf_section
*section
,
6328 void *file ATTRIBUTE_UNUSED
)
6330 unsigned char *start
= section
->start
;
6332 uint32_t cu_list_offset
, tu_list_offset
;
6333 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6334 unsigned int cu_list_elements
, tu_list_elements
;
6335 unsigned int address_table_size
, symbol_table_slots
;
6336 unsigned char *cu_list
, *tu_list
;
6337 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6340 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6342 printf (_("Contents of the %s section:\n"), section
->name
);
6344 if (section
->size
< 6 * sizeof (uint32_t))
6346 warn (_("Truncated header in the %s section.\n"), section
->name
);
6350 version
= byte_get_little_endian (start
, 4);
6351 printf (_("Version %ld\n"), (long) version
);
6353 /* Prior versions are obsolete, and future versions may not be
6354 backwards compatible. */
6355 if (version
< 3 || version
> 8)
6357 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6361 warn (_("The address table data in version 3 may be wrong.\n"));
6363 warn (_("Version 4 does not support case insensitive lookups.\n"));
6365 warn (_("Version 5 does not include inlined functions.\n"));
6367 warn (_("Version 6 does not include symbol attributes.\n"));
6368 /* Version 7 indices generated by Gold have bad type unit references,
6369 PR binutils/15021. But we don't know if the index was generated by
6370 Gold or not, so to avoid worrying users with gdb-generated indices
6371 we say nothing for version 7 here. */
6373 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6374 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6375 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6376 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6377 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6379 if (cu_list_offset
> section
->size
6380 || tu_list_offset
> section
->size
6381 || address_table_offset
> section
->size
6382 || symbol_table_offset
> section
->size
6383 || constant_pool_offset
> section
->size
)
6385 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6389 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6390 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6391 address_table_size
= symbol_table_offset
- address_table_offset
;
6392 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6394 cu_list
= start
+ cu_list_offset
;
6395 tu_list
= start
+ tu_list_offset
;
6396 address_table
= start
+ address_table_offset
;
6397 symbol_table
= start
+ symbol_table_offset
;
6398 constant_pool
= start
+ constant_pool_offset
;
6400 printf (_("\nCU table:\n"));
6401 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6403 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6404 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6406 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6407 (unsigned long) cu_offset
,
6408 (unsigned long) (cu_offset
+ cu_length
- 1));
6411 printf (_("\nTU table:\n"));
6412 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6414 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6415 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6416 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6418 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6419 (unsigned long) tu_offset
,
6420 (unsigned long) type_offset
);
6421 print_dwarf_vma (signature
, 8);
6425 printf (_("\nAddress table:\n"));
6426 for (i
= 0; i
< address_table_size
; i
+= 2 * 8 + 4)
6428 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6429 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6430 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6432 print_dwarf_vma (low
, 8);
6433 print_dwarf_vma (high
, 8);
6434 printf (_("%lu\n"), (unsigned long) cu_index
);
6437 printf (_("\nSymbol table:\n"));
6438 for (i
= 0; i
< symbol_table_slots
; ++i
)
6440 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6441 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6442 uint32_t num_cus
, cu
;
6444 if (name_offset
!= 0
6445 || cu_vector_offset
!= 0)
6449 printf ("[%3u] %s:", i
, constant_pool
+ name_offset
);
6450 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
6453 for (j
= 0; j
< num_cus
; ++j
)
6456 gdb_index_symbol_kind kind
;
6458 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6459 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6460 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6461 cu
= GDB_INDEX_CU_VALUE (cu
);
6462 /* Convert to TU number if it's for a type unit. */
6463 if (cu
>= cu_list_elements
/ 2)
6464 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6465 (unsigned long) (cu
- cu_list_elements
/ 2));
6467 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6469 printf (" [%s, %s]",
6470 is_static
? _("static") : _("global"),
6471 get_gdb_index_symbol_kind_name (kind
));
6483 /* Pre-allocate enough space for the CU/TU sets needed. */
6486 prealloc_cu_tu_list (unsigned int nshndx
)
6488 if (shndx_pool
== NULL
)
6490 shndx_pool_size
= nshndx
;
6491 shndx_pool_used
= 0;
6492 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6493 sizeof (unsigned int));
6497 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6498 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6499 sizeof (unsigned int));
6504 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6506 if (shndx_pool_used
>= shndx_pool_size
)
6508 error (_("Internal error: out of space in the shndx pool.\n"));
6511 shndx_pool
[shndx_pool_used
++] = shndx
;
6515 end_cu_tu_entry (void)
6517 if (shndx_pool_used
>= shndx_pool_size
)
6519 error (_("Internal error: out of space in the shndx pool.\n"));
6522 shndx_pool
[shndx_pool_used
++] = 0;
6525 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6528 get_DW_SECT_short_name (unsigned int dw_sect
)
6530 static char buf
[16];
6538 case DW_SECT_ABBREV
:
6544 case DW_SECT_STR_OFFSETS
:
6546 case DW_SECT_MACINFO
:
6554 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6558 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6559 These sections are extensions for Fission.
6560 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6563 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6565 unsigned char *phdr
= section
->start
;
6566 unsigned char *limit
= phdr
+ section
->size
;
6567 unsigned char *phash
;
6568 unsigned char *pindex
;
6569 unsigned char *ppool
;
6570 unsigned int version
;
6571 unsigned int ncols
= 0;
6573 unsigned int nslots
;
6576 dwarf_vma signature_high
;
6577 dwarf_vma signature_low
;
6580 /* PR 17512: file: 002-168123-0.004. */
6583 warn (_("Section %s is empty\n"), section
->name
);
6586 /* PR 17512: file: 002-376-0.004. */
6587 if (section
->size
< 24)
6589 warn (_("Section %s is too small to contain a CU/TU header"),
6594 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
6596 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
6597 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
6598 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
6601 pindex
= phash
+ nslots
* 8;
6602 ppool
= pindex
+ nslots
* 4;
6606 printf (_("Contents of the %s section:\n\n"), section
->name
);
6607 printf (_(" Version: %d\n"), version
);
6609 printf (_(" Number of columns: %d\n"), ncols
);
6610 printf (_(" Number of used entries: %d\n"), nused
);
6611 printf (_(" Number of slots: %d\n\n"), nslots
);
6616 warn (_("Section %s too small for %d hash table entries\n"),
6617 section
->name
, nslots
);
6624 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6625 for (i
= 0; i
< nslots
; i
++)
6627 unsigned char *shndx_list
;
6630 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
6631 if (signature_high
!= 0 || signature_low
!= 0)
6633 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
6634 shndx_list
= ppool
+ j
* 4;
6636 printf (_(" [%3d] Signature: 0x%s Sections: "),
6637 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6638 buf
, sizeof (buf
)));
6641 if (shndx_list
>= limit
)
6643 warn (_("Section %s too small for shndx pool\n"),
6647 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
6651 printf (" %d", shndx
);
6653 add_shndx_to_cu_tu_entry (shndx
);
6665 else if (version
== 2)
6668 unsigned int dw_sect
;
6669 unsigned char *ph
= phash
;
6670 unsigned char *pi
= pindex
;
6671 unsigned char *poffsets
= ppool
+ ncols
* 4;
6672 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
6673 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
6674 bfd_boolean is_tu_index
;
6675 struct cu_tu_set
*this_set
= NULL
;
6677 unsigned char *prow
;
6679 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
6683 warn (_("Section %s too small for offset and size tables\n"),
6690 printf (_(" Offset table\n"));
6691 printf (" slot %-16s ",
6692 is_tu_index
? _("signature") : _("dwo_id"));
6699 tu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6705 cu_sets
= xcmalloc (nused
, sizeof (struct cu_tu_set
));
6712 for (j
= 0; j
< ncols
; j
++)
6714 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6715 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
6720 for (i
= 0; i
< nslots
; i
++)
6722 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
6724 SAFE_BYTE_GET (row
, pi
, 4, limit
);
6728 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
6730 prow
= poffsets
+ (row
- 1) * ncols
* 4;
6733 printf (_(" [%3d] 0x%s"),
6734 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6735 buf
, sizeof (buf
)));
6736 for (j
= 0; j
< ncols
; j
++)
6738 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
6740 printf (" %8d", val
);
6743 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6744 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
6760 printf (_(" Size table\n"));
6761 printf (" slot %-16s ",
6762 is_tu_index
? _("signature") : _("dwo_id"));
6765 for (j
= 0; j
< ncols
; j
++)
6767 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
6769 printf (" %8s", get_DW_SECT_short_name (val
));
6775 for (i
= 0; i
< nslots
; i
++)
6777 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
6779 SAFE_BYTE_GET (row
, pi
, 4, limit
);
6782 prow
= psizes
+ (row
- 1) * ncols
* 4;
6785 printf (_(" [%3d] 0x%s"),
6786 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6787 buf
, sizeof (buf
)));
6789 for (j
= 0; j
< ncols
; j
++)
6791 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
6793 printf (" %8d", val
);
6796 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
6797 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
6809 else if (do_display
)
6810 printf (_(" Unsupported version (%d)\n"), version
);
6818 /* Load the CU and TU indexes if present. This will build a list of
6819 section sets that we can use to associate a .debug_info.dwo section
6820 with its associated .debug_abbrev.dwo section in a .dwp file. */
6823 load_cu_tu_indexes (void *file
)
6825 /* If we have already loaded (or tried to load) the CU and TU indexes
6826 then do not bother to repeat the task. */
6827 if (cu_tu_indexes_read
)
6830 if (load_debug_section (dwp_cu_index
, file
))
6831 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
6833 if (load_debug_section (dwp_tu_index
, file
))
6834 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
6836 cu_tu_indexes_read
= 1;
6839 /* Find the set of sections that includes section SHNDX. */
6842 find_cu_tu_set (void *file
, unsigned int shndx
)
6846 load_cu_tu_indexes (file
);
6848 /* Find SHNDX in the shndx pool. */
6849 for (i
= 0; i
< shndx_pool_used
; i
++)
6850 if (shndx_pool
[i
] == shndx
)
6853 if (i
>= shndx_pool_used
)
6856 /* Now backup to find the first entry in the set. */
6857 while (i
> 0 && shndx_pool
[i
- 1] != 0)
6860 return shndx_pool
+ i
;
6863 /* Display a .debug_cu_index or .debug_tu_index section. */
6866 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
6868 return process_cu_tu_index (section
, 1);
6872 display_debug_not_supported (struct dwarf_section
*section
,
6873 void *file ATTRIBUTE_UNUSED
)
6875 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6882 cmalloc (size_t nmemb
, size_t size
)
6884 /* Check for overflow. */
6885 if (nmemb
>= ~(size_t) 0 / size
)
6888 return malloc (nmemb
* size
);
6892 xcmalloc (size_t nmemb
, size_t size
)
6894 /* Check for overflow. */
6895 if (nmemb
>= ~(size_t) 0 / size
)
6898 return xmalloc (nmemb
* size
);
6902 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
6904 /* Check for overflow. */
6905 if (nmemb
>= ~(size_t) 0 / size
)
6908 return xrealloc (ptr
, nmemb
* size
);
6912 free_debug_memory (void)
6918 for (i
= 0; i
< max
; i
++)
6919 free_debug_section ((enum dwarf_section_display_enum
) i
);
6921 if (debug_information
!= NULL
)
6923 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
6925 for (i
= 0; i
< num_debug_info_entries
; i
++)
6927 if (!debug_information
[i
].max_loc_offsets
)
6929 free (debug_information
[i
].loc_offsets
);
6930 free (debug_information
[i
].have_frame_base
);
6932 if (!debug_information
[i
].max_range_lists
)
6933 free (debug_information
[i
].range_lists
);
6937 free (debug_information
);
6938 debug_information
= NULL
;
6939 num_debug_info_entries
= 0;
6944 dwarf_select_sections_by_names (const char *names
)
6948 const char * option
;
6952 debug_dump_long_opts
;
6954 static const debug_dump_long_opts opts_table
[] =
6956 /* Please keep this table alpha- sorted. */
6957 { "Ranges", & do_debug_ranges
, 1 },
6958 { "abbrev", & do_debug_abbrevs
, 1 },
6959 { "addr", & do_debug_addr
, 1 },
6960 { "aranges", & do_debug_aranges
, 1 },
6961 { "cu_index", & do_debug_cu_index
, 1 },
6962 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
6963 { "frames", & do_debug_frames
, 1 },
6964 { "frames-interp", & do_debug_frames_interp
, 1 },
6965 /* The special .gdb_index section. */
6966 { "gdb_index", & do_gdb_index
, 1 },
6967 { "info", & do_debug_info
, 1 },
6968 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
6969 { "loc", & do_debug_loc
, 1 },
6970 { "macro", & do_debug_macinfo
, 1 },
6971 { "pubnames", & do_debug_pubnames
, 1 },
6972 { "pubtypes", & do_debug_pubtypes
, 1 },
6973 /* This entry is for compatability
6974 with earlier versions of readelf. */
6975 { "ranges", & do_debug_aranges
, 1 },
6976 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
6977 { "str", & do_debug_str
, 1 },
6978 /* These trace_* sections are used by Itanium VMS. */
6979 { "trace_abbrev", & do_trace_abbrevs
, 1 },
6980 { "trace_aranges", & do_trace_aranges
, 1 },
6981 { "trace_info", & do_trace_info
, 1 },
6990 const debug_dump_long_opts
* entry
;
6992 for (entry
= opts_table
; entry
->option
; entry
++)
6994 size_t len
= strlen (entry
->option
);
6996 if (strncmp (p
, entry
->option
, len
) == 0
6997 && (p
[len
] == ',' || p
[len
] == '\0'))
6999 * entry
->variable
|= entry
->val
;
7001 /* The --debug-dump=frames-interp option also
7002 enables the --debug-dump=frames option. */
7003 if (do_debug_frames_interp
)
7004 do_debug_frames
= 1;
7011 if (entry
->option
== NULL
)
7013 warn (_("Unrecognized debug option '%s'\n"), p
);
7014 p
= strchr (p
, ',');
7025 dwarf_select_sections_by_letters (const char *letters
)
7027 unsigned int lindex
= 0;
7029 while (letters
[lindex
])
7030 switch (letters
[lindex
++])
7037 do_debug_abbrevs
= 1;
7041 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
7045 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
7049 do_debug_pubnames
= 1;
7053 do_debug_pubtypes
= 1;
7057 do_debug_aranges
= 1;
7061 do_debug_ranges
= 1;
7065 do_debug_frames_interp
= 1;
7067 do_debug_frames
= 1;
7071 do_debug_macinfo
= 1;
7083 warn (_("Unrecognized debug option '%s'\n"), optarg
);
7089 dwarf_select_sections_all (void)
7092 do_debug_abbrevs
= 1;
7093 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
7094 do_debug_pubnames
= 1;
7095 do_debug_pubtypes
= 1;
7096 do_debug_aranges
= 1;
7097 do_debug_ranges
= 1;
7098 do_debug_frames
= 1;
7099 do_debug_macinfo
= 1;
7104 do_trace_abbrevs
= 1;
7105 do_trace_aranges
= 1;
7107 do_debug_cu_index
= 1;
7110 struct dwarf_section_display debug_displays
[] =
7112 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0 },
7113 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7114 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0 },
7115 display_debug_aranges
, &do_debug_aranges
, 1 },
7116 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0 },
7117 display_debug_frames
, &do_debug_frames
, 1 },
7118 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
},
7119 display_debug_info
, &do_debug_info
, 1 },
7120 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0 },
7121 display_debug_lines
, &do_debug_lines
, 1 },
7122 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0 },
7123 display_debug_pubnames
, &do_debug_pubnames
, 0 },
7124 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0 },
7125 display_debug_gnu_pubnames
, &do_debug_pubnames
, 0 },
7126 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0 },
7127 display_debug_frames
, &do_debug_frames
, 1 },
7128 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0 },
7129 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7130 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0 },
7131 display_debug_macro
, &do_debug_macinfo
, 1 },
7132 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0 },
7133 display_debug_str
, &do_debug_str
, 0 },
7134 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0 },
7135 display_debug_loc
, &do_debug_loc
, 1 },
7136 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0 },
7137 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
7138 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0 },
7139 display_debug_gnu_pubnames
, &do_debug_pubtypes
, 0 },
7140 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0 },
7141 display_debug_ranges
, &do_debug_ranges
, 1 },
7142 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0 },
7143 display_debug_not_supported
, NULL
, 0 },
7144 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0 },
7145 display_debug_not_supported
, NULL
, 0 },
7146 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
},
7147 display_debug_types
, &do_debug_info
, 1 },
7148 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0 },
7149 display_debug_not_supported
, NULL
, 0 },
7150 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0 },
7151 display_gdb_index
, &do_gdb_index
, 0 },
7152 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
},
7153 display_trace_info
, &do_trace_info
, 1 },
7154 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0 },
7155 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
7156 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0 },
7157 display_debug_aranges
, &do_trace_aranges
, 0 },
7158 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
7159 display_debug_info
, &do_debug_info
, 1 },
7160 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0 },
7161 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7162 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
},
7163 display_debug_types
, &do_debug_info
, 1 },
7164 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0 },
7165 display_debug_lines
, &do_debug_lines
, 1 },
7166 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0 },
7167 display_debug_loc
, &do_debug_loc
, 1 },
7168 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0 },
7169 display_debug_macro
, &do_debug_macinfo
, 1 },
7170 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0 },
7171 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7172 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0 },
7173 display_debug_str
, &do_debug_str
, 1 },
7174 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0 },
7175 display_debug_str_offsets
, NULL
, 0 },
7176 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0 },
7177 display_debug_str_offsets
, NULL
, 0 },
7178 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0 },
7179 display_debug_addr
, &do_debug_addr
, 1 },
7180 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0 },
7181 display_cu_index
, &do_debug_cu_index
, 0 },
7182 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0 },
7183 display_cu_index
, &do_debug_cu_index
, 0 },