1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2015 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 unsigned int alloc_num_debug_info_entries
= 0;
42 static debug_info
*debug_information
= NULL
;
43 /* Special value for num_debug_info_entries to indicate
44 that the .debug_info section could not be loaded/parsed. */
45 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
47 unsigned int eh_addr_size
;
52 int do_debug_pubnames
;
53 int do_debug_pubtypes
;
57 int do_debug_frames_interp
;
66 int do_debug_cu_index
;
69 int dwarf_cutoff_level
= -1;
70 unsigned long dwarf_start_die
;
74 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
75 sections. For version 1 package files, each set is stored in SHNDX_POOL
76 as a zero-terminated list of section indexes comprising one set of debug
77 sections from a .dwo file. */
79 static int cu_tu_indexes_read
= 0;
80 static unsigned int *shndx_pool
= NULL
;
81 static unsigned int shndx_pool_size
= 0;
82 static unsigned int shndx_pool_used
= 0;
84 /* For version 2 package files, each set contains an array of section offsets
85 and an array of section sizes, giving the offset and size of the
86 contribution from a CU or TU within one of the debug sections.
87 When displaying debug info from a package file, we need to use these
88 tables to locate the corresponding contributions to each section. */
93 dwarf_vma section_offsets
[DW_SECT_MAX
];
94 size_t section_sizes
[DW_SECT_MAX
];
97 static int cu_count
= 0;
98 static int tu_count
= 0;
99 static struct cu_tu_set
*cu_sets
= NULL
;
100 static struct cu_tu_set
*tu_sets
= NULL
;
102 static void load_cu_tu_indexes (void *file
);
104 /* Values for do_debug_lines. */
105 #define FLAG_DEBUG_LINES_RAW 1
106 #define FLAG_DEBUG_LINES_DECODED 2
109 size_of_encoded_value (int encoding
)
111 switch (encoding
& 0x7)
114 case 0: return eh_addr_size
;
122 get_encoded_value (unsigned char **pdata
,
124 struct dwarf_section
*section
,
127 unsigned char * data
= * pdata
;
128 unsigned int size
= size_of_encoded_value (encoding
);
131 if (data
+ size
>= end
)
133 warn (_("Encoded value extends past end of section\n"));
138 /* PR 17512: file: 002-829853-0.004. */
141 warn (_("Encoded size of %d is too large to read\n"), size
);
146 /* PR 17512: file: 1085-5603-0.004. */
149 warn (_("Encoded size of 0 is too small to read\n"));
154 if (encoding
& DW_EH_PE_signed
)
155 val
= byte_get_signed (data
, size
);
157 val
= byte_get (data
, size
);
159 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
160 val
+= section
->address
+ (data
- section
->start
);
162 * pdata
= data
+ size
;
166 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
168 # define DWARF_VMA_FMT "ll"
169 # define DWARF_VMA_FMT_LONG "%16.16llx"
171 # define DWARF_VMA_FMT "I64"
172 # define DWARF_VMA_FMT_LONG "%016I64x"
175 # define DWARF_VMA_FMT "l"
176 # define DWARF_VMA_FMT_LONG "%16.16lx"
179 /* Convert a dwarf vma value into a string. Returns a pointer to a static
180 buffer containing the converted VALUE. The value is converted according
181 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
182 it specifies the maximum number of bytes to be displayed in the converted
183 value and FMTCH is ignored - hex is always used. */
186 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
188 /* As dwarf_vmatoa is used more then once in a printf call
189 for output, we are cycling through an fixed array of pointers
190 for return address. */
191 static int buf_pos
= 0;
192 static struct dwarf_vmatoa_buf
198 ret
= buf
[buf_pos
++].place
;
199 buf_pos
%= ARRAY_SIZE (buf
);
203 /* Printf does not have a way of specifiying a maximum field width for an
204 integer value, so we print the full value into a buffer and then select
205 the precision we need. */
206 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
209 return ret
+ (16 - 2 * num_bytes
);
215 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
216 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
221 static inline const char *
222 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
224 return dwarf_vmatoa_1 (fmtch
, value
, 0);
227 /* Print a dwarf_vma value (typically an address, offset or length) in
228 hexadecimal format, followed by a space. The length of the VALUE (and
229 hence the precision displayed) is determined by the NUM_BYTES parameter. */
232 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
234 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
237 /* Format a 64-bit value, given as two 32-bit values, in hex.
238 For reentrancy, this uses a buffer provided by the caller. */
241 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
242 unsigned int buf_len
)
247 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
250 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
251 snprintf (buf
+ len
, buf_len
- len
,
252 "%08" DWARF_VMA_FMT
"x", lvalue
);
258 /* Read in a LEB128 encoded value starting at address DATA.
259 If SIGN is true, return a signed LEB128 value.
260 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
261 No bytes will be read at address END or beyond. */
264 read_leb128 (unsigned char *data
,
265 unsigned int *length_return
,
267 const unsigned char * const end
)
269 dwarf_vma result
= 0;
270 unsigned int num_read
= 0;
271 unsigned int shift
= 0;
272 unsigned char byte
= 0;
279 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
282 if ((byte
& 0x80) == 0)
285 /* PR 17512: file: 0ca183b8.
286 FIXME: Should we signal this error somehow ? */
287 if (shift
>= sizeof (result
))
291 if (length_return
!= NULL
)
292 *length_return
= num_read
;
294 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
295 result
|= (dwarf_vma
) -1 << shift
;
300 /* Create a signed version to avoid painful typecasts. */
301 static inline dwarf_signed_vma
302 read_sleb128 (unsigned char * data
,
303 unsigned int * length_return
,
304 const unsigned char * const end
)
306 return (dwarf_signed_vma
) read_leb128 (data
, length_return
, TRUE
, end
);
309 static inline dwarf_vma
310 read_uleb128 (unsigned char * data
,
311 unsigned int * length_return
,
312 const unsigned char * const end
)
314 return read_leb128 (data
, length_return
, FALSE
, end
);
317 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
320 int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \
321 unsigned int amount = (AMOUNT); \
322 if (((PTR) + amount) >= (END)) \
325 amount = (END) - (PTR); \
329 if (amount == 0 || amount > 8) \
332 VAL = byte_get ((PTR), amount); \
336 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
339 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
344 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
347 unsigned int amount = (AMOUNT); \
348 if (((PTR) + amount) >= (END)) \
351 amount = (END) - (PTR); \
356 VAL = byte_get_signed ((PTR), amount); \
362 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
365 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
370 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
373 if (((PTR) + 8) <= (END)) \
375 byte_get_64 ((PTR), (HIGH), (LOW)); \
379 * (LOW) = * (HIGH) = 0; \
384 typedef struct State_Machine_Registers
392 unsigned char op_index
;
393 unsigned char end_sequence
;
394 /* This variable hold the number of the last entry seen
395 in the File Table. */
396 unsigned int last_file_entry
;
399 static SMR state_machine_regs
;
402 reset_state_machine (int is_stmt
)
404 state_machine_regs
.address
= 0;
405 state_machine_regs
.op_index
= 0;
406 state_machine_regs
.file
= 1;
407 state_machine_regs
.line
= 1;
408 state_machine_regs
.column
= 0;
409 state_machine_regs
.is_stmt
= is_stmt
;
410 state_machine_regs
.basic_block
= 0;
411 state_machine_regs
.end_sequence
= 0;
412 state_machine_regs
.last_file_entry
= 0;
415 /* Handled an extend line op.
416 Returns the number of bytes read. */
419 process_extended_line_op (unsigned char * data
,
423 unsigned char op_code
;
424 unsigned int bytes_read
;
427 unsigned char *orig_data
= data
;
430 len
= read_uleb128 (data
, & bytes_read
, end
);
433 if (len
== 0 || data
== end
|| len
> (uintptr_t) (end
- data
))
435 warn (_("Badly formed extended line op encountered!\n"));
442 printf (_(" Extended opcode %d: "), op_code
);
446 case DW_LNE_end_sequence
:
447 printf (_("End of Sequence\n\n"));
448 reset_state_machine (is_stmt
);
451 case DW_LNE_set_address
:
452 /* PR 17512: file: 002-100480-0.004. */
453 if (len
- bytes_read
- 1 > 8)
455 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
456 len
- bytes_read
- 1);
460 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
461 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
462 state_machine_regs
.address
= adr
;
463 state_machine_regs
.op_index
= 0;
466 case DW_LNE_define_file
:
467 printf (_("define new File Table entry\n"));
468 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
469 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
472 data
+= strnlen ((char *) data
, end
- data
) + 1;
473 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
475 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
477 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
479 printf ("%s\n\n", name
);
481 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
482 warn (_("DW_LNE_define_file: Bad opcode length\n"));
485 case DW_LNE_set_discriminator
:
486 printf (_("set Discriminator to %s\n"),
487 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
491 case DW_LNE_HP_negate_is_UV_update
:
492 printf ("DW_LNE_HP_negate_is_UV_update\n");
494 case DW_LNE_HP_push_context
:
495 printf ("DW_LNE_HP_push_context\n");
497 case DW_LNE_HP_pop_context
:
498 printf ("DW_LNE_HP_pop_context\n");
500 case DW_LNE_HP_set_file_line_column
:
501 printf ("DW_LNE_HP_set_file_line_column\n");
503 case DW_LNE_HP_set_routine_name
:
504 printf ("DW_LNE_HP_set_routine_name\n");
506 case DW_LNE_HP_set_sequence
:
507 printf ("DW_LNE_HP_set_sequence\n");
509 case DW_LNE_HP_negate_post_semantics
:
510 printf ("DW_LNE_HP_negate_post_semantics\n");
512 case DW_LNE_HP_negate_function_exit
:
513 printf ("DW_LNE_HP_negate_function_exit\n");
515 case DW_LNE_HP_negate_front_end_logical
:
516 printf ("DW_LNE_HP_negate_front_end_logical\n");
518 case DW_LNE_HP_define_proc
:
519 printf ("DW_LNE_HP_define_proc\n");
521 case DW_LNE_HP_source_file_correlation
:
523 unsigned char *edata
= data
+ len
- bytes_read
- 1;
525 printf ("DW_LNE_HP_source_file_correlation\n");
531 opc
= read_uleb128 (data
, & bytes_read
, edata
);
536 case DW_LNE_HP_SFC_formfeed
:
537 printf (" DW_LNE_HP_SFC_formfeed\n");
539 case DW_LNE_HP_SFC_set_listing_line
:
540 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
542 read_uleb128 (data
, & bytes_read
, edata
)));
545 case DW_LNE_HP_SFC_associate
:
546 printf (" DW_LNE_HP_SFC_associate ");
549 read_uleb128 (data
, & bytes_read
, edata
)));
553 read_uleb128 (data
, & bytes_read
, edata
)));
557 read_uleb128 (data
, & bytes_read
, edata
)));
561 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
571 unsigned int rlen
= len
- bytes_read
- 1;
573 if (op_code
>= DW_LNE_lo_user
574 /* The test against DW_LNW_hi_user is redundant due to
575 the limited range of the unsigned char data type used
577 /*&& op_code <= DW_LNE_hi_user*/)
578 printf (_("user defined: "));
580 printf (_("UNKNOWN: "));
581 printf (_("length %d ["), rlen
);
583 printf (" %02x", *data
++);
592 static const unsigned char *
593 fetch_indirect_string (dwarf_vma offset
)
595 struct dwarf_section
*section
= &debug_displays
[str
].section
;
597 if (section
->start
== NULL
)
598 return (const unsigned char *) _("<no .debug_str section>");
600 if (offset
> section
->size
)
602 warn (_("DW_FORM_strp offset too big: %s\n"),
603 dwarf_vmatoa ("x", offset
));
604 return (const unsigned char *) _("<offset is too big>");
607 return (const unsigned char *) section
->start
+ offset
;
611 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
612 dwarf_vma offset_size
, int dwo
)
614 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
615 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
616 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
617 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
618 dwarf_vma index_offset
= idx
* offset_size
;
619 dwarf_vma str_offset
;
621 if (index_section
->start
== NULL
)
622 return (dwo
? _("<no .debug_str_offsets.dwo section>")
623 : _("<no .debug_str_offsets section>"));
625 if (this_set
!= NULL
)
626 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
627 if (index_offset
> index_section
->size
)
629 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
630 dwarf_vmatoa ("x", index_offset
));
631 return _("<index offset is too big>");
634 if (str_section
->start
== NULL
)
635 return (dwo
? _("<no .debug_str.dwo section>")
636 : _("<no .debug_str section>"));
638 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
639 str_offset
-= str_section
->address
;
640 if (str_offset
> str_section
->size
)
642 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
643 dwarf_vmatoa ("x", str_offset
));
644 return _("<indirect index offset is too big>");
647 return (const char *) str_section
->start
+ str_offset
;
651 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
653 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
655 if (section
->start
== NULL
)
656 return (_("<no .debug_addr section>"));
658 if (offset
+ bytes
> section
->size
)
660 warn (_("Offset into section %s too big: %s\n"),
661 section
->name
, dwarf_vmatoa ("x", offset
));
662 return "<offset too big>";
665 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
669 /* FIXME: There are better and more efficient ways to handle
670 these structures. For now though, I just want something that
671 is simple to implement. */
672 typedef struct abbrev_attr
674 unsigned long attribute
;
676 struct abbrev_attr
*next
;
680 typedef struct abbrev_entry
685 struct abbrev_attr
*first_attr
;
686 struct abbrev_attr
*last_attr
;
687 struct abbrev_entry
*next
;
691 static abbrev_entry
*first_abbrev
= NULL
;
692 static abbrev_entry
*last_abbrev
= NULL
;
699 for (abbrv
= first_abbrev
; abbrv
;)
701 abbrev_entry
*next_abbrev
= abbrv
->next
;
704 for (attr
= abbrv
->first_attr
; attr
;)
706 abbrev_attr
*next_attr
= attr
->next
;
716 last_abbrev
= first_abbrev
= NULL
;
720 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
724 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
729 entry
->entry
= number
;
731 entry
->children
= children
;
732 entry
->first_attr
= NULL
;
733 entry
->last_attr
= NULL
;
736 if (first_abbrev
== NULL
)
737 first_abbrev
= entry
;
739 last_abbrev
->next
= entry
;
745 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
749 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
754 attr
->attribute
= attribute
;
758 if (last_abbrev
->first_attr
== NULL
)
759 last_abbrev
->first_attr
= attr
;
761 last_abbrev
->last_attr
->next
= attr
;
763 last_abbrev
->last_attr
= attr
;
766 /* Processes the (partial) contents of a .debug_abbrev section.
767 Returns NULL if the end of the section was encountered.
768 Returns the address after the last byte read if the end of
769 an abbreviation set was found. */
771 static unsigned char *
772 process_abbrev_section (unsigned char *start
, unsigned char *end
)
774 if (first_abbrev
!= NULL
)
779 unsigned int bytes_read
;
782 unsigned long attribute
;
785 entry
= read_uleb128 (start
, & bytes_read
, end
);
788 /* A single zero is supposed to end the section according
789 to the standard. If there's more, then signal that to
796 tag
= read_uleb128 (start
, & bytes_read
, end
);
803 add_abbrev (entry
, tag
, children
);
809 attribute
= read_uleb128 (start
, & bytes_read
, end
);
814 form
= read_uleb128 (start
, & bytes_read
, end
);
819 add_abbrev_attr (attribute
, form
);
821 while (attribute
!= 0);
824 /* Report the missing single zero which ends the section. */
825 error (_(".debug_abbrev section not zero terminated\n"));
831 get_TAG_name (unsigned long tag
)
833 const char *name
= get_DW_TAG_name ((unsigned int)tag
);
837 static char buffer
[100];
839 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
847 get_FORM_name (unsigned long form
)
852 return "DW_FORM value: 0";
854 name
= get_DW_FORM_name (form
);
857 static char buffer
[100];
859 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
866 static unsigned char *
867 display_block (unsigned char *data
,
869 const unsigned char * const end
)
873 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length
));
875 return (unsigned char *) end
;
877 maxlen
= (dwarf_vma
) (end
- data
);
878 length
= length
> maxlen
? maxlen
: length
;
881 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
887 decode_location_expression (unsigned char * data
,
888 unsigned int pointer_size
,
889 unsigned int offset_size
,
893 struct dwarf_section
* section
)
896 unsigned int bytes_read
;
898 dwarf_signed_vma svalue
;
899 unsigned char *end
= data
+ length
;
900 int need_frame_base
= 0;
909 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
910 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
913 printf ("DW_OP_deref");
916 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
917 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
920 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
921 printf ("DW_OP_const1s: %ld", (long) svalue
);
924 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
925 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
928 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
929 printf ("DW_OP_const2s: %ld", (long) svalue
);
932 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
933 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
936 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
937 printf ("DW_OP_const4s: %ld", (long) svalue
);
940 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
941 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
942 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
943 printf ("%lu", (unsigned long) uvalue
);
946 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
947 printf ("DW_OP_const8s: %ld ", (long) svalue
);
948 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
949 printf ("%ld", (long) svalue
);
952 printf ("DW_OP_constu: %s",
953 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
957 printf ("DW_OP_consts: %s",
958 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
962 printf ("DW_OP_dup");
965 printf ("DW_OP_drop");
968 printf ("DW_OP_over");
971 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
972 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
975 printf ("DW_OP_swap");
978 printf ("DW_OP_rot");
981 printf ("DW_OP_xderef");
984 printf ("DW_OP_abs");
987 printf ("DW_OP_and");
990 printf ("DW_OP_div");
993 printf ("DW_OP_minus");
996 printf ("DW_OP_mod");
999 printf ("DW_OP_mul");
1002 printf ("DW_OP_neg");
1005 printf ("DW_OP_not");
1008 printf ("DW_OP_or");
1011 printf ("DW_OP_plus");
1013 case DW_OP_plus_uconst
:
1014 printf ("DW_OP_plus_uconst: %s",
1015 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1019 printf ("DW_OP_shl");
1022 printf ("DW_OP_shr");
1025 printf ("DW_OP_shra");
1028 printf ("DW_OP_xor");
1031 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1032 printf ("DW_OP_bra: %ld", (long) svalue
);
1035 printf ("DW_OP_eq");
1038 printf ("DW_OP_ge");
1041 printf ("DW_OP_gt");
1044 printf ("DW_OP_le");
1047 printf ("DW_OP_lt");
1050 printf ("DW_OP_ne");
1053 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1054 printf ("DW_OP_skip: %ld", (long) svalue
);
1089 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1124 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1125 regname (op
- DW_OP_reg0
, 1));
1160 printf ("DW_OP_breg%d (%s): %s",
1162 regname (op
- DW_OP_breg0
, 1),
1163 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1168 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1170 printf ("DW_OP_regx: %s (%s)",
1171 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1174 need_frame_base
= 1;
1175 printf ("DW_OP_fbreg: %s",
1176 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1180 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1182 printf ("DW_OP_bregx: %s (%s) %s",
1183 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1184 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1188 printf ("DW_OP_piece: %s",
1189 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1192 case DW_OP_deref_size
:
1193 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1194 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1196 case DW_OP_xderef_size
:
1197 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1198 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1201 printf ("DW_OP_nop");
1204 /* DWARF 3 extensions. */
1205 case DW_OP_push_object_address
:
1206 printf ("DW_OP_push_object_address");
1209 /* XXX: Strictly speaking for 64-bit DWARF3 files
1210 this ought to be an 8-byte wide computation. */
1211 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1212 printf ("DW_OP_call2: <0x%s>",
1213 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1216 /* XXX: Strictly speaking for 64-bit DWARF3 files
1217 this ought to be an 8-byte wide computation. */
1218 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1219 printf ("DW_OP_call4: <0x%s>",
1220 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1222 case DW_OP_call_ref
:
1223 /* XXX: Strictly speaking for 64-bit DWARF3 files
1224 this ought to be an 8-byte wide computation. */
1225 if (dwarf_version
== -1)
1227 printf (_("(DW_OP_call_ref in frame info)"));
1228 /* No way to tell where the next op is, so just bail. */
1229 return need_frame_base
;
1231 if (dwarf_version
== 2)
1233 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1237 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1239 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1241 case DW_OP_form_tls_address
:
1242 printf ("DW_OP_form_tls_address");
1244 case DW_OP_call_frame_cfa
:
1245 printf ("DW_OP_call_frame_cfa");
1247 case DW_OP_bit_piece
:
1248 printf ("DW_OP_bit_piece: ");
1249 printf (_("size: %s "),
1250 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1252 printf (_("offset: %s "),
1253 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1257 /* DWARF 4 extensions. */
1258 case DW_OP_stack_value
:
1259 printf ("DW_OP_stack_value");
1262 case DW_OP_implicit_value
:
1263 printf ("DW_OP_implicit_value");
1264 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1266 data
= display_block (data
, uvalue
, end
);
1269 /* GNU extensions. */
1270 case DW_OP_GNU_push_tls_address
:
1271 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1273 case DW_OP_GNU_uninit
:
1274 printf ("DW_OP_GNU_uninit");
1275 /* FIXME: Is there data associated with this OP ? */
1277 case DW_OP_GNU_encoded_addr
:
1284 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1286 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1287 print_dwarf_vma (addr
, pointer_size
);
1290 case DW_OP_GNU_implicit_pointer
:
1291 /* XXX: Strictly speaking for 64-bit DWARF3 files
1292 this ought to be an 8-byte wide computation. */
1293 if (dwarf_version
== -1)
1295 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1296 /* No way to tell where the next op is, so just bail. */
1297 return need_frame_base
;
1299 if (dwarf_version
== 2)
1301 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1305 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1307 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1308 dwarf_vmatoa ("x", uvalue
),
1309 dwarf_vmatoa ("d", read_sleb128 (data
,
1310 &bytes_read
, end
)));
1313 case DW_OP_GNU_entry_value
:
1314 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1316 /* PR 17531: file: 0cc9cd00. */
1317 if (uvalue
> (dwarf_vma
) (end
- data
))
1318 uvalue
= end
- data
;
1319 printf ("DW_OP_GNU_entry_value: (");
1320 if (decode_location_expression (data
, pointer_size
, offset_size
,
1321 dwarf_version
, uvalue
,
1322 cu_offset
, section
))
1323 need_frame_base
= 1;
1329 case DW_OP_GNU_const_type
:
1330 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1332 printf ("DW_OP_GNU_const_type: <0x%s> ",
1333 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1334 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1335 data
= display_block (data
, uvalue
, end
);
1337 case DW_OP_GNU_regval_type
:
1338 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1340 printf ("DW_OP_GNU_regval_type: %s (%s)",
1341 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1342 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1344 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1346 case DW_OP_GNU_deref_type
:
1347 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1348 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue
);
1349 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1351 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1353 case DW_OP_GNU_convert
:
1354 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1356 printf ("DW_OP_GNU_convert <0x%s>",
1357 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1359 case DW_OP_GNU_reinterpret
:
1360 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1362 printf ("DW_OP_GNU_reinterpret <0x%s>",
1363 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1365 case DW_OP_GNU_parameter_ref
:
1366 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1367 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1368 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1370 case DW_OP_GNU_addr_index
:
1371 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1373 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1375 case DW_OP_GNU_const_index
:
1376 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1378 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1381 /* HP extensions. */
1382 case DW_OP_HP_is_value
:
1383 printf ("DW_OP_HP_is_value");
1384 /* FIXME: Is there data associated with this OP ? */
1386 case DW_OP_HP_fltconst4
:
1387 printf ("DW_OP_HP_fltconst4");
1388 /* FIXME: Is there data associated with this OP ? */
1390 case DW_OP_HP_fltconst8
:
1391 printf ("DW_OP_HP_fltconst8");
1392 /* FIXME: Is there data associated with this OP ? */
1394 case DW_OP_HP_mod_range
:
1395 printf ("DW_OP_HP_mod_range");
1396 /* FIXME: Is there data associated with this OP ? */
1398 case DW_OP_HP_unmod_range
:
1399 printf ("DW_OP_HP_unmod_range");
1400 /* FIXME: Is there data associated with this OP ? */
1403 printf ("DW_OP_HP_tls");
1404 /* FIXME: Is there data associated with this OP ? */
1407 /* PGI (STMicroelectronics) extensions. */
1408 case DW_OP_PGI_omp_thread_num
:
1409 /* Pushes the thread number for the current thread as it would be
1410 returned by the standard OpenMP library function:
1411 omp_get_thread_num(). The "current thread" is the thread for
1412 which the expression is being evaluated. */
1413 printf ("DW_OP_PGI_omp_thread_num");
1417 if (op
>= DW_OP_lo_user
1418 && op
<= DW_OP_hi_user
)
1419 printf (_("(User defined location op)"));
1421 printf (_("(Unknown location op)"));
1422 /* No way to tell where the next op is, so just bail. */
1423 return need_frame_base
;
1426 /* Separate the ops. */
1431 return need_frame_base
;
1434 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1435 This is used for DWARF package files. */
1437 static struct cu_tu_set
*
1438 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1440 struct cu_tu_set
*p
;
1442 unsigned int dw_sect
;
1448 dw_sect
= DW_SECT_TYPES
;
1454 dw_sect
= DW_SECT_INFO
;
1458 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1466 /* Add INC to HIGH_BITS:LOW_BITS. */
1468 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1470 dwarf_vma tmp
= * low_bits
;
1474 /* FIXME: There is probably a better way of handling this:
1476 We need to cope with dwarf_vma being a 32-bit or 64-bit
1477 type. Plus regardless of its size LOW_BITS is meant to
1478 only hold 32-bits, so if there is overflow or wrap around
1479 we must propagate into HIGH_BITS. */
1480 if (tmp
< * low_bits
)
1484 else if (sizeof (tmp
) > 8
1494 static unsigned char *
1495 read_and_display_attr_value (unsigned long attribute
,
1497 unsigned char * data
,
1498 unsigned char * end
,
1499 dwarf_vma cu_offset
,
1500 dwarf_vma pointer_size
,
1501 dwarf_vma offset_size
,
1503 debug_info
* debug_info_p
,
1505 struct dwarf_section
* section
,
1506 struct cu_tu_set
* this_set
)
1508 dwarf_vma uvalue
= 0;
1509 unsigned char *block_start
= NULL
;
1510 unsigned char * orig_data
= data
;
1511 unsigned int bytes_read
;
1513 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
1515 warn (_("Corrupt attribute\n"));
1524 case DW_FORM_ref_addr
:
1525 if (dwarf_version
== 2)
1526 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1527 else if (dwarf_version
== 3 || dwarf_version
== 4)
1528 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1530 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1535 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1539 case DW_FORM_sec_offset
:
1540 case DW_FORM_GNU_ref_alt
:
1541 case DW_FORM_GNU_strp_alt
:
1542 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1545 case DW_FORM_flag_present
:
1552 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1557 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1562 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1566 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1570 case DW_FORM_GNU_str_index
:
1571 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1575 case DW_FORM_ref_udata
:
1577 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1581 case DW_FORM_indirect
:
1582 form
= read_uleb128 (data
, & bytes_read
, end
);
1585 printf (" %s", get_FORM_name (form
));
1586 return read_and_display_attr_value (attribute
, form
, data
, end
,
1587 cu_offset
, pointer_size
,
1588 offset_size
, dwarf_version
,
1589 debug_info_p
, do_loc
,
1591 case DW_FORM_GNU_addr_index
:
1592 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1599 case DW_FORM_ref_addr
:
1601 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue
));
1604 case DW_FORM_GNU_ref_alt
:
1606 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue
));
1612 case DW_FORM_ref_udata
:
1614 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1619 case DW_FORM_sec_offset
:
1621 printf (" 0x%s", dwarf_vmatoa ("x", uvalue
));
1624 case DW_FORM_flag_present
:
1631 printf (" %s", dwarf_vmatoa ("d", uvalue
));
1638 dwarf_vma high_bits
;
1642 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1644 if (form
== DW_FORM_ref8
)
1645 add64 (& high_bits
, & utmp
, cu_offset
);
1647 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1650 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1651 && num_debug_info_entries
== 0)
1653 if (sizeof (uvalue
) == 8)
1654 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1656 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1662 case DW_FORM_string
:
1664 printf (" %.*s", (int) (end
- data
), data
);
1665 data
+= strnlen ((char *) data
, end
- data
) + 1;
1669 case DW_FORM_exprloc
:
1670 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1671 block_start
= data
+ bytes_read
;
1672 if (block_start
>= end
)
1674 warn (_("Block ends prematurely\n"));
1678 /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1679 gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute
1680 block_start + uvalue here. */
1681 data
= block_start
+ uvalue
;
1682 /* PR 17512: file: 008-103549-0.001:0.1. */
1683 if (block_start
+ uvalue
> end
|| data
< block_start
)
1685 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1686 uvalue
= end
- block_start
;
1689 data
= block_start
+ uvalue
;
1691 data
= display_block (block_start
, uvalue
, end
);
1694 case DW_FORM_block1
:
1695 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1696 block_start
= data
+ 1;
1697 if (block_start
>= end
)
1699 warn (_("Block ends prematurely\n"));
1703 data
= block_start
+ uvalue
;
1704 if (block_start
+ uvalue
> end
|| data
< block_start
)
1706 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1707 uvalue
= end
- block_start
;
1710 data
= block_start
+ uvalue
;
1712 data
= display_block (block_start
, uvalue
, end
);
1715 case DW_FORM_block2
:
1716 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1717 block_start
= data
+ 2;
1718 if (block_start
>= end
)
1720 warn (_("Block ends prematurely\n"));
1724 data
= block_start
+ uvalue
;
1725 if (block_start
+ uvalue
> end
|| data
< block_start
)
1727 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1728 uvalue
= end
- block_start
;
1731 data
= block_start
+ uvalue
;
1733 data
= display_block (block_start
, uvalue
, end
);
1736 case DW_FORM_block4
:
1737 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1738 block_start
= data
+ 4;
1739 /* PR 17512: file: 3371-3907-0.004. */
1740 if (block_start
>= end
)
1742 warn (_("Block ends prematurely\n"));
1746 data
= block_start
+ uvalue
;
1747 if (block_start
+ uvalue
> end
1748 /* PR 17531: file: 5b5f0592. */
1749 || data
< block_start
)
1751 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1752 uvalue
= end
- block_start
;
1755 data
= block_start
+ uvalue
;
1757 data
= display_block (block_start
, uvalue
, end
);
1762 printf (_(" (indirect string, offset: 0x%s): %s"),
1763 dwarf_vmatoa ("x", uvalue
),
1764 fetch_indirect_string (uvalue
));
1767 case DW_FORM_GNU_str_index
:
1770 const char *suffix
= strrchr (section
->name
, '.');
1771 int dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? 1 : 0;
1773 printf (_(" (indexed string: 0x%s): %s"),
1774 dwarf_vmatoa ("x", uvalue
),
1775 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
1779 case DW_FORM_GNU_strp_alt
:
1781 printf (_(" (alt indirect string, offset: 0x%s)"),
1782 dwarf_vmatoa ("x", uvalue
));
1785 case DW_FORM_indirect
:
1786 /* Handled above. */
1789 case DW_FORM_ref_sig8
:
1792 dwarf_vma high_bits
;
1795 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1796 printf (" signature: 0x%s",
1797 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
1802 case DW_FORM_GNU_addr_index
:
1804 printf (_(" (addr_index: 0x%s): %s"),
1805 dwarf_vmatoa ("x", uvalue
),
1806 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
1810 warn (_("Unrecognized form: %lu\n"), form
);
1814 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1815 && num_debug_info_entries
== 0
1816 && debug_info_p
!= NULL
)
1820 case DW_AT_frame_base
:
1821 have_frame_base
= 1;
1822 case DW_AT_location
:
1823 case DW_AT_string_length
:
1824 case DW_AT_return_addr
:
1825 case DW_AT_data_member_location
:
1826 case DW_AT_vtable_elem_location
:
1828 case DW_AT_static_link
:
1829 case DW_AT_use_location
:
1830 case DW_AT_GNU_call_site_value
:
1831 case DW_AT_GNU_call_site_data_value
:
1832 case DW_AT_GNU_call_site_target
:
1833 case DW_AT_GNU_call_site_target_clobbered
:
1834 if ((dwarf_version
< 4
1835 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1836 || form
== DW_FORM_sec_offset
)
1838 /* Process location list. */
1839 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1840 unsigned int num
= debug_info_p
->num_loc_offsets
;
1842 if (lmax
== 0 || num
>= lmax
)
1845 debug_info_p
->loc_offsets
= (dwarf_vma
*)
1846 xcrealloc (debug_info_p
->loc_offsets
,
1847 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1848 debug_info_p
->have_frame_base
= (int *)
1849 xcrealloc (debug_info_p
->have_frame_base
,
1850 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1851 debug_info_p
->max_loc_offsets
= lmax
;
1853 if (this_set
!= NULL
)
1854 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
1855 debug_info_p
->loc_offsets
[num
] = uvalue
;
1856 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1857 debug_info_p
->num_loc_offsets
++;
1862 if (need_base_address
)
1863 debug_info_p
->base_address
= uvalue
;
1866 case DW_AT_GNU_addr_base
:
1867 debug_info_p
->addr_base
= uvalue
;
1870 case DW_AT_GNU_ranges_base
:
1871 debug_info_p
->ranges_base
= uvalue
;
1875 if ((dwarf_version
< 4
1876 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1877 || form
== DW_FORM_sec_offset
)
1879 /* Process range list. */
1880 unsigned int lmax
= debug_info_p
->max_range_lists
;
1881 unsigned int num
= debug_info_p
->num_range_lists
;
1883 if (lmax
== 0 || num
>= lmax
)
1886 debug_info_p
->range_lists
= (dwarf_vma
*)
1887 xcrealloc (debug_info_p
->range_lists
,
1888 lmax
, sizeof (*debug_info_p
->range_lists
));
1889 debug_info_p
->max_range_lists
= lmax
;
1891 debug_info_p
->range_lists
[num
] = uvalue
;
1892 debug_info_p
->num_range_lists
++;
1901 if (do_loc
|| attribute
== 0)
1904 /* For some attributes we can display further information. */
1911 case DW_INL_not_inlined
:
1912 printf (_("(not inlined)"));
1914 case DW_INL_inlined
:
1915 printf (_("(inlined)"));
1917 case DW_INL_declared_not_inlined
:
1918 printf (_("(declared as inline but ignored)"));
1920 case DW_INL_declared_inlined
:
1921 printf (_("(declared as inline and inlined)"));
1924 printf (_(" (Unknown inline attribute value: %s)"),
1925 dwarf_vmatoa ("x", uvalue
));
1930 case DW_AT_language
:
1934 /* Ordered by the numeric value of these constants. */
1935 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1936 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1937 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1938 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1939 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1940 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1941 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1942 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1943 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1944 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1945 /* DWARF 2.1 values. */
1946 case DW_LANG_Java
: printf ("(Java)"); break;
1947 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1948 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1949 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1950 /* DWARF 3 values. */
1951 case DW_LANG_PLI
: printf ("(PLI)"); break;
1952 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1953 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1954 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1955 case DW_LANG_D
: printf ("(D)"); break;
1956 /* DWARF 4 values. */
1957 case DW_LANG_Python
: printf ("(Python)"); break;
1958 /* DWARF 5 values. */
1959 case DW_LANG_Go
: printf ("(Go)"); break;
1960 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
1961 case DW_LANG_C11
: printf ("(C11)"); break;
1962 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
1963 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
1964 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
1965 /* MIPS extension. */
1966 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1967 /* UPC extension. */
1968 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1970 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1971 printf (_("(implementation defined: %s)"),
1972 dwarf_vmatoa ("x", uvalue
));
1974 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
1979 case DW_AT_encoding
:
1983 case DW_ATE_void
: printf ("(void)"); break;
1984 case DW_ATE_address
: printf ("(machine address)"); break;
1985 case DW_ATE_boolean
: printf ("(boolean)"); break;
1986 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1987 case DW_ATE_float
: printf ("(float)"); break;
1988 case DW_ATE_signed
: printf ("(signed)"); break;
1989 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1990 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1991 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1992 /* DWARF 2.1 values: */
1993 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1994 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
1995 /* DWARF 3 values: */
1996 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
1997 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
1998 case DW_ATE_edited
: printf ("(edited)"); break;
1999 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2000 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2001 /* HP extensions: */
2002 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2003 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2004 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2005 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2006 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2007 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2008 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2011 if (uvalue
>= DW_ATE_lo_user
2012 && uvalue
<= DW_ATE_hi_user
)
2013 printf (_("(user defined type)"));
2015 printf (_("(unknown type)"));
2020 case DW_AT_accessibility
:
2024 case DW_ACCESS_public
: printf ("(public)"); break;
2025 case DW_ACCESS_protected
: printf ("(protected)"); break;
2026 case DW_ACCESS_private
: printf ("(private)"); break;
2028 printf (_("(unknown accessibility)"));
2033 case DW_AT_visibility
:
2037 case DW_VIS_local
: printf ("(local)"); break;
2038 case DW_VIS_exported
: printf ("(exported)"); break;
2039 case DW_VIS_qualified
: printf ("(qualified)"); break;
2040 default: printf (_("(unknown visibility)")); break;
2044 case DW_AT_virtuality
:
2048 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2049 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2050 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2051 default: printf (_("(unknown virtuality)")); break;
2055 case DW_AT_identifier_case
:
2059 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2060 case DW_ID_up_case
: printf ("(up_case)"); break;
2061 case DW_ID_down_case
: printf ("(down_case)"); break;
2062 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2063 default: printf (_("(unknown case)")); break;
2067 case DW_AT_calling_convention
:
2071 case DW_CC_normal
: printf ("(normal)"); break;
2072 case DW_CC_program
: printf ("(program)"); break;
2073 case DW_CC_nocall
: printf ("(nocall)"); break;
2075 if (uvalue
>= DW_CC_lo_user
2076 && uvalue
<= DW_CC_hi_user
)
2077 printf (_("(user defined)"));
2079 printf (_("(unknown convention)"));
2083 case DW_AT_ordering
:
2087 case -1: printf (_("(undefined)")); break;
2088 case 0: printf ("(row major)"); break;
2089 case 1: printf ("(column major)"); break;
2093 case DW_AT_frame_base
:
2094 have_frame_base
= 1;
2095 case DW_AT_location
:
2096 case DW_AT_string_length
:
2097 case DW_AT_return_addr
:
2098 case DW_AT_data_member_location
:
2099 case DW_AT_vtable_elem_location
:
2101 case DW_AT_static_link
:
2102 case DW_AT_use_location
:
2103 case DW_AT_GNU_call_site_value
:
2104 case DW_AT_GNU_call_site_data_value
:
2105 case DW_AT_GNU_call_site_target
:
2106 case DW_AT_GNU_call_site_target_clobbered
:
2107 if ((dwarf_version
< 4
2108 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2109 || form
== DW_FORM_sec_offset
)
2110 printf (_(" (location list)"));
2112 case DW_AT_allocated
:
2113 case DW_AT_associated
:
2114 case DW_AT_data_location
:
2116 case DW_AT_upper_bound
:
2117 case DW_AT_lower_bound
:
2120 int need_frame_base
;
2123 need_frame_base
= decode_location_expression (block_start
,
2128 cu_offset
, section
);
2130 if (need_frame_base
&& !have_frame_base
)
2131 printf (_(" [without DW_AT_frame_base]"));
2137 if (form
== DW_FORM_ref_sig8
2138 || form
== DW_FORM_GNU_ref_alt
)
2141 if (form
== DW_FORM_ref1
2142 || form
== DW_FORM_ref2
2143 || form
== DW_FORM_ref4
2144 || form
== DW_FORM_ref_udata
)
2145 uvalue
+= cu_offset
;
2147 if (uvalue
>= section
->size
)
2148 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2149 dwarf_vmatoa ("x", uvalue
),
2150 (unsigned long) (orig_data
- section
->start
));
2153 unsigned long abbrev_number
;
2154 abbrev_entry
* entry
;
2156 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2158 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2159 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2160 use different abbrev table, and we don't track .debug_info chunks
2162 if (form
!= DW_FORM_ref_addr
)
2164 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2165 if (entry
->entry
== abbrev_number
)
2168 printf (" (%s)", get_TAG_name (entry
->tag
));
2183 get_AT_name (unsigned long attribute
)
2188 return "DW_AT value: 0";
2190 /* One value is shared by the MIPS and HP extensions: */
2191 if (attribute
== DW_AT_MIPS_fde
)
2192 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2194 name
= get_DW_AT_name (attribute
);
2198 static char buffer
[100];
2200 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2208 static unsigned char *
2209 read_and_display_attr (unsigned long attribute
,
2211 unsigned char * data
,
2212 unsigned char * end
,
2213 dwarf_vma cu_offset
,
2214 dwarf_vma pointer_size
,
2215 dwarf_vma offset_size
,
2217 debug_info
* debug_info_p
,
2219 struct dwarf_section
* section
,
2220 struct cu_tu_set
* this_set
)
2223 printf (" %-18s:", get_AT_name (attribute
));
2224 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2225 cu_offset
, pointer_size
, offset_size
,
2226 dwarf_version
, debug_info_p
,
2227 do_loc
, section
, this_set
);
2233 /* Process the contents of a .debug_info section. If do_loc is non-zero
2234 then we are scanning for location lists and we do not want to display
2235 anything to the user. If do_types is non-zero, we are processing
2236 a .debug_types section instead of a .debug_info section. */
2239 process_debug_info (struct dwarf_section
*section
,
2241 enum dwarf_section_display_enum abbrev_sec
,
2245 unsigned char *start
= section
->start
;
2246 unsigned char *end
= start
+ section
->size
;
2247 unsigned char *section_begin
;
2249 unsigned int num_units
= 0;
2251 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2252 && num_debug_info_entries
== 0
2257 /* First scan the section to get the number of comp units. */
2258 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2261 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2262 will be the length. For a 64-bit DWARF section, it'll be
2263 the escape code 0xffffffff followed by an 8 byte length. */
2264 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2266 if (length
== 0xffffffff)
2268 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2269 section_begin
+= length
+ 12;
2271 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2273 warn (_("Reserved length value (0x%s) found in section %s\n"),
2274 dwarf_vmatoa ("x", length
), section
->name
);
2278 section_begin
+= length
+ 4;
2280 /* Negative values are illegal, they may even cause infinite
2281 looping. This can happen if we can't accurately apply
2282 relocations to an object file, or if the file is corrupt. */
2283 if ((signed long) length
<= 0 || section_begin
< start
)
2285 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2286 dwarf_vmatoa ("x", length
), section
->name
);
2293 error (_("No comp units in %s section ?\n"), section
->name
);
2297 /* Then allocate an array to hold the information. */
2298 debug_information
= (debug_info
*) cmalloc (num_units
,
2299 sizeof (* debug_information
));
2300 if (debug_information
== NULL
)
2302 error (_("Not enough memory for a debug info array of %u entries\n"),
2304 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
2307 /* PR 17531: file: 92ca3797.
2308 We cannot rely upon the debug_information array being initialised
2309 before it is used. A corrupt file could easily contain references
2310 to a unit for which information has not been made available. So
2311 we ensure that the array is zeroed here. */
2312 memset (debug_information
, 0, num_units
* sizeof * debug_information
);
2314 alloc_num_debug_info_entries
= num_units
;
2319 if (dwarf_start_die
== 0)
2320 printf (_("Contents of the %s section:\n\n"), section
->name
);
2322 load_debug_section (str
, file
);
2323 load_debug_section (str_dwo
, file
);
2324 load_debug_section (str_index
, file
);
2325 load_debug_section (str_index_dwo
, file
);
2326 load_debug_section (debug_addr
, file
);
2329 load_debug_section (abbrev_sec
, file
);
2330 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2332 warn (_("Unable to locate %s section!\n"),
2333 debug_displays
[abbrev_sec
].section
.name
);
2337 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2339 DWARF2_Internal_CompUnit compunit
;
2340 unsigned char *hdrptr
;
2341 unsigned char *tags
;
2342 int level
, last_level
, saved_level
;
2343 dwarf_vma cu_offset
;
2344 unsigned int offset_size
;
2345 int initial_length_size
;
2346 dwarf_vma signature_high
= 0;
2347 dwarf_vma signature_low
= 0;
2348 dwarf_vma type_offset
= 0;
2349 struct cu_tu_set
*this_set
;
2350 dwarf_vma abbrev_base
;
2355 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2357 if (compunit
.cu_length
== 0xffffffff)
2359 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2361 initial_length_size
= 12;
2366 initial_length_size
= 4;
2369 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2371 cu_offset
= start
- section_begin
;
2373 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2375 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2377 if (this_set
== NULL
)
2380 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2384 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2385 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2388 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2389 /* PR 17512: file: 001-108546-0.001:0.1. */
2390 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2392 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2393 compunit
.cu_pointer_size
, offset_size
);
2394 compunit
.cu_pointer_size
= offset_size
;
2399 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2401 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2404 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2405 && num_debug_info_entries
== 0
2408 debug_information
[unit
].cu_offset
= cu_offset
;
2409 debug_information
[unit
].pointer_size
2410 = compunit
.cu_pointer_size
;
2411 debug_information
[unit
].offset_size
= offset_size
;
2412 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2413 debug_information
[unit
].base_address
= 0;
2414 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2415 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2416 debug_information
[unit
].loc_offsets
= NULL
;
2417 debug_information
[unit
].have_frame_base
= NULL
;
2418 debug_information
[unit
].max_loc_offsets
= 0;
2419 debug_information
[unit
].num_loc_offsets
= 0;
2420 debug_information
[unit
].range_lists
= NULL
;
2421 debug_information
[unit
].max_range_lists
= 0;
2422 debug_information
[unit
].num_range_lists
= 0;
2425 if (!do_loc
&& dwarf_start_die
== 0)
2427 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2428 dwarf_vmatoa ("x", cu_offset
));
2429 printf (_(" Length: 0x%s (%s)\n"),
2430 dwarf_vmatoa ("x", compunit
.cu_length
),
2431 offset_size
== 8 ? "64-bit" : "32-bit");
2432 printf (_(" Version: %d\n"), compunit
.cu_version
);
2433 printf (_(" Abbrev Offset: 0x%s\n"),
2434 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2435 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2440 printf (_(" Signature: 0x%s\n"),
2441 dwarf_vmatoa64 (signature_high
, signature_low
,
2442 buf
, sizeof (buf
)));
2443 printf (_(" Type Offset: 0x%s\n"),
2444 dwarf_vmatoa ("x", type_offset
));
2446 if (this_set
!= NULL
)
2448 dwarf_vma
*offsets
= this_set
->section_offsets
;
2449 size_t *sizes
= this_set
->section_sizes
;
2451 printf (_(" Section contributions:\n"));
2452 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2453 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2454 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2455 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2456 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2457 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2458 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2459 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2460 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2461 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2462 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2463 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2467 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2470 warn (_("Debug info is corrupted, length of CU at %s"
2471 " extends beyond end of section (length = %s)\n"),
2472 dwarf_vmatoa ("x", cu_offset
),
2473 dwarf_vmatoa ("x", compunit
.cu_length
));
2478 start
+= compunit
.cu_length
+ initial_length_size
;
2482 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2483 dwarf_vmatoa ("x", cu_offset
));
2487 if (compunit
.cu_version
!= 2
2488 && compunit
.cu_version
!= 3
2489 && compunit
.cu_version
!= 4)
2491 warn (_("CU at offset %s contains corrupt or "
2492 "unsupported version number: %d.\n"),
2493 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2499 /* Process the abbrevs used by this compilation unit. */
2500 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2501 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2502 (unsigned long) compunit
.cu_abbrev_offset
,
2503 (unsigned long) abbrev_size
);
2504 /* PR 17531: file:4bcd9ce9. */
2505 else if ((abbrev_base
+ abbrev_size
)
2506 > debug_displays
[abbrev_sec
].section
.size
)
2507 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2508 (unsigned long) abbrev_base
+ abbrev_size
,
2509 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
2511 process_abbrev_section
2512 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2513 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2514 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2515 + abbrev_base
+ abbrev_size
));
2520 while (tags
< start
)
2522 unsigned int bytes_read
;
2523 unsigned long abbrev_number
;
2524 unsigned long die_offset
;
2525 abbrev_entry
*entry
;
2527 int do_printing
= 1;
2529 die_offset
= tags
- section_begin
;
2531 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2534 /* A null DIE marks the end of a list of siblings or it may also be
2535 a section padding. */
2536 if (abbrev_number
== 0)
2538 /* Check if it can be a section padding for the last CU. */
2539 if (level
== 0 && start
== end
)
2543 for (chk
= tags
; chk
< start
; chk
++)
2550 if (!do_loc
&& die_offset
>= dwarf_start_die
2551 && (dwarf_cutoff_level
== -1
2552 || level
< dwarf_cutoff_level
))
2553 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2559 static unsigned num_bogus_warns
= 0;
2561 if (num_bogus_warns
< 3)
2563 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2564 die_offset
, section
->name
);
2566 if (num_bogus_warns
== 3)
2567 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2570 if (dwarf_start_die
!= 0 && level
< saved_level
)
2577 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2581 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2582 saved_level
= level
;
2583 do_printing
= (dwarf_cutoff_level
== -1
2584 || level
< dwarf_cutoff_level
);
2586 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2587 level
, die_offset
, abbrev_number
);
2588 else if (dwarf_cutoff_level
== -1
2589 || last_level
< dwarf_cutoff_level
)
2590 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2595 /* Scan through the abbreviation list until we reach the
2597 for (entry
= first_abbrev
;
2598 entry
&& entry
->entry
!= abbrev_number
;
2599 entry
= entry
->next
)
2604 if (!do_loc
&& do_printing
)
2609 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2610 die_offset
, abbrev_number
);
2614 if (!do_loc
&& do_printing
)
2615 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2620 need_base_address
= 0;
2622 case DW_TAG_compile_unit
:
2623 need_base_address
= 1;
2625 case DW_TAG_entry_point
:
2626 case DW_TAG_subprogram
:
2627 need_base_address
= 0;
2628 /* Assuming that there is no DW_AT_frame_base. */
2629 have_frame_base
= 0;
2633 for (attr
= entry
->first_attr
;
2634 attr
&& attr
->attribute
;
2639 if (! do_loc
&& do_printing
)
2640 /* Show the offset from where the tag was extracted. */
2641 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2643 if (debug_information
&& unit
< alloc_num_debug_info_entries
)
2644 arg
= debug_information
+ unit
;
2648 tags
= read_and_display_attr (attr
->attribute
,
2653 compunit
.cu_pointer_size
,
2655 compunit
.cu_version
,
2657 do_loc
|| ! do_printing
,
2662 if (entry
->children
)
2667 /* Set num_debug_info_entries here so that it can be used to check if
2668 we need to process .debug_loc and .debug_ranges sections. */
2669 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2670 && num_debug_info_entries
== 0
2673 if (num_units
> alloc_num_debug_info_entries
)
2674 num_debug_info_entries
= alloc_num_debug_info_entries
;
2676 num_debug_info_entries
= num_units
;
2685 /* Locate and scan the .debug_info section in the file and record the pointer
2686 sizes and offsets for the compilation units in it. Usually an executable
2687 will have just one pointer size, but this is not guaranteed, and so we try
2688 not to make any assumptions. Returns zero upon failure, or the number of
2689 compilation units upon success. */
2692 load_debug_info (void * file
)
2694 /* Reset the last pointer size so that we can issue correct error
2695 messages if we are displaying the contents of more than one section. */
2696 last_pointer_size
= 0;
2697 warned_about_missing_comp_units
= FALSE
;
2699 /* If we have already tried and failed to load the .debug_info
2700 section then do not bother to repeat the task. */
2701 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2704 /* If we already have the information there is nothing else to do. */
2705 if (num_debug_info_entries
> 0)
2706 return num_debug_info_entries
;
2708 /* If this is a DWARF package file, load the CU and TU indexes. */
2709 load_cu_tu_indexes (file
);
2711 if (load_debug_section (info
, file
)
2712 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2713 return num_debug_info_entries
;
2715 if (load_debug_section (info_dwo
, file
)
2716 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2718 return num_debug_info_entries
;
2720 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2724 /* Read a DWARF .debug_line section header starting at DATA.
2725 Upon success returns an updated DATA pointer and the LINFO
2726 structure and the END_OF_SEQUENCE pointer will be filled in.
2727 Otherwise returns NULL. */
2729 static unsigned char *
2730 read_debug_line_header (struct dwarf_section
* section
,
2731 unsigned char * data
,
2732 unsigned char * end
,
2733 DWARF2_Internal_LineInfo
* linfo
,
2734 unsigned char ** end_of_sequence
)
2736 unsigned char *hdrptr
;
2737 unsigned int offset_size
;
2738 unsigned int initial_length_size
;
2740 /* Extract information from the Line Number Program Header.
2741 (section 6.2.4 in the Dwarf3 doc). */
2744 /* Get and check the length of the block. */
2745 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2747 if (linfo
->li_length
== 0xffffffff)
2749 /* This section is 64-bit DWARF 3. */
2750 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2752 initial_length_size
= 12;
2757 initial_length_size
= 4;
2760 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2762 /* If the length is just a bias against the initial_length_size then
2763 this means that the field has a relocation against it which has not
2764 been applied. (Ie we are dealing with an object file, not a linked
2765 binary). Do not complain but instead assume that the rest of the
2766 section applies to this particular header. */
2767 if (linfo
->li_length
== - initial_length_size
)
2769 linfo
->li_length
= section
->size
- initial_length_size
;
2773 warn (_("The line info appears to be corrupt - the section is too small\n"));
2778 /* Get and check the version number. */
2779 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2781 if (linfo
->li_version
!= 2
2782 && linfo
->li_version
!= 3
2783 && linfo
->li_version
!= 4)
2785 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2789 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2790 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2792 if (linfo
->li_version
>= 4)
2794 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2796 if (linfo
->li_max_ops_per_insn
== 0)
2798 warn (_("Invalid maximum operations per insn.\n"));
2803 linfo
->li_max_ops_per_insn
= 1;
2805 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2806 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2807 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2808 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2810 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2811 /* PR 17512: file:002-117414-0.004. */
2812 if (* end_of_sequence
> end
)
2814 warn (_("Line length %s extends beyond end of section\n"),
2815 dwarf_vmatoa ("u", linfo
->li_length
));
2816 * end_of_sequence
= end
;
2824 display_debug_lines_raw (struct dwarf_section
*section
,
2825 unsigned char *data
,
2828 unsigned char *start
= section
->start
;
2830 printf (_("Raw dump of debug contents of section %s:\n\n"),
2835 static DWARF2_Internal_LineInfo saved_linfo
;
2836 DWARF2_Internal_LineInfo linfo
;
2837 unsigned char *standard_opcodes
;
2838 unsigned char *end_of_sequence
;
2839 unsigned int last_dir_entry
= 0;
2842 if (const_strneq (section
->name
, ".debug_line.")
2843 /* Note: the following does not apply to .debug_line.dwo sections.
2844 These are full debug_line sections. */
2845 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2847 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2848 section containing just the Line Number Statements. They are
2849 created by the assembler and intended to be used alongside gcc's
2850 -ffunction-sections command line option. When the linker's
2851 garbage collection decides to discard a .text.<foo> section it
2852 can then also discard the line number information in .debug_line.<foo>.
2854 Since the section is a fragment it does not have the details
2855 needed to fill out a LineInfo structure, so instead we use the
2856 details from the last full debug_line section that we processed. */
2857 end_of_sequence
= end
;
2858 standard_opcodes
= NULL
;
2859 linfo
= saved_linfo
;
2860 /* PR 17531: file: 0522b371. */
2861 if (linfo
.li_line_range
== 0)
2863 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2866 reset_state_machine (linfo
.li_default_is_stmt
);
2870 unsigned char * hdrptr
;
2872 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2873 & end_of_sequence
)) == NULL
)
2876 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2877 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2878 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2879 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
2880 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2881 if (linfo
.li_version
>= 4)
2882 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2883 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2884 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2885 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2886 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2888 /* PR 17512: file: 1665-6428-0.004. */
2889 if (linfo
.li_line_range
== 0)
2891 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2892 linfo
.li_line_range
= 1;
2895 reset_state_machine (linfo
.li_default_is_stmt
);
2897 /* Display the contents of the Opcodes table. */
2898 standard_opcodes
= hdrptr
;
2900 /* PR 17512: file: 002-417945-0.004. */
2901 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
2903 warn (_("Line Base extends beyond end of section\n"));
2907 printf (_("\n Opcodes:\n"));
2909 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2910 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2912 /* Display the contents of the Directory table. */
2913 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2916 printf (_("\n The Directory Table is empty.\n"));
2919 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2920 (long)(data
- start
));
2922 while (data
< end
&& *data
!= 0)
2924 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
2926 data
+= strnlen ((char *) data
, end
- data
) + 1;
2929 /* PR 17512: file: 002-132094-0.004. */
2930 if (data
>= end
- 1)
2934 /* Skip the NUL at the end of the table. */
2937 /* Display the contents of the File Name table. */
2939 printf (_("\n The File Name Table is empty.\n"));
2942 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2943 (long)(data
- start
));
2944 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2946 while (data
< end
&& *data
!= 0)
2948 unsigned char *name
;
2949 unsigned int bytes_read
;
2951 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2953 data
+= strnlen ((char *) data
, end
- data
) + 1;
2956 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2959 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2962 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2964 printf ("%.*s\n", (int)(end
- name
), name
);
2968 warn (_("Corrupt file name table entry\n"));
2974 /* Skip the NUL at the end of the table. */
2977 saved_linfo
= linfo
;
2980 /* Now display the statements. */
2981 if (data
>= end_of_sequence
)
2982 printf (_(" No Line Number Statements.\n"));
2985 printf (_(" Line Number Statements:\n"));
2987 while (data
< end_of_sequence
)
2989 unsigned char op_code
;
2990 dwarf_signed_vma adv
;
2992 unsigned int bytes_read
;
2994 printf (" [0x%08lx]", (long)(data
- start
));
2998 if (op_code
>= linfo
.li_opcode_base
)
3000 op_code
-= linfo
.li_opcode_base
;
3001 uladv
= (op_code
/ linfo
.li_line_range
);
3002 if (linfo
.li_max_ops_per_insn
== 1)
3004 uladv
*= linfo
.li_min_insn_length
;
3005 state_machine_regs
.address
+= uladv
;
3006 printf (_(" Special opcode %d: "
3007 "advance Address by %s to 0x%s"),
3008 op_code
, dwarf_vmatoa ("u", uladv
),
3009 dwarf_vmatoa ("x", state_machine_regs
.address
));
3013 state_machine_regs
.address
3014 += ((state_machine_regs
.op_index
+ uladv
)
3015 / linfo
.li_max_ops_per_insn
)
3016 * linfo
.li_min_insn_length
;
3017 state_machine_regs
.op_index
3018 = (state_machine_regs
.op_index
+ uladv
)
3019 % linfo
.li_max_ops_per_insn
;
3020 printf (_(" Special opcode %d: "
3021 "advance Address by %s to 0x%s[%d]"),
3022 op_code
, dwarf_vmatoa ("u", uladv
),
3023 dwarf_vmatoa ("x", state_machine_regs
.address
),
3024 state_machine_regs
.op_index
);
3026 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3027 state_machine_regs
.line
+= adv
;
3028 printf (_(" and Line by %s to %d\n"),
3029 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
3031 else switch (op_code
)
3033 case DW_LNS_extended_op
:
3034 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3038 printf (_(" Copy\n"));
3041 case DW_LNS_advance_pc
:
3042 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3044 if (linfo
.li_max_ops_per_insn
== 1)
3046 uladv
*= linfo
.li_min_insn_length
;
3047 state_machine_regs
.address
+= uladv
;
3048 printf (_(" Advance PC by %s to 0x%s\n"),
3049 dwarf_vmatoa ("u", uladv
),
3050 dwarf_vmatoa ("x", state_machine_regs
.address
));
3054 state_machine_regs
.address
3055 += ((state_machine_regs
.op_index
+ uladv
)
3056 / linfo
.li_max_ops_per_insn
)
3057 * linfo
.li_min_insn_length
;
3058 state_machine_regs
.op_index
3059 = (state_machine_regs
.op_index
+ uladv
)
3060 % linfo
.li_max_ops_per_insn
;
3061 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3062 dwarf_vmatoa ("u", uladv
),
3063 dwarf_vmatoa ("x", state_machine_regs
.address
),
3064 state_machine_regs
.op_index
);
3068 case DW_LNS_advance_line
:
3069 adv
= read_sleb128 (data
, & bytes_read
, end
);
3071 state_machine_regs
.line
+= adv
;
3072 printf (_(" Advance Line by %s to %d\n"),
3073 dwarf_vmatoa ("d", adv
),
3074 state_machine_regs
.line
);
3077 case DW_LNS_set_file
:
3078 adv
= read_uleb128 (data
, & bytes_read
, end
);
3080 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3081 dwarf_vmatoa ("d", adv
));
3082 state_machine_regs
.file
= adv
;
3085 case DW_LNS_set_column
:
3086 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3088 printf (_(" Set column to %s\n"),
3089 dwarf_vmatoa ("u", uladv
));
3090 state_machine_regs
.column
= uladv
;
3093 case DW_LNS_negate_stmt
:
3094 adv
= state_machine_regs
.is_stmt
;
3096 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3097 state_machine_regs
.is_stmt
= adv
;
3100 case DW_LNS_set_basic_block
:
3101 printf (_(" Set basic block\n"));
3102 state_machine_regs
.basic_block
= 1;
3105 case DW_LNS_const_add_pc
:
3106 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3107 if (linfo
.li_max_ops_per_insn
)
3109 uladv
*= linfo
.li_min_insn_length
;
3110 state_machine_regs
.address
+= uladv
;
3111 printf (_(" Advance PC by constant %s to 0x%s\n"),
3112 dwarf_vmatoa ("u", uladv
),
3113 dwarf_vmatoa ("x", state_machine_regs
.address
));
3117 state_machine_regs
.address
3118 += ((state_machine_regs
.op_index
+ uladv
)
3119 / linfo
.li_max_ops_per_insn
)
3120 * linfo
.li_min_insn_length
;
3121 state_machine_regs
.op_index
3122 = (state_machine_regs
.op_index
+ uladv
)
3123 % linfo
.li_max_ops_per_insn
;
3124 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3125 dwarf_vmatoa ("u", uladv
),
3126 dwarf_vmatoa ("x", state_machine_regs
.address
),
3127 state_machine_regs
.op_index
);
3131 case DW_LNS_fixed_advance_pc
:
3132 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3133 state_machine_regs
.address
+= uladv
;
3134 state_machine_regs
.op_index
= 0;
3135 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3136 dwarf_vmatoa ("u", uladv
),
3137 dwarf_vmatoa ("x", state_machine_regs
.address
));
3140 case DW_LNS_set_prologue_end
:
3141 printf (_(" Set prologue_end to true\n"));
3144 case DW_LNS_set_epilogue_begin
:
3145 printf (_(" Set epilogue_begin to true\n"));
3148 case DW_LNS_set_isa
:
3149 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3151 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3155 printf (_(" Unknown opcode %d with operands: "), op_code
);
3157 if (standard_opcodes
!= NULL
)
3158 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3160 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3162 i
== 1 ? "" : ", ");
3178 unsigned char *name
;
3179 unsigned int directory_index
;
3180 unsigned int modification_date
;
3181 unsigned int length
;
3184 /* Output a decoded representation of the .debug_line section. */
3187 display_debug_lines_decoded (struct dwarf_section
*section
,
3188 unsigned char *data
,
3191 static DWARF2_Internal_LineInfo saved_linfo
;
3193 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3198 /* This loop amounts to one iteration per compilation unit. */
3199 DWARF2_Internal_LineInfo linfo
;
3200 unsigned char *standard_opcodes
;
3201 unsigned char *end_of_sequence
;
3203 File_Entry
*file_table
= NULL
;
3204 unsigned int n_files
= 0;
3205 unsigned char **directory_table
= NULL
;
3206 unsigned int n_directories
= 0;
3208 if (const_strneq (section
->name
, ".debug_line.")
3209 /* Note: the following does not apply to .debug_line.dwo sections.
3210 These are full debug_line sections. */
3211 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3213 /* See comment in display_debug_lines_raw(). */
3214 end_of_sequence
= end
;
3215 standard_opcodes
= NULL
;
3216 linfo
= saved_linfo
;
3217 /* PR 17531: file: 0522b371. */
3218 if (linfo
.li_line_range
== 0)
3220 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3223 reset_state_machine (linfo
.li_default_is_stmt
);
3227 unsigned char *hdrptr
;
3229 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3230 & end_of_sequence
)) == NULL
)
3233 /* PR 17531: file: 0522b371. */
3234 if (linfo
.li_line_range
== 0)
3236 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3237 linfo
.li_line_range
= 1;
3239 reset_state_machine (linfo
.li_default_is_stmt
);
3241 /* Save a pointer to the contents of the Opcodes table. */
3242 standard_opcodes
= hdrptr
;
3244 /* Traverse the Directory table just to count entries. */
3245 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3248 unsigned char *ptr_directory_table
= data
;
3252 data
+= strnlen ((char *) data
, end
- data
) + 1;
3256 /* Go through the directory table again to save the directories. */
3257 directory_table
= (unsigned char **)
3258 xmalloc (n_directories
* sizeof (unsigned char *));
3261 while (*ptr_directory_table
!= 0)
3263 directory_table
[i
] = ptr_directory_table
;
3264 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3265 ptr_directory_table
- end
) + 1;
3269 /* Skip the NUL at the end of the table. */
3272 /* Traverse the File Name table just to count the entries. */
3275 unsigned char *ptr_file_name_table
= data
;
3279 unsigned int bytes_read
;
3281 /* Skip Name, directory index, last modification time and length
3283 data
+= strnlen ((char *) data
, end
- data
) + 1;
3284 read_uleb128 (data
, & bytes_read
, end
);
3286 read_uleb128 (data
, & bytes_read
, end
);
3288 read_uleb128 (data
, & bytes_read
, end
);
3294 /* Go through the file table again to save the strings. */
3295 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3298 while (*ptr_file_name_table
!= 0)
3300 unsigned int bytes_read
;
3302 file_table
[i
].name
= ptr_file_name_table
;
3303 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3304 end
- ptr_file_name_table
) + 1;
3306 /* We are not interested in directory, time or size. */
3307 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3309 ptr_file_name_table
+= bytes_read
;
3310 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3312 ptr_file_name_table
+= bytes_read
;
3313 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3314 ptr_file_name_table
+= bytes_read
;
3319 /* Print the Compilation Unit's name and a header. */
3320 if (directory_table
== NULL
)
3322 printf (_("CU: %s:\n"), file_table
[0].name
);
3323 printf (_("File name Line number Starting address\n"));
3327 unsigned int ix
= file_table
[0].directory_index
;
3328 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3330 if (do_wide
|| strlen (directory
) < 76)
3331 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3333 printf ("%s:\n", file_table
[0].name
);
3335 printf (_("File name Line number Starting address\n"));
3339 /* Skip the NUL at the end of the table. */
3342 saved_linfo
= linfo
;
3345 /* This loop iterates through the Dwarf Line Number Program. */
3346 while (data
< end_of_sequence
)
3348 unsigned char op_code
;
3350 unsigned long int uladv
;
3351 unsigned int bytes_read
;
3352 int is_special_opcode
= 0;
3356 if (op_code
>= linfo
.li_opcode_base
)
3358 op_code
-= linfo
.li_opcode_base
;
3359 uladv
= (op_code
/ linfo
.li_line_range
);
3360 if (linfo
.li_max_ops_per_insn
== 1)
3362 uladv
*= linfo
.li_min_insn_length
;
3363 state_machine_regs
.address
+= uladv
;
3367 state_machine_regs
.address
3368 += ((state_machine_regs
.op_index
+ uladv
)
3369 / linfo
.li_max_ops_per_insn
)
3370 * linfo
.li_min_insn_length
;
3371 state_machine_regs
.op_index
3372 = (state_machine_regs
.op_index
+ uladv
)
3373 % linfo
.li_max_ops_per_insn
;
3376 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3377 state_machine_regs
.line
+= adv
;
3378 is_special_opcode
= 1;
3380 else switch (op_code
)
3382 case DW_LNS_extended_op
:
3384 unsigned int ext_op_code_len
;
3385 unsigned char ext_op_code
;
3386 unsigned char *op_code_data
= data
;
3388 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3390 op_code_data
+= bytes_read
;
3392 if (ext_op_code_len
== 0)
3394 warn (_("Badly formed extended line op encountered!\n"));
3397 ext_op_code_len
+= bytes_read
;
3398 ext_op_code
= *op_code_data
++;
3400 switch (ext_op_code
)
3402 case DW_LNE_end_sequence
:
3403 reset_state_machine (linfo
.li_default_is_stmt
);
3405 case DW_LNE_set_address
:
3406 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3408 ext_op_code_len
- bytes_read
- 1,
3410 state_machine_regs
.op_index
= 0;
3412 case DW_LNE_define_file
:
3414 file_table
= (File_Entry
*) xrealloc
3415 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3417 ++state_machine_regs
.last_file_entry
;
3418 /* Source file name. */
3419 file_table
[n_files
].name
= op_code_data
;
3420 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3421 /* Directory index. */
3422 file_table
[n_files
].directory_index
=
3423 read_uleb128 (op_code_data
, & bytes_read
,
3425 op_code_data
+= bytes_read
;
3426 /* Last modification time. */
3427 file_table
[n_files
].modification_date
=
3428 read_uleb128 (op_code_data
, & bytes_read
,
3430 op_code_data
+= bytes_read
;
3432 file_table
[n_files
].length
=
3433 read_uleb128 (op_code_data
, & bytes_read
,
3439 case DW_LNE_set_discriminator
:
3440 case DW_LNE_HP_set_sequence
:
3441 /* Simply ignored. */
3445 printf (_("UNKNOWN (%u): length %d\n"),
3446 ext_op_code
, ext_op_code_len
- bytes_read
);
3449 data
+= ext_op_code_len
;
3455 case DW_LNS_advance_pc
:
3456 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3458 if (linfo
.li_max_ops_per_insn
== 1)
3460 uladv
*= linfo
.li_min_insn_length
;
3461 state_machine_regs
.address
+= uladv
;
3465 state_machine_regs
.address
3466 += ((state_machine_regs
.op_index
+ uladv
)
3467 / linfo
.li_max_ops_per_insn
)
3468 * linfo
.li_min_insn_length
;
3469 state_machine_regs
.op_index
3470 = (state_machine_regs
.op_index
+ uladv
)
3471 % linfo
.li_max_ops_per_insn
;
3475 case DW_LNS_advance_line
:
3476 adv
= read_sleb128 (data
, & bytes_read
, end
);
3478 state_machine_regs
.line
+= adv
;
3481 case DW_LNS_set_file
:
3482 adv
= read_uleb128 (data
, & bytes_read
, end
);
3484 state_machine_regs
.file
= adv
;
3486 if (file_table
== NULL
)
3487 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3488 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3489 /* If directory index is 0, that means current directory. */
3490 printf ("\n./%s:[++]\n",
3491 file_table
[state_machine_regs
.file
- 1].name
);
3492 else if (directory_table
== NULL
)
3493 printf (_("\n [Use directory table entry %d]\n"),
3494 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3496 /* The directory index starts counting at 1. */
3497 printf ("\n%s/%s:\n",
3498 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3499 file_table
[state_machine_regs
.file
- 1].name
);
3502 case DW_LNS_set_column
:
3503 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3505 state_machine_regs
.column
= uladv
;
3508 case DW_LNS_negate_stmt
:
3509 adv
= state_machine_regs
.is_stmt
;
3511 state_machine_regs
.is_stmt
= adv
;
3514 case DW_LNS_set_basic_block
:
3515 state_machine_regs
.basic_block
= 1;
3518 case DW_LNS_const_add_pc
:
3519 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3520 if (linfo
.li_max_ops_per_insn
== 1)
3522 uladv
*= linfo
.li_min_insn_length
;
3523 state_machine_regs
.address
+= uladv
;
3527 state_machine_regs
.address
3528 += ((state_machine_regs
.op_index
+ uladv
)
3529 / linfo
.li_max_ops_per_insn
)
3530 * linfo
.li_min_insn_length
;
3531 state_machine_regs
.op_index
3532 = (state_machine_regs
.op_index
+ uladv
)
3533 % linfo
.li_max_ops_per_insn
;
3537 case DW_LNS_fixed_advance_pc
:
3538 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3539 state_machine_regs
.address
+= uladv
;
3540 state_machine_regs
.op_index
= 0;
3543 case DW_LNS_set_prologue_end
:
3546 case DW_LNS_set_epilogue_begin
:
3549 case DW_LNS_set_isa
:
3550 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3552 printf (_(" Set ISA to %lu\n"), uladv
);
3556 printf (_(" Unknown opcode %d with operands: "), op_code
);
3558 if (standard_opcodes
!= NULL
)
3559 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3561 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3563 i
== 1 ? "" : ", ");
3570 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3571 to the DWARF address/line matrix. */
3572 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3573 || (op_code
== DW_LNS_copy
))
3575 const unsigned int MAX_FILENAME_LENGTH
= 35;
3577 char *newFileName
= NULL
;
3578 size_t fileNameLength
;
3581 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3583 fileName
= "<unknown>";
3585 fileNameLength
= strlen (fileName
);
3587 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3589 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3590 /* Truncate file name */
3591 strncpy (newFileName
,
3592 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3593 MAX_FILENAME_LENGTH
+ 1);
3597 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3598 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3601 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3603 if (linfo
.li_max_ops_per_insn
== 1)
3604 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3605 newFileName
, state_machine_regs
.line
,
3606 state_machine_regs
.address
);
3608 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3609 newFileName
, state_machine_regs
.line
,
3610 state_machine_regs
.address
,
3611 state_machine_regs
.op_index
);
3615 if (linfo
.li_max_ops_per_insn
== 1)
3616 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3617 newFileName
, state_machine_regs
.line
,
3618 state_machine_regs
.address
);
3620 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3621 newFileName
, state_machine_regs
.line
,
3622 state_machine_regs
.address
,
3623 state_machine_regs
.op_index
);
3626 if (op_code
== DW_LNE_end_sequence
)
3640 if (directory_table
)
3642 free (directory_table
);
3643 directory_table
= NULL
;
3654 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3656 unsigned char *data
= section
->start
;
3657 unsigned char *end
= data
+ section
->size
;
3659 int retValDecoded
= 1;
3661 if (do_debug_lines
== 0)
3662 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3664 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3665 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3667 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3668 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3670 if (!retValRaw
|| !retValDecoded
)
3677 find_debug_info_for_offset (unsigned long offset
)
3681 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3684 for (i
= 0; i
< num_debug_info_entries
; i
++)
3685 if (debug_information
[i
].cu_offset
== offset
)
3686 return debug_information
+ i
;
3692 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
3694 /* See gdb/gdb-index.h. */
3695 static const char * const kinds
[] =
3707 return _ (kinds
[kind
]);
3711 display_debug_pubnames_worker (struct dwarf_section
*section
,
3712 void *file ATTRIBUTE_UNUSED
,
3715 DWARF2_Internal_PubNames names
;
3716 unsigned char *start
= section
->start
;
3717 unsigned char *end
= start
+ section
->size
;
3719 /* It does not matter if this load fails,
3720 we test for that later on. */
3721 load_debug_info (file
);
3723 printf (_("Contents of the %s section:\n\n"), section
->name
);
3727 unsigned char *data
;
3730 unsigned int offset_size
, initial_length_size
;
3734 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3735 if (names
.pn_length
== 0xffffffff)
3737 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3739 initial_length_size
= 12;
3744 initial_length_size
= 4;
3747 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3748 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3750 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3751 && num_debug_info_entries
> 0
3752 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3753 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3754 (unsigned long) names
.pn_offset
, section
->name
);
3756 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3758 adr
= start
+ names
.pn_length
+ initial_length_size
;
3759 /* PR 17531: file: 7615b6b2. */
3760 if ((dwarf_signed_vma
) names
.pn_length
< 0
3761 /* PR 17531: file: a5dbeaa7. */
3764 warn (_("Negative length for public name: 0x%lx\n"), (long) names
.pn_length
);
3770 printf (_(" Length: %ld\n"),
3771 (long) names
.pn_length
);
3772 printf (_(" Version: %d\n"),
3774 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3775 (unsigned long) names
.pn_offset
);
3776 printf (_(" Size of area in .debug_info section: %ld\n"),
3777 (long) names
.pn_size
);
3779 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3781 static int warned
= 0;
3785 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3793 printf (_("\n Offset Kind Name\n"));
3795 printf (_("\n Offset\tName\n"));
3799 bfd_size_type maxprint
;
3801 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3805 data
+= offset_size
;
3808 maxprint
= (end
- data
) - 1;
3812 unsigned int kind_data
;
3813 gdb_index_symbol_kind kind
;
3814 const char *kind_name
;
3817 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
3820 /* GCC computes the kind as the upper byte in the CU index
3821 word, and then right shifts it by the CU index size.
3822 Left shift KIND to where the gdb-index.h accessor macros
3824 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
3825 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
3826 kind_name
= get_gdb_index_symbol_kind_name (kind
);
3827 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
3828 printf (" %-6lx %s,%-10s %.*s\n",
3829 (unsigned long) offset
, is_static
? _("s") : _("g"),
3830 kind_name
, (int) maxprint
, data
);
3833 printf (" %-6lx\t%.*s\n", (unsigned long) offset
, (int) maxprint
, data
);
3835 data
+= strnlen ((char *) data
, maxprint
) + 1;
3840 while (offset
!= 0);
3848 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
3850 return display_debug_pubnames_worker (section
, file
, 0);
3854 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
3856 return display_debug_pubnames_worker (section
, file
, 1);
3860 display_debug_macinfo (struct dwarf_section
*section
,
3861 void *file ATTRIBUTE_UNUSED
)
3863 unsigned char *start
= section
->start
;
3864 unsigned char *end
= start
+ section
->size
;
3865 unsigned char *curr
= start
;
3866 unsigned int bytes_read
;
3867 enum dwarf_macinfo_record_type op
;
3869 printf (_("Contents of the %s section:\n\n"), section
->name
);
3873 unsigned int lineno
;
3874 const unsigned char *string
;
3876 op
= (enum dwarf_macinfo_record_type
) *curr
;
3881 case DW_MACINFO_start_file
:
3883 unsigned int filenum
;
3885 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3887 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3890 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3895 case DW_MACINFO_end_file
:
3896 printf (_(" DW_MACINFO_end_file\n"));
3899 case DW_MACINFO_define
:
3900 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3903 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3904 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3908 case DW_MACINFO_undef
:
3909 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3912 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3913 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3917 case DW_MACINFO_vendor_ext
:
3919 unsigned int constant
;
3921 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3924 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3925 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3935 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3936 filename and dirname corresponding to file name table entry with index
3937 FILEIDX. Return NULL on failure. */
3939 static unsigned char *
3940 get_line_filename_and_dirname (dwarf_vma line_offset
,
3942 unsigned char **dir_name
)
3944 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3945 unsigned char *hdrptr
, *dirtable
, *file_name
;
3946 unsigned int offset_size
, initial_length_size
;
3947 unsigned int version
, opcode_base
, bytes_read
;
3948 dwarf_vma length
, diridx
;
3949 const unsigned char * end
;
3952 if (section
->start
== NULL
3953 || line_offset
>= section
->size
3957 hdrptr
= section
->start
+ line_offset
;
3958 end
= section
->start
+ section
->size
;
3960 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3961 if (length
== 0xffffffff)
3963 /* This section is 64-bit DWARF 3. */
3964 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3966 initial_length_size
= 12;
3971 initial_length_size
= 4;
3973 if (length
+ initial_length_size
> section
->size
)
3976 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3977 if (version
!= 2 && version
!= 3 && version
!= 4)
3979 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3981 hdrptr
++; /* Skip max_ops_per_insn. */
3982 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3984 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3985 if (opcode_base
== 0)
3988 hdrptr
+= opcode_base
- 1;
3990 /* Skip over dirname table. */
3991 while (*hdrptr
!= '\0')
3992 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3993 hdrptr
++; /* Skip the NUL at the end of the table. */
3994 /* Now skip over preceding filename table entries. */
3995 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3997 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3998 read_uleb128 (hdrptr
, &bytes_read
, end
);
3999 hdrptr
+= bytes_read
;
4000 read_uleb128 (hdrptr
, &bytes_read
, end
);
4001 hdrptr
+= bytes_read
;
4002 read_uleb128 (hdrptr
, &bytes_read
, end
);
4003 hdrptr
+= bytes_read
;
4005 if (hdrptr
== end
|| *hdrptr
== '\0')
4008 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4009 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
4012 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
4013 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
4014 if (*dirtable
== '\0')
4016 *dir_name
= dirtable
;
4021 display_debug_macro (struct dwarf_section
*section
,
4024 unsigned char *start
= section
->start
;
4025 unsigned char *end
= start
+ section
->size
;
4026 unsigned char *curr
= start
;
4027 unsigned char *extended_op_buf
[256];
4028 unsigned int bytes_read
;
4030 load_debug_section (str
, file
);
4031 load_debug_section (line
, file
);
4033 printf (_("Contents of the %s section:\n\n"), section
->name
);
4037 unsigned int lineno
, version
, flags
;
4038 unsigned int offset_size
= 4;
4039 const unsigned char *string
;
4040 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
4041 unsigned char **extended_ops
= NULL
;
4043 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
4046 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4051 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
4054 printf (_(" Offset: 0x%lx\n"),
4055 (unsigned long) sec_offset
);
4056 printf (_(" Version: %d\n"), version
);
4057 printf (_(" Offset size: %d\n"), offset_size
);
4060 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
4061 printf (_(" Offset into .debug_line: 0x%lx\n"),
4062 (unsigned long) line_offset
);
4066 unsigned int i
, count
, op
;
4069 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
4071 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
4072 extended_ops
= extended_op_buf
;
4075 printf (_(" Extension opcode arguments:\n"));
4076 for (i
= 0; i
< count
; i
++)
4078 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4079 extended_ops
[op
] = curr
;
4080 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
4083 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
4086 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
4087 for (n
= 0; n
< nargs
; n
++)
4091 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
4092 printf ("%s%s", get_FORM_name (form
),
4093 n
== nargs
- 1 ? "\n" : ", ");
4103 case DW_FORM_block1
:
4104 case DW_FORM_block2
:
4105 case DW_FORM_block4
:
4107 case DW_FORM_string
:
4109 case DW_FORM_sec_offset
:
4112 error (_("Invalid extension opcode form %s\n"),
4113 get_FORM_name (form
));
4129 error (_(".debug_macro section not zero terminated\n"));
4133 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4139 case DW_MACRO_GNU_start_file
:
4141 unsigned int filenum
;
4142 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4144 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4146 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4149 if ((flags
& 2) == 0)
4150 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4153 = get_line_filename_and_dirname (line_offset
, filenum
,
4155 if (file_name
== NULL
)
4156 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4159 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4161 dir_name
!= NULL
? (const char *) dir_name
: "",
4162 dir_name
!= NULL
? "/" : "", file_name
);
4166 case DW_MACRO_GNU_end_file
:
4167 printf (_(" DW_MACRO_GNU_end_file\n"));
4170 case DW_MACRO_GNU_define
:
4171 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4174 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4175 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4179 case DW_MACRO_GNU_undef
:
4180 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4183 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4184 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4188 case DW_MACRO_GNU_define_indirect
:
4189 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4191 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4192 string
= fetch_indirect_string (offset
);
4193 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4197 case DW_MACRO_GNU_undef_indirect
:
4198 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4200 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4201 string
= fetch_indirect_string (offset
);
4202 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4206 case DW_MACRO_GNU_transparent_include
:
4207 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4208 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4209 (unsigned long) offset
);
4212 case DW_MACRO_GNU_define_indirect_alt
:
4213 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4215 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4216 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4217 lineno
, (unsigned long) offset
);
4220 case DW_MACRO_GNU_undef_indirect_alt
:
4221 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4223 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4224 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4225 lineno
, (unsigned long) offset
);
4228 case DW_MACRO_GNU_transparent_include_alt
:
4229 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4230 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4231 (unsigned long) offset
);
4235 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
4237 error (_(" Unknown macro opcode %02x seen\n"), op
);
4242 /* Skip over unhandled opcodes. */
4244 unsigned char *desc
= extended_ops
[op
];
4245 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
4249 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
4252 printf (_(" DW_MACRO_GNU_%02x -"), op
);
4253 for (n
= 0; n
< nargs
; n
++)
4257 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
4259 = read_and_display_attr_value (0, val
,
4260 curr
, end
, 0, 0, offset_size
,
4261 version
, NULL
, 0, NULL
,
4279 display_debug_abbrev (struct dwarf_section
*section
,
4280 void *file ATTRIBUTE_UNUSED
)
4282 abbrev_entry
*entry
;
4283 unsigned char *start
= section
->start
;
4284 unsigned char *end
= start
+ section
->size
;
4286 printf (_("Contents of the %s section:\n\n"), section
->name
);
4290 unsigned char *last
;
4295 start
= process_abbrev_section (start
, end
);
4297 if (first_abbrev
== NULL
)
4300 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4302 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4306 printf (" %ld %s [%s]\n",
4308 get_TAG_name (entry
->tag
),
4309 entry
->children
? _("has children") : _("no children"));
4311 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4312 printf (" %-18s %s\n",
4313 get_AT_name (attr
->attribute
),
4314 get_FORM_name (attr
->form
));
4324 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4327 display_loc_list (struct dwarf_section
*section
,
4328 unsigned char **start_ptr
,
4329 unsigned int debug_info_entry
,
4330 unsigned long offset
,
4331 unsigned long base_address
,
4334 unsigned char *start
= *start_ptr
;
4335 unsigned char *section_end
= section
->start
+ section
->size
;
4336 unsigned long cu_offset
;
4337 unsigned int pointer_size
;
4338 unsigned int offset_size
;
4343 unsigned short length
;
4344 int need_frame_base
;
4346 if (debug_info_entry
>= num_debug_info_entries
)
4348 warn (_("No debug information available for loc lists of entry: %u\n"),
4353 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4354 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4355 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4356 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4358 if (pointer_size
< 2 || pointer_size
> 8)
4360 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4361 pointer_size
, debug_info_entry
);
4367 if (start
+ 2 * pointer_size
> section_end
)
4369 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4374 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4376 /* Note: we use sign extension here in order to be sure that we can detect
4377 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4378 address will not affect the values that we display since we always show
4379 hex values, and always the bottom 32-bits. */
4380 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4381 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4383 if (begin
== 0 && end
== 0)
4385 printf (_("<End of list>\n"));
4389 /* Check base address specifiers. */
4390 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4393 print_dwarf_vma (begin
, pointer_size
);
4394 print_dwarf_vma (end
, pointer_size
);
4395 printf (_("(base address)\n"));
4399 if (start
+ 2 > section_end
)
4401 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4406 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4408 if (start
+ length
> section_end
)
4410 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4415 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4416 print_dwarf_vma (end
+ base_address
, pointer_size
);
4419 need_frame_base
= decode_location_expression (start
,
4424 cu_offset
, section
);
4427 if (need_frame_base
&& !has_frame_base
)
4428 printf (_(" [without DW_AT_frame_base]"));
4431 fputs (_(" (start == end)"), stdout
);
4432 else if (begin
> end
)
4433 fputs (_(" (start > end)"), stdout
);
4443 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4444 right-adjusted in a field of length LEN, and followed by a space. */
4447 print_addr_index (unsigned int idx
, unsigned int len
)
4449 static char buf
[15];
4450 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4451 printf ("%*s ", len
, buf
);
4454 /* Display a location list from a .dwo section. It uses address indexes rather
4455 than embedded addresses. This code closely follows display_loc_list, but the
4456 two are sufficiently different that combining things is very ugly. */
4459 display_loc_list_dwo (struct dwarf_section
*section
,
4460 unsigned char **start_ptr
,
4461 unsigned int debug_info_entry
,
4462 unsigned long offset
,
4465 unsigned char *start
= *start_ptr
;
4466 unsigned char *section_end
= section
->start
+ section
->size
;
4467 unsigned long cu_offset
;
4468 unsigned int pointer_size
;
4469 unsigned int offset_size
;
4472 unsigned short length
;
4473 int need_frame_base
;
4475 unsigned int bytes_read
;
4477 if (debug_info_entry
>= num_debug_info_entries
)
4479 warn (_("No debug information for loc lists of entry: %u\n"),
4484 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4485 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4486 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4487 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4489 if (pointer_size
< 2 || pointer_size
> 8)
4491 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4492 pointer_size
, debug_info_entry
);
4498 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4500 if (start
>= section_end
)
4502 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4507 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4510 case 0: /* A terminating entry. */
4512 printf (_("<End of list>\n"));
4514 case 1: /* A base-address entry. */
4515 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4516 start
+= bytes_read
;
4517 print_addr_index (idx
, 8);
4519 printf (_("(base address selection entry)\n"));
4521 case 2: /* A start/end entry. */
4522 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4523 start
+= bytes_read
;
4524 print_addr_index (idx
, 8);
4525 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4526 start
+= bytes_read
;
4527 print_addr_index (idx
, 8);
4529 case 3: /* A start/length entry. */
4530 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4531 start
+= bytes_read
;
4532 print_addr_index (idx
, 8);
4533 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4534 printf ("%08x ", idx
);
4536 case 4: /* An offset pair entry. */
4537 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4538 printf ("%08x ", idx
);
4539 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4540 printf ("%08x ", idx
);
4543 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4548 if (start
+ 2 > section_end
)
4550 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4555 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4556 if (start
+ length
> section_end
)
4558 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4564 need_frame_base
= decode_location_expression (start
,
4569 cu_offset
, section
);
4572 if (need_frame_base
&& !has_frame_base
)
4573 printf (_(" [without DW_AT_frame_base]"));
4583 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4585 static dwarf_vma
*loc_offsets
;
4588 loc_offsets_compar (const void *ap
, const void *bp
)
4590 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4591 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4593 return (a
> b
) - (b
> a
);
4597 display_debug_loc (struct dwarf_section
*section
, void *file
)
4599 unsigned char *start
= section
->start
;
4600 unsigned long bytes
;
4601 unsigned char *section_begin
= start
;
4602 unsigned int num_loc_list
= 0;
4603 unsigned long last_offset
= 0;
4604 unsigned int first
= 0;
4608 int seen_first_offset
= 0;
4609 int locs_sorted
= 1;
4610 unsigned char *next
;
4611 unsigned int *array
= NULL
;
4612 const char *suffix
= strrchr (section
->name
, '.');
4615 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4618 bytes
= section
->size
;
4622 printf (_("\nThe %s section is empty.\n"), section
->name
);
4626 if (load_debug_info (file
) == 0)
4628 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4633 /* Check the order of location list in .debug_info section. If
4634 offsets of location lists are in the ascending order, we can
4635 use `debug_information' directly. */
4636 for (i
= 0; i
< num_debug_info_entries
; i
++)
4640 num
= debug_information
[i
].num_loc_offsets
;
4641 if (num
> num_loc_list
)
4644 /* Check if we can use `debug_information' directly. */
4645 if (locs_sorted
&& num
!= 0)
4647 if (!seen_first_offset
)
4649 /* This is the first location list. */
4650 last_offset
= debug_information
[i
].loc_offsets
[0];
4652 seen_first_offset
= 1;
4658 for (; j
< num
; j
++)
4661 debug_information
[i
].loc_offsets
[j
])
4666 last_offset
= debug_information
[i
].loc_offsets
[j
];
4671 if (!seen_first_offset
)
4672 error (_("No location lists in .debug_info section!\n"));
4674 if (debug_information
[first
].num_loc_offsets
> 0
4675 && debug_information
[first
].loc_offsets
[0] != 0)
4676 warn (_("Location lists in %s section start at 0x%s\n"),
4678 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4681 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4682 printf (_("Contents of the %s section:\n\n"), section
->name
);
4683 printf (_(" Offset Begin End Expression\n"));
4685 seen_first_offset
= 0;
4686 for (i
= first
; i
< num_debug_info_entries
; i
++)
4688 unsigned long offset
;
4689 unsigned long base_address
;
4694 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4696 loc_offsets
= debug_information
[i
].loc_offsets
;
4697 qsort (array
, debug_information
[i
].num_loc_offsets
,
4698 sizeof (*array
), loc_offsets_compar
);
4701 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4703 j
= locs_sorted
? k
: array
[k
];
4705 && debug_information
[i
].loc_offsets
[locs_sorted
4706 ? k
- 1 : array
[k
- 1]]
4707 == debug_information
[i
].loc_offsets
[j
])
4709 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4710 offset
= debug_information
[i
].loc_offsets
[j
];
4711 next
= section_begin
+ offset
;
4712 base_address
= debug_information
[i
].base_address
;
4714 if (!seen_first_offset
)
4715 seen_first_offset
= 1;
4719 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4720 (unsigned long) (start
- section_begin
),
4721 (unsigned long) (next
- section_begin
));
4722 else if (start
> next
)
4723 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4724 (unsigned long) (start
- section_begin
),
4725 (unsigned long) (next
- section_begin
));
4729 if (offset
>= bytes
)
4731 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4737 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4739 display_loc_list (section
, &start
, i
, offset
, base_address
,
4744 if (start
< section
->start
+ section
->size
)
4745 warn (_("There are %ld unused bytes at the end of section %s\n"),
4746 (long) (section
->start
+ section
->size
- start
), section
->name
);
4753 display_debug_str (struct dwarf_section
*section
,
4754 void *file ATTRIBUTE_UNUSED
)
4756 unsigned char *start
= section
->start
;
4757 unsigned long bytes
= section
->size
;
4758 dwarf_vma addr
= section
->address
;
4762 printf (_("\nThe %s section is empty.\n"), section
->name
);
4766 printf (_("Contents of the %s section:\n\n"), section
->name
);
4774 lbytes
= (bytes
> 16 ? 16 : bytes
);
4776 printf (" 0x%8.8lx ", (unsigned long) addr
);
4778 for (j
= 0; j
< 16; j
++)
4781 printf ("%2.2x", start
[j
]);
4789 for (j
= 0; j
< lbytes
; j
++)
4792 if (k
>= ' ' && k
< 0x80)
4811 display_debug_info (struct dwarf_section
*section
, void *file
)
4813 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4817 display_debug_types (struct dwarf_section
*section
, void *file
)
4819 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4823 display_trace_info (struct dwarf_section
*section
, void *file
)
4825 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4829 display_debug_aranges (struct dwarf_section
*section
,
4830 void *file ATTRIBUTE_UNUSED
)
4832 unsigned char *start
= section
->start
;
4833 unsigned char *end
= start
+ section
->size
;
4835 printf (_("Contents of the %s section:\n\n"), section
->name
);
4837 /* It does not matter if this load fails,
4838 we test for that later on. */
4839 load_debug_info (file
);
4843 unsigned char *hdrptr
;
4844 DWARF2_Internal_ARange arange
;
4845 unsigned char *addr_ranges
;
4848 unsigned char address_size
;
4850 unsigned int offset_size
;
4851 unsigned int initial_length_size
;
4855 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4856 if (arange
.ar_length
== 0xffffffff)
4858 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4860 initial_length_size
= 12;
4865 initial_length_size
= 4;
4868 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4869 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4871 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4872 && num_debug_info_entries
> 0
4873 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4874 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4875 (unsigned long) arange
.ar_info_offset
, section
->name
);
4877 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4878 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4880 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4882 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4886 printf (_(" Length: %ld\n"),
4887 (long) arange
.ar_length
);
4888 printf (_(" Version: %d\n"), arange
.ar_version
);
4889 printf (_(" Offset into .debug_info: 0x%lx\n"),
4890 (unsigned long) arange
.ar_info_offset
);
4891 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4892 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4894 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4896 /* PR 17512: file: 001-108546-0.001:0.1. */
4897 if (address_size
== 0 || address_size
> 8)
4899 error (_("Invalid address size in %s section!\n"),
4904 /* The DWARF spec does not require that the address size be a power
4905 of two, but we do. This will have to change if we ever encounter
4906 an uneven architecture. */
4907 if ((address_size
& (address_size
- 1)) != 0)
4909 warn (_("Pointer size + Segment size is not a power of two.\n"));
4913 if (address_size
> 4)
4914 printf (_("\n Address Length\n"));
4916 printf (_("\n Address Length\n"));
4918 addr_ranges
= hdrptr
;
4920 /* Must pad to an alignment boundary that is twice the address size. */
4921 excess
= (hdrptr
- start
) % (2 * address_size
);
4923 addr_ranges
+= (2 * address_size
) - excess
;
4925 start
+= arange
.ar_length
+ initial_length_size
;
4927 while (addr_ranges
+ 2 * address_size
<= start
)
4929 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4930 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4933 print_dwarf_vma (address
, address_size
);
4934 print_dwarf_vma (length
, address_size
);
4944 /* Comparison function for qsort. */
4946 comp_addr_base (const void * v0
, const void * v1
)
4948 debug_info
* info0
= (debug_info
*) v0
;
4949 debug_info
* info1
= (debug_info
*) v1
;
4950 return info0
->addr_base
- info1
->addr_base
;
4953 /* Display the debug_addr section. */
4955 display_debug_addr (struct dwarf_section
*section
,
4958 debug_info
**debug_addr_info
;
4959 unsigned char *entry
;
4964 if (section
->size
== 0)
4966 printf (_("\nThe %s section is empty.\n"), section
->name
);
4970 if (load_debug_info (file
) == 0)
4972 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4977 printf (_("Contents of the %s section:\n\n"), section
->name
);
4979 /* PR 17531: file: cf38d01b.
4980 We use xcalloc because a corrupt file may not have initialised all of the
4981 fields in the debug_info structure, which means that the sort below might
4982 try to move uninitialised data. */
4983 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
4984 sizeof (debug_info
*));
4987 for (i
= 0; i
< num_debug_info_entries
; i
++)
4988 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4990 /* PR 17531: file: cf38d01b. */
4991 if (debug_information
[i
].addr_base
>= section
->size
)
4992 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
4993 (unsigned long) debug_information
[i
].addr_base
, i
);
4995 debug_addr_info
[count
++] = debug_information
+ i
;
4998 /* Add a sentinel to make iteration convenient. */
4999 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
5000 debug_addr_info
[count
]->addr_base
= section
->size
;
5001 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
5003 for (i
= 0; i
< count
; i
++)
5006 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
5008 printf (_(" For compilation unit at offset 0x%s:\n"),
5009 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
5011 printf (_("\tIndex\tAddress\n"));
5012 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
5013 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
5017 dwarf_vma base
= byte_get (entry
, address_size
);
5018 printf (_("\t%d:\t"), idx
);
5019 print_dwarf_vma (base
, address_size
);
5021 entry
+= address_size
;
5027 free (debug_addr_info
);
5031 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5033 display_debug_str_offsets (struct dwarf_section
*section
,
5034 void *file ATTRIBUTE_UNUSED
)
5036 if (section
->size
== 0)
5038 printf (_("\nThe %s section is empty.\n"), section
->name
);
5041 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5042 what the offset size is for this section. */
5046 /* Each debug_information[x].range_lists[y] gets this representation for
5047 sorting purposes. */
5051 /* The debug_information[x].range_lists[y] value. */
5052 unsigned long ranges_offset
;
5054 /* Original debug_information to find parameters of the data. */
5055 debug_info
*debug_info_p
;
5058 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5061 range_entry_compar (const void *ap
, const void *bp
)
5063 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
5064 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
5065 const unsigned long a
= a_re
->ranges_offset
;
5066 const unsigned long b
= b_re
->ranges_offset
;
5068 return (a
> b
) - (b
> a
);
5072 display_debug_ranges (struct dwarf_section
*section
,
5073 void *file ATTRIBUTE_UNUSED
)
5075 unsigned char *start
= section
->start
;
5076 unsigned char *last_start
= start
;
5077 unsigned long bytes
= section
->size
;
5078 unsigned char *section_begin
= start
;
5079 unsigned char *finish
= start
+ bytes
;
5080 unsigned int num_range_list
, i
;
5081 struct range_entry
*range_entries
, *range_entry_fill
;
5085 printf (_("\nThe %s section is empty.\n"), section
->name
);
5089 if (load_debug_info (file
) == 0)
5091 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5097 for (i
= 0; i
< num_debug_info_entries
; i
++)
5098 num_range_list
+= debug_information
[i
].num_range_lists
;
5100 if (num_range_list
== 0)
5102 /* This can happen when the file was compiled with -gsplit-debug
5103 which removes references to range lists from the primary .o file. */
5104 printf (_("No range lists in .debug_info section.\n"));
5108 range_entries
= (struct range_entry
*)
5109 xmalloc (sizeof (*range_entries
) * num_range_list
);
5110 range_entry_fill
= range_entries
;
5112 for (i
= 0; i
< num_debug_info_entries
; i
++)
5114 debug_info
*debug_info_p
= &debug_information
[i
];
5117 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
5119 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
5120 range_entry_fill
->debug_info_p
= debug_info_p
;
5125 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
5126 range_entry_compar
);
5128 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
5129 warn (_("Range lists in %s section start at 0x%lx\n"),
5130 section
->name
, range_entries
[0].ranges_offset
);
5132 printf (_("Contents of the %s section:\n\n"), section
->name
);
5133 printf (_(" Offset Begin End\n"));
5135 for (i
= 0; i
< num_range_list
; i
++)
5137 struct range_entry
*range_entry
= &range_entries
[i
];
5138 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
5139 unsigned int pointer_size
;
5140 unsigned long offset
;
5141 unsigned char *next
;
5142 unsigned long base_address
;
5144 pointer_size
= debug_info_p
->pointer_size
;
5145 offset
= range_entry
->ranges_offset
;
5146 next
= section_begin
+ offset
;
5147 base_address
= debug_info_p
->base_address
;
5149 /* PR 17512: file: 001-101485-0.001:0.1. */
5150 if (pointer_size
< 2 || pointer_size
> 8)
5152 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5153 pointer_size
, offset
);
5157 if (dwarf_check
!= 0 && i
> 0)
5160 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5161 (unsigned long) (start
- section_begin
),
5162 (unsigned long) (next
- section_begin
), section
->name
);
5163 else if (start
> next
)
5165 if (next
== last_start
)
5167 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5168 (unsigned long) (start
- section_begin
),
5169 (unsigned long) (next
- section_begin
), section
->name
);
5175 while (start
< finish
)
5180 /* Note: we use sign extension here in order to be sure that
5181 we can detect the -1 escape value. Sign extension into the
5182 top 32 bits of a 32-bit address will not affect the values
5183 that we display since we always show hex values, and always
5184 the bottom 32-bits. */
5185 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
5186 if (start
>= finish
)
5188 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
5190 printf (" %8.8lx ", offset
);
5192 if (begin
== 0 && end
== 0)
5194 printf (_("<End of list>\n"));
5198 /* Check base address specifiers. */
5199 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
5202 print_dwarf_vma (begin
, pointer_size
);
5203 print_dwarf_vma (end
, pointer_size
);
5204 printf ("(base address)\n");
5208 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5209 print_dwarf_vma (end
+ base_address
, pointer_size
);
5212 fputs (_("(start == end)"), stdout
);
5213 else if (begin
> end
)
5214 fputs (_("(start > end)"), stdout
);
5221 free (range_entries
);
5226 typedef struct Frame_Chunk
5228 struct Frame_Chunk
*next
;
5229 unsigned char *chunk_start
;
5231 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5232 short int *col_type
;
5235 unsigned int code_factor
;
5242 unsigned char fde_encoding
;
5243 unsigned char cfa_exp
;
5244 unsigned char ptr_size
;
5245 unsigned char segment_size
;
5249 static const char *const *dwarf_regnames
;
5250 static unsigned int dwarf_regnames_count
;
5252 /* A marker for a col_type that means this column was never referenced
5253 in the frame info. */
5254 #define DW_CFA_unreferenced (-1)
5256 /* Return 0 if no more space is needed, 1 if more space is needed,
5257 -1 for invalid reg. */
5260 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
5262 unsigned int prev
= fc
->ncols
;
5264 if (reg
< (unsigned int) fc
->ncols
)
5267 if (dwarf_regnames_count
5268 && reg
> dwarf_regnames_count
)
5271 fc
->ncols
= reg
+ 1;
5272 /* PR 17512: file: 10450-2643-0.004.
5273 If reg == -1 then this can happen... */
5277 /* PR 17512: file: 2844a11d. */
5278 if (fc
->ncols
> 1024)
5280 error (_("Unfeasibly large register number: %u\n"), reg
);
5282 /* FIXME: 1024 is an arbitrary limit. Increase it if
5283 we ever encounter a valid binary that exceeds it. */
5287 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
5288 sizeof (short int));
5289 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
5290 /* PR 17512: file:002-10025-0.005. */
5291 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
5293 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5299 while (prev
< fc
->ncols
)
5301 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
5302 fc
->col_offset
[prev
] = 0;
5308 static const char *const dwarf_regnames_i386
[] =
5310 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5311 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5312 "eip", "eflags", NULL
, /* 8 - 10 */
5313 "st0", "st1", "st2", "st3", /* 11 - 14 */
5314 "st4", "st5", "st6", "st7", /* 15 - 18 */
5315 NULL
, NULL
, /* 19 - 20 */
5316 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5317 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5318 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5319 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5320 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5321 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5322 "tr", "ldtr", /* 48 - 49 */
5323 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5324 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5325 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5326 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5327 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5328 NULL
, NULL
, NULL
, /* 90 - 92 */
5329 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5333 init_dwarf_regnames_i386 (void)
5335 dwarf_regnames
= dwarf_regnames_i386
;
5336 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5339 static const char *const dwarf_regnames_x86_64
[] =
5341 "rax", "rdx", "rcx", "rbx",
5342 "rsi", "rdi", "rbp", "rsp",
5343 "r8", "r9", "r10", "r11",
5344 "r12", "r13", "r14", "r15",
5346 "xmm0", "xmm1", "xmm2", "xmm3",
5347 "xmm4", "xmm5", "xmm6", "xmm7",
5348 "xmm8", "xmm9", "xmm10", "xmm11",
5349 "xmm12", "xmm13", "xmm14", "xmm15",
5350 "st0", "st1", "st2", "st3",
5351 "st4", "st5", "st6", "st7",
5352 "mm0", "mm1", "mm2", "mm3",
5353 "mm4", "mm5", "mm6", "mm7",
5355 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5356 "fs.base", "gs.base", NULL
, NULL
,
5358 "mxcsr", "fcw", "fsw",
5359 "xmm16", "xmm17", "xmm18", "xmm19",
5360 "xmm20", "xmm21", "xmm22", "xmm23",
5361 "xmm24", "xmm25", "xmm26", "xmm27",
5362 "xmm28", "xmm29", "xmm30", "xmm31",
5363 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5364 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5365 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5366 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5367 NULL
, NULL
, NULL
, /* 115 - 117 */
5368 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5372 init_dwarf_regnames_x86_64 (void)
5374 dwarf_regnames
= dwarf_regnames_x86_64
;
5375 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5378 static const char *const dwarf_regnames_aarch64
[] =
5380 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5381 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5382 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5383 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5384 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5385 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5386 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5387 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5388 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5389 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5390 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5391 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5395 init_dwarf_regnames_aarch64 (void)
5397 dwarf_regnames
= dwarf_regnames_aarch64
;
5398 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
5402 init_dwarf_regnames (unsigned int e_machine
)
5408 init_dwarf_regnames_i386 ();
5414 init_dwarf_regnames_x86_64 ();
5418 init_dwarf_regnames_aarch64 ();
5427 regname (unsigned int regno
, int row
)
5429 static char reg
[64];
5431 && regno
< dwarf_regnames_count
5432 && dwarf_regnames
[regno
] != NULL
)
5435 return dwarf_regnames
[regno
];
5436 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5437 dwarf_regnames
[regno
]);
5440 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5445 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
5450 if (*max_regs
< fc
->ncols
)
5451 *max_regs
= fc
->ncols
;
5453 if (*need_col_headers
)
5455 static const char *sloc
= " LOC";
5457 *need_col_headers
= 0;
5459 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5461 for (r
= 0; r
< *max_regs
; r
++)
5462 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5467 printf ("%-5s ", regname (r
, 1));
5473 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5475 strcpy (tmp
, "exp");
5477 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5478 printf ("%-8s ", tmp
);
5480 for (r
= 0; r
< fc
->ncols
; r
++)
5482 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5484 switch (fc
->col_type
[r
])
5486 case DW_CFA_undefined
:
5489 case DW_CFA_same_value
:
5493 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5495 case DW_CFA_val_offset
:
5496 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5498 case DW_CFA_register
:
5499 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5501 case DW_CFA_expression
:
5502 strcpy (tmp
, "exp");
5504 case DW_CFA_val_expression
:
5505 strcpy (tmp
, "vexp");
5508 strcpy (tmp
, "n/a");
5511 printf ("%-5s ", tmp
);
5517 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5518 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5519 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5521 static unsigned char *
5522 read_cie (unsigned char *start
, unsigned char *end
,
5523 Frame_Chunk
**p_cie
, int *p_version
,
5524 unsigned long *p_aug_len
, unsigned char **p_aug
)
5528 unsigned int length_return
;
5529 unsigned char *augmentation_data
= NULL
;
5530 unsigned long augmentation_data_len
= 0;
5533 /* PR 17512: file: 001-228113-0.004. */
5537 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5538 memset (fc
, 0, sizeof (Frame_Chunk
));
5540 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5541 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5545 fc
->augmentation
= (char *) start
;
5546 /* PR 17512: file: 001-228113-0.004.
5547 Skip past augmentation name, but avoid running off the end of the data. */
5549 if (* start
++ == '\0')
5553 warn (_("No terminator for augmentation name\n"));
5557 if (strcmp (fc
->augmentation
, "eh") == 0)
5558 start
+= eh_addr_size
;
5562 GET (fc
->ptr_size
, 1);
5563 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
5565 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
5569 GET (fc
->segment_size
, 1);
5570 /* PR 17512: file: e99d2804. */
5571 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
5573 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
5577 eh_addr_size
= fc
->ptr_size
;
5581 fc
->ptr_size
= eh_addr_size
;
5582 fc
->segment_size
= 0;
5584 fc
->code_factor
= LEB ();
5585 fc
->data_factor
= SLEB ();
5595 if (fc
->augmentation
[0] == 'z')
5597 augmentation_data_len
= LEB ();
5598 augmentation_data
= start
;
5599 start
+= augmentation_data_len
;
5600 /* PR 17512: file: 11042-2589-0.004. */
5603 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len
);
5608 if (augmentation_data_len
)
5612 unsigned char *qend
;
5614 p
= (unsigned char *) fc
->augmentation
+ 1;
5615 q
= augmentation_data
;
5616 qend
= q
+ augmentation_data_len
;
5618 /* PR 17531: file: 015adfaa. */
5621 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len
);
5622 augmentation_data_len
= 0;
5625 while (p
< end
&& q
< augmentation_data
+ augmentation_data_len
)
5630 q
+= 1 + size_of_encoded_value (*q
);
5632 fc
->fde_encoding
= *q
++;
5639 /* Note - it is OK if this loop terminates with q < qend.
5640 Padding may have been inserted to align the end of the CIE. */
5645 *p_version
= version
;
5648 *p_aug_len
= augmentation_data_len
;
5649 *p_aug
= augmentation_data
;
5655 display_debug_frames (struct dwarf_section
*section
,
5656 void *file ATTRIBUTE_UNUSED
)
5658 unsigned char *start
= section
->start
;
5659 unsigned char *end
= start
+ section
->size
;
5660 unsigned char *section_start
= start
;
5661 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
5662 Frame_Chunk
*remembered_state
= 0;
5664 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5665 unsigned int length_return
;
5666 unsigned int max_regs
= 0;
5667 const char *bad_reg
= _("bad register: ");
5668 unsigned int saved_eh_addr_size
= eh_addr_size
;
5670 printf (_("Contents of the %s section:\n"), section
->name
);
5674 unsigned char *saved_start
;
5675 unsigned char *block_end
;
5680 int need_col_headers
= 1;
5681 unsigned char *augmentation_data
= NULL
;
5682 unsigned long augmentation_data_len
= 0;
5683 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5684 unsigned int offset_size
;
5685 unsigned int initial_length_size
;
5687 saved_start
= start
;
5689 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5693 printf ("\n%08lx ZERO terminator\n\n",
5694 (unsigned long)(saved_start
- section_start
));
5695 /* Skip any zero terminators that directly follow.
5696 A corrupt section size could have loaded a whole
5697 slew of zero filled memory bytes. eg
5698 PR 17512: file: 070-19381-0.004. */
5699 while (start
< end
&& * start
== 0)
5704 if (length
== 0xffffffff)
5706 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5708 initial_length_size
= 12;
5713 initial_length_size
= 4;
5716 block_end
= saved_start
+ length
+ initial_length_size
;
5717 if (block_end
> end
|| block_end
< start
)
5719 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5720 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5721 (unsigned long) (saved_start
- section_start
));
5725 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5727 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5728 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5733 start
= read_cie (start
, end
, &cie
, &version
,
5734 &augmentation_data_len
, &augmentation_data
);
5735 /* PR 17512: file: 027-135133-0.005. */
5742 fc
->chunk_start
= saved_start
;
5743 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5746 if (frame_need_space (fc
, mreg
) < 0)
5748 if (fc
->fde_encoding
)
5749 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5751 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5752 print_dwarf_vma (length
, fc
->ptr_size
);
5753 print_dwarf_vma (cie_id
, offset_size
);
5755 if (do_debug_frames_interp
)
5757 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5758 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5763 printf (" Version: %d\n", version
);
5764 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5767 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5768 printf (" Segment Size: %u\n", fc
->segment_size
);
5770 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5771 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5772 printf (" Return address column: %d\n", fc
->ra
);
5774 if (augmentation_data_len
)
5778 printf (" Augmentation data: ");
5779 for (i
= 0; i
< augmentation_data_len
; ++i
)
5780 /* FIXME: If do_wide is FALSE, then we should
5781 add carriage returns at 80 columns... */
5782 printf (" %02x", augmentation_data
[i
]);
5790 unsigned char *look_for
;
5791 static Frame_Chunk fde_fc
;
5792 unsigned long segment_selector
;
5796 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
5797 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
5800 look_for
= section_start
+ cie_id
;
5802 if (look_for
<= saved_start
)
5804 for (cie
= chunks
; cie
; cie
= cie
->next
)
5805 if (cie
->chunk_start
== look_for
)
5810 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
5811 if (cie
->chunk_start
== look_for
)
5815 unsigned int off_size
;
5816 unsigned char *cie_scan
;
5818 cie_scan
= look_for
;
5820 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
5821 if (length
== 0xffffffff)
5823 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
5830 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
5833 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
5834 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
5839 read_cie (cie_scan
, end
, &cie
, &version
,
5840 &augmentation_data_len
, &augmentation_data
);
5841 /* PR 17512: file: 3450-2098-0.004. */
5844 warn (_("Failed to read CIE information\n"));
5847 cie
->next
= forward_refs
;
5849 cie
->chunk_start
= look_for
;
5850 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5853 if (frame_need_space (cie
, mreg
) < 0)
5855 warn (_("Invalid max register\n"));
5858 if (cie
->fde_encoding
)
5860 = size_of_encoded_value (cie
->fde_encoding
);
5867 memset (fc
, 0, sizeof (Frame_Chunk
));
5871 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5872 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5873 (unsigned long) (saved_start
- section_start
));
5875 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5876 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5877 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
5879 warn (_("Invalid max register\n"));
5883 fc
->augmentation
= "";
5884 fc
->fde_encoding
= 0;
5885 fc
->ptr_size
= eh_addr_size
;
5886 fc
->segment_size
= 0;
5890 fc
->ncols
= cie
->ncols
;
5891 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5892 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5893 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5894 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5895 fc
->augmentation
= cie
->augmentation
;
5896 fc
->ptr_size
= cie
->ptr_size
;
5897 eh_addr_size
= cie
->ptr_size
;
5898 fc
->segment_size
= cie
->segment_size
;
5899 fc
->code_factor
= cie
->code_factor
;
5900 fc
->data_factor
= cie
->data_factor
;
5901 fc
->cfa_reg
= cie
->cfa_reg
;
5902 fc
->cfa_offset
= cie
->cfa_offset
;
5904 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
5906 warn (_("Invalid max register\n"));
5909 fc
->fde_encoding
= cie
->fde_encoding
;
5912 if (fc
->fde_encoding
)
5913 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5915 segment_selector
= 0;
5916 if (fc
->segment_size
)
5917 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5919 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
5921 /* FIXME: It appears that sometimes the final pc_range value is
5922 encoded in less than encoded_ptr_size bytes. See the x86_64
5923 run of the "objcopy on compressed debug sections" test for an
5925 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5927 if (cie
->augmentation
[0] == 'z')
5929 augmentation_data_len
= LEB ();
5930 augmentation_data
= start
;
5931 start
+= augmentation_data_len
;
5932 /* PR 17512: file: 722-8446-0.004. */
5933 if (start
>= end
|| ((signed long) augmentation_data_len
) < 0)
5935 warn (_("Corrupt augmentation data length: %lx\n"),
5936 augmentation_data_len
);
5938 augmentation_data
= NULL
;
5939 augmentation_data_len
= 0;
5943 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5944 (unsigned long)(saved_start
- section_start
),
5945 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
5946 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5947 (unsigned long)(cie
->chunk_start
- section_start
));
5949 if (fc
->segment_size
)
5950 printf ("%04lx:", segment_selector
);
5953 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
5954 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
5956 if (! do_debug_frames_interp
&& augmentation_data_len
)
5960 printf (" Augmentation data: ");
5961 for (i
= 0; i
< augmentation_data_len
; ++i
)
5962 printf (" %02x", augmentation_data
[i
]);
5968 /* At this point, fc is the current chunk, cie (if any) is set, and
5969 we're about to interpret instructions for the chunk. */
5970 /* ??? At present we need to do this always, since this sizes the
5971 fc->col_type and fc->col_offset arrays, which we write into always.
5972 We should probably split the interpreted and non-interpreted bits
5973 into two different routines, since there's so much that doesn't
5974 really overlap between them. */
5975 if (1 || do_debug_frames_interp
)
5977 /* Start by making a pass over the chunk, allocating storage
5978 and taking note of what registers are used. */
5979 unsigned char *tmp
= start
;
5981 while (start
< block_end
)
5983 unsigned int reg
, op
, opa
;
5985 unsigned char * new_start
;
5992 /* Warning: if you add any more cases to this switch, be
5993 sure to add them to the corresponding switch below. */
5996 case DW_CFA_advance_loc
:
6000 if (frame_need_space (fc
, opa
) >= 0)
6001 fc
->col_type
[opa
] = DW_CFA_undefined
;
6003 case DW_CFA_restore
:
6004 if (frame_need_space (fc
, opa
) >= 0)
6005 fc
->col_type
[opa
] = DW_CFA_undefined
;
6007 case DW_CFA_set_loc
:
6008 start
+= encoded_ptr_size
;
6010 case DW_CFA_advance_loc1
:
6013 case DW_CFA_advance_loc2
:
6016 case DW_CFA_advance_loc4
:
6019 case DW_CFA_offset_extended
:
6020 case DW_CFA_val_offset
:
6021 reg
= LEB (); LEB ();
6022 if (frame_need_space (fc
, reg
) >= 0)
6023 fc
->col_type
[reg
] = DW_CFA_undefined
;
6025 case DW_CFA_restore_extended
:
6027 if (frame_need_space (fc
, reg
) >= 0)
6028 fc
->col_type
[reg
] = DW_CFA_undefined
;
6030 case DW_CFA_undefined
:
6032 if (frame_need_space (fc
, reg
) >= 0)
6033 fc
->col_type
[reg
] = DW_CFA_undefined
;
6035 case DW_CFA_same_value
:
6037 if (frame_need_space (fc
, reg
) >= 0)
6038 fc
->col_type
[reg
] = DW_CFA_undefined
;
6040 case DW_CFA_register
:
6041 reg
= LEB (); LEB ();
6042 if (frame_need_space (fc
, reg
) >= 0)
6043 fc
->col_type
[reg
] = DW_CFA_undefined
;
6045 case DW_CFA_def_cfa
:
6048 case DW_CFA_def_cfa_register
:
6051 case DW_CFA_def_cfa_offset
:
6054 case DW_CFA_def_cfa_expression
:
6056 new_start
= start
+ temp
;
6057 if (new_start
< start
)
6059 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
6065 case DW_CFA_expression
:
6066 case DW_CFA_val_expression
:
6069 new_start
= start
+ temp
;
6070 if (new_start
< start
)
6072 /* PR 17512: file:306-192417-0.005. */
6073 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
6078 if (frame_need_space (fc
, reg
) >= 0)
6079 fc
->col_type
[reg
] = DW_CFA_undefined
;
6081 case DW_CFA_offset_extended_sf
:
6082 case DW_CFA_val_offset_sf
:
6083 reg
= LEB (); SLEB ();
6084 if (frame_need_space (fc
, reg
) >= 0)
6085 fc
->col_type
[reg
] = DW_CFA_undefined
;
6087 case DW_CFA_def_cfa_sf
:
6090 case DW_CFA_def_cfa_offset_sf
:
6093 case DW_CFA_MIPS_advance_loc8
:
6096 case DW_CFA_GNU_args_size
:
6099 case DW_CFA_GNU_negative_offset_extended
:
6100 reg
= LEB (); LEB ();
6101 if (frame_need_space (fc
, reg
) >= 0)
6102 fc
->col_type
[reg
] = DW_CFA_undefined
;
6111 /* Now we know what registers are used, make a second pass over
6112 the chunk, this time actually printing out the info. */
6114 while (start
< block_end
)
6116 unsigned char * tmp
;
6118 unsigned long ul
, reg
, roffs
;
6122 const char *reg_prefix
= "";
6129 /* Warning: if you add any more cases to this switch, be
6130 sure to add them to the corresponding switch above. */
6133 case DW_CFA_advance_loc
:
6134 if (do_debug_frames_interp
)
6135 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6137 printf (" DW_CFA_advance_loc: %d to %s\n",
6138 opa
* fc
->code_factor
,
6139 dwarf_vmatoa_1 (NULL
,
6140 fc
->pc_begin
+ opa
* fc
->code_factor
,
6142 fc
->pc_begin
+= opa
* fc
->code_factor
;
6147 if (opa
>= (unsigned int) fc
->ncols
)
6148 reg_prefix
= bad_reg
;
6149 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6150 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6151 reg_prefix
, regname (opa
, 0),
6152 roffs
* fc
->data_factor
);
6153 if (*reg_prefix
== '\0')
6155 fc
->col_type
[opa
] = DW_CFA_offset
;
6156 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
6160 case DW_CFA_restore
:
6161 if (opa
>= (unsigned int) cie
->ncols
6162 || opa
>= (unsigned int) fc
->ncols
)
6163 reg_prefix
= bad_reg
;
6164 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6165 printf (" DW_CFA_restore: %s%s\n",
6166 reg_prefix
, regname (opa
, 0));
6167 if (*reg_prefix
== '\0')
6169 fc
->col_type
[opa
] = cie
->col_type
[opa
];
6170 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
6171 if (do_debug_frames_interp
6172 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
6173 fc
->col_type
[opa
] = DW_CFA_undefined
;
6177 case DW_CFA_set_loc
:
6178 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
6179 if (do_debug_frames_interp
)
6180 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6182 printf (" DW_CFA_set_loc: %s\n",
6183 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
6187 case DW_CFA_advance_loc1
:
6188 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
6189 if (do_debug_frames_interp
)
6190 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6192 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6193 (unsigned long) (ofs
* fc
->code_factor
),
6194 dwarf_vmatoa_1 (NULL
,
6195 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6197 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6200 case DW_CFA_advance_loc2
:
6201 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
6202 if (do_debug_frames_interp
)
6203 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6205 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6206 (unsigned long) (ofs
* fc
->code_factor
),
6207 dwarf_vmatoa_1 (NULL
,
6208 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6210 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6213 case DW_CFA_advance_loc4
:
6214 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
6215 if (do_debug_frames_interp
)
6216 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6218 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6219 (unsigned long) (ofs
* fc
->code_factor
),
6220 dwarf_vmatoa_1 (NULL
,
6221 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6223 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6226 case DW_CFA_offset_extended
:
6229 if (reg
>= (unsigned int) fc
->ncols
)
6230 reg_prefix
= bad_reg
;
6231 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6232 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6233 reg_prefix
, regname (reg
, 0),
6234 roffs
* fc
->data_factor
);
6235 if (*reg_prefix
== '\0')
6237 fc
->col_type
[reg
] = DW_CFA_offset
;
6238 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6242 case DW_CFA_val_offset
:
6245 if (reg
>= (unsigned int) fc
->ncols
)
6246 reg_prefix
= bad_reg
;
6247 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6248 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6249 reg_prefix
, regname (reg
, 0),
6250 roffs
* fc
->data_factor
);
6251 if (*reg_prefix
== '\0')
6253 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6254 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6258 case DW_CFA_restore_extended
:
6260 if (reg
>= (unsigned int) cie
->ncols
6261 || reg
>= (unsigned int) fc
->ncols
)
6262 reg_prefix
= bad_reg
;
6263 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6264 printf (" DW_CFA_restore_extended: %s%s\n",
6265 reg_prefix
, regname (reg
, 0));
6266 if (*reg_prefix
== '\0')
6268 fc
->col_type
[reg
] = cie
->col_type
[reg
];
6269 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
6273 case DW_CFA_undefined
:
6275 if (reg
>= (unsigned int) fc
->ncols
)
6276 reg_prefix
= bad_reg
;
6277 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6278 printf (" DW_CFA_undefined: %s%s\n",
6279 reg_prefix
, regname (reg
, 0));
6280 if (*reg_prefix
== '\0')
6282 fc
->col_type
[reg
] = DW_CFA_undefined
;
6283 fc
->col_offset
[reg
] = 0;
6287 case DW_CFA_same_value
:
6289 if (reg
>= (unsigned int) fc
->ncols
)
6290 reg_prefix
= bad_reg
;
6291 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6292 printf (" DW_CFA_same_value: %s%s\n",
6293 reg_prefix
, regname (reg
, 0));
6294 if (*reg_prefix
== '\0')
6296 fc
->col_type
[reg
] = DW_CFA_same_value
;
6297 fc
->col_offset
[reg
] = 0;
6301 case DW_CFA_register
:
6304 if (reg
>= (unsigned int) fc
->ncols
)
6305 reg_prefix
= bad_reg
;
6306 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6308 printf (" DW_CFA_register: %s%s in ",
6309 reg_prefix
, regname (reg
, 0));
6310 puts (regname (roffs
, 0));
6312 if (*reg_prefix
== '\0')
6314 fc
->col_type
[reg
] = DW_CFA_register
;
6315 fc
->col_offset
[reg
] = roffs
;
6319 case DW_CFA_remember_state
:
6320 if (! do_debug_frames_interp
)
6321 printf (" DW_CFA_remember_state\n");
6322 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6323 rs
->cfa_offset
= fc
->cfa_offset
;
6324 rs
->cfa_reg
= fc
->cfa_reg
;
6326 rs
->cfa_exp
= fc
->cfa_exp
;
6327 rs
->ncols
= fc
->ncols
;
6328 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
6329 sizeof (* rs
->col_type
));
6330 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
6331 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
6332 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
6333 rs
->next
= remembered_state
;
6334 remembered_state
= rs
;
6337 case DW_CFA_restore_state
:
6338 if (! do_debug_frames_interp
)
6339 printf (" DW_CFA_restore_state\n");
6340 rs
= remembered_state
;
6343 remembered_state
= rs
->next
;
6344 fc
->cfa_offset
= rs
->cfa_offset
;
6345 fc
->cfa_reg
= rs
->cfa_reg
;
6347 fc
->cfa_exp
= rs
->cfa_exp
;
6348 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
6350 warn (_("Invalid column number in saved frame state\n"));
6354 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
6355 memcpy (fc
->col_offset
, rs
->col_offset
,
6356 rs
->ncols
* sizeof (* rs
->col_offset
));
6357 free (rs
->col_type
);
6358 free (rs
->col_offset
);
6361 else if (do_debug_frames_interp
)
6362 printf ("Mismatched DW_CFA_restore_state\n");
6365 case DW_CFA_def_cfa
:
6366 fc
->cfa_reg
= LEB ();
6367 fc
->cfa_offset
= LEB ();
6369 if (! do_debug_frames_interp
)
6370 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6371 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6374 case DW_CFA_def_cfa_register
:
6375 fc
->cfa_reg
= LEB ();
6377 if (! do_debug_frames_interp
)
6378 printf (" DW_CFA_def_cfa_register: %s\n",
6379 regname (fc
->cfa_reg
, 0));
6382 case DW_CFA_def_cfa_offset
:
6383 fc
->cfa_offset
= LEB ();
6384 if (! do_debug_frames_interp
)
6385 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
6389 if (! do_debug_frames_interp
)
6390 printf (" DW_CFA_nop\n");
6393 case DW_CFA_def_cfa_expression
:
6395 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6397 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
6400 if (! do_debug_frames_interp
)
6402 printf (" DW_CFA_def_cfa_expression (");
6403 decode_location_expression (start
, eh_addr_size
, 0, -1,
6411 case DW_CFA_expression
:
6414 if (reg
>= (unsigned int) fc
->ncols
)
6415 reg_prefix
= bad_reg
;
6416 /* PR 17512: file: 069-133014-0.006. */
6417 /* PR 17512: file: 98c02eb4. */
6419 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
6421 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
6424 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6426 printf (" DW_CFA_expression: %s%s (",
6427 reg_prefix
, regname (reg
, 0));
6428 decode_location_expression (start
, eh_addr_size
, 0, -1,
6432 if (*reg_prefix
== '\0')
6433 fc
->col_type
[reg
] = DW_CFA_expression
;
6437 case DW_CFA_val_expression
:
6440 if (reg
>= (unsigned int) fc
->ncols
)
6441 reg_prefix
= bad_reg
;
6443 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
6445 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
6448 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6450 printf (" DW_CFA_val_expression: %s%s (",
6451 reg_prefix
, regname (reg
, 0));
6452 decode_location_expression (start
, eh_addr_size
, 0, -1,
6456 if (*reg_prefix
== '\0')
6457 fc
->col_type
[reg
] = DW_CFA_val_expression
;
6461 case DW_CFA_offset_extended_sf
:
6464 if (frame_need_space (fc
, reg
) < 0)
6465 reg_prefix
= bad_reg
;
6466 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6467 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6468 reg_prefix
, regname (reg
, 0),
6469 l
* fc
->data_factor
);
6470 if (*reg_prefix
== '\0')
6472 fc
->col_type
[reg
] = DW_CFA_offset
;
6473 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6477 case DW_CFA_val_offset_sf
:
6480 if (frame_need_space (fc
, reg
) < 0)
6481 reg_prefix
= bad_reg
;
6482 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6483 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6484 reg_prefix
, regname (reg
, 0),
6485 l
* fc
->data_factor
);
6486 if (*reg_prefix
== '\0')
6488 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6489 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6493 case DW_CFA_def_cfa_sf
:
6494 fc
->cfa_reg
= LEB ();
6495 fc
->cfa_offset
= SLEB ();
6496 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6498 if (! do_debug_frames_interp
)
6499 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6500 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6503 case DW_CFA_def_cfa_offset_sf
:
6504 fc
->cfa_offset
= SLEB ();
6505 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6506 if (! do_debug_frames_interp
)
6507 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
6510 case DW_CFA_MIPS_advance_loc8
:
6511 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
6512 if (do_debug_frames_interp
)
6513 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6515 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6516 (unsigned long) (ofs
* fc
->code_factor
),
6517 dwarf_vmatoa_1 (NULL
,
6518 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6520 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6523 case DW_CFA_GNU_window_save
:
6524 if (! do_debug_frames_interp
)
6525 printf (" DW_CFA_GNU_window_save\n");
6528 case DW_CFA_GNU_args_size
:
6530 if (! do_debug_frames_interp
)
6531 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
6534 case DW_CFA_GNU_negative_offset_extended
:
6537 if (frame_need_space (fc
, reg
) < 0)
6538 reg_prefix
= bad_reg
;
6539 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6540 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6541 reg_prefix
, regname (reg
, 0),
6542 l
* fc
->data_factor
);
6543 if (*reg_prefix
== '\0')
6545 fc
->col_type
[reg
] = DW_CFA_offset
;
6546 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6551 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
6552 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
6554 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
6559 if (do_debug_frames_interp
)
6560 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6563 eh_addr_size
= saved_eh_addr_size
;
6576 display_gdb_index (struct dwarf_section
*section
,
6577 void *file ATTRIBUTE_UNUSED
)
6579 unsigned char *start
= section
->start
;
6581 uint32_t cu_list_offset
, tu_list_offset
;
6582 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6583 unsigned int cu_list_elements
, tu_list_elements
;
6584 unsigned int address_table_size
, symbol_table_slots
;
6585 unsigned char *cu_list
, *tu_list
;
6586 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6589 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6591 printf (_("Contents of the %s section:\n"), section
->name
);
6593 if (section
->size
< 6 * sizeof (uint32_t))
6595 warn (_("Truncated header in the %s section.\n"), section
->name
);
6599 version
= byte_get_little_endian (start
, 4);
6600 printf (_("Version %ld\n"), (long) version
);
6602 /* Prior versions are obsolete, and future versions may not be
6603 backwards compatible. */
6604 if (version
< 3 || version
> 8)
6606 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6610 warn (_("The address table data in version 3 may be wrong.\n"));
6612 warn (_("Version 4 does not support case insensitive lookups.\n"));
6614 warn (_("Version 5 does not include inlined functions.\n"));
6616 warn (_("Version 6 does not include symbol attributes.\n"));
6617 /* Version 7 indices generated by Gold have bad type unit references,
6618 PR binutils/15021. But we don't know if the index was generated by
6619 Gold or not, so to avoid worrying users with gdb-generated indices
6620 we say nothing for version 7 here. */
6622 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6623 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6624 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6625 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6626 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6628 if (cu_list_offset
> section
->size
6629 || tu_list_offset
> section
->size
6630 || address_table_offset
> section
->size
6631 || symbol_table_offset
> section
->size
6632 || constant_pool_offset
> section
->size
)
6634 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6638 /* PR 17531: file: 418d0a8a. */
6639 if (tu_list_offset
< cu_list_offset
)
6641 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6642 tu_list_offset
, cu_list_offset
);
6646 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6648 if (address_table_offset
< tu_list_offset
)
6650 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6651 address_table_offset
, tu_list_offset
);
6655 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6657 /* PR 17531: file: 18a47d3d. */
6658 if (symbol_table_offset
< address_table_offset
)
6660 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6661 symbol_table_offset
, address_table_offset
);
6665 address_table_size
= symbol_table_offset
- address_table_offset
;
6667 if (constant_pool_offset
< symbol_table_offset
)
6669 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6670 constant_pool_offset
, symbol_table_offset
);
6674 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6676 cu_list
= start
+ cu_list_offset
;
6677 tu_list
= start
+ tu_list_offset
;
6678 address_table
= start
+ address_table_offset
;
6679 symbol_table
= start
+ symbol_table_offset
;
6680 constant_pool
= start
+ constant_pool_offset
;
6682 if (address_table
+ address_table_size
* (2 + 8 + 4) > section
->start
+ section
->size
)
6684 warn (_("Address table extends beyond end of section.\n"));
6688 printf (_("\nCU table:\n"));
6689 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6691 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6692 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6694 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6695 (unsigned long) cu_offset
,
6696 (unsigned long) (cu_offset
+ cu_length
- 1));
6699 printf (_("\nTU table:\n"));
6700 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6702 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6703 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6704 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6706 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6707 (unsigned long) tu_offset
,
6708 (unsigned long) type_offset
);
6709 print_dwarf_vma (signature
, 8);
6713 printf (_("\nAddress table:\n"));
6714 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
6717 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6718 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6719 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6721 print_dwarf_vma (low
, 8);
6722 print_dwarf_vma (high
, 8);
6723 printf (_("%lu\n"), (unsigned long) cu_index
);
6726 printf (_("\nSymbol table:\n"));
6727 for (i
= 0; i
< symbol_table_slots
; ++i
)
6729 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6730 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6731 uint32_t num_cus
, cu
;
6733 if (name_offset
!= 0
6734 || cu_vector_offset
!= 0)
6737 unsigned char * adr
;
6739 adr
= constant_pool
+ name_offset
;
6740 /* PR 17531: file: 5b7b07ad. */
6741 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
6743 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
6744 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6748 printf ("[%3u] %.*s:", i
,
6749 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
6750 constant_pool
+ name_offset
);
6752 adr
= constant_pool
+ cu_vector_offset
;
6753 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
6755 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
6756 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6757 cu_vector_offset
, i
);
6761 num_cus
= byte_get_little_endian (adr
, 4);
6763 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
6764 if (num_cus
* 4 < num_cus
6765 || adr
>= section
->start
+ section
->size
6766 || adr
< constant_pool
)
6768 printf ("<invalid number of CUs: %d>\n", num_cus
);
6769 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6777 for (j
= 0; j
< num_cus
; ++j
)
6780 gdb_index_symbol_kind kind
;
6782 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6783 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6784 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6785 cu
= GDB_INDEX_CU_VALUE (cu
);
6786 /* Convert to TU number if it's for a type unit. */
6787 if (cu
>= cu_list_elements
/ 2)
6788 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6789 (unsigned long) (cu
- cu_list_elements
/ 2));
6791 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6793 printf (" [%s, %s]",
6794 is_static
? _("static") : _("global"),
6795 get_gdb_index_symbol_kind_name (kind
));
6807 /* Pre-allocate enough space for the CU/TU sets needed. */
6810 prealloc_cu_tu_list (unsigned int nshndx
)
6812 if (shndx_pool
== NULL
)
6814 shndx_pool_size
= nshndx
;
6815 shndx_pool_used
= 0;
6816 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6817 sizeof (unsigned int));
6821 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6822 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6823 sizeof (unsigned int));
6828 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6830 if (shndx_pool_used
>= shndx_pool_size
)
6832 error (_("Internal error: out of space in the shndx pool.\n"));
6835 shndx_pool
[shndx_pool_used
++] = shndx
;
6839 end_cu_tu_entry (void)
6841 if (shndx_pool_used
>= shndx_pool_size
)
6843 error (_("Internal error: out of space in the shndx pool.\n"));
6846 shndx_pool
[shndx_pool_used
++] = 0;
6849 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6852 get_DW_SECT_short_name (unsigned int dw_sect
)
6854 static char buf
[16];
6862 case DW_SECT_ABBREV
:
6868 case DW_SECT_STR_OFFSETS
:
6870 case DW_SECT_MACINFO
:
6878 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6882 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6883 These sections are extensions for Fission.
6884 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6887 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6889 unsigned char *phdr
= section
->start
;
6890 unsigned char *limit
= phdr
+ section
->size
;
6891 unsigned char *phash
;
6892 unsigned char *pindex
;
6893 unsigned char *ppool
;
6894 unsigned int version
;
6895 unsigned int ncols
= 0;
6897 unsigned int nslots
;
6900 dwarf_vma signature_high
;
6901 dwarf_vma signature_low
;
6904 /* PR 17512: file: 002-168123-0.004. */
6907 warn (_("Section %s is empty\n"), section
->name
);
6910 /* PR 17512: file: 002-376-0.004. */
6911 if (section
->size
< 24)
6913 warn (_("Section %s is too small to contain a CU/TU header\n"),
6918 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
6920 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
6921 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
6922 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
6925 pindex
= phash
+ nslots
* 8;
6926 ppool
= pindex
+ nslots
* 4;
6928 /* PR 17531: file: 45d69832. */
6929 if (pindex
< phash
|| ppool
< phdr
|| (pindex
== phash
&& nslots
!= 0))
6931 warn (_("Section %s is too small for %d slots\n"),
6932 section
->name
, nslots
);
6938 printf (_("Contents of the %s section:\n\n"), section
->name
);
6939 printf (_(" Version: %d\n"), version
);
6941 printf (_(" Number of columns: %d\n"), ncols
);
6942 printf (_(" Number of used entries: %d\n"), nused
);
6943 printf (_(" Number of slots: %d\n\n"), nslots
);
6946 if (ppool
> limit
|| ppool
< phdr
)
6948 warn (_("Section %s too small for %d hash table entries\n"),
6949 section
->name
, nslots
);
6956 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6957 for (i
= 0; i
< nslots
; i
++)
6959 unsigned char *shndx_list
;
6962 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
6963 if (signature_high
!= 0 || signature_low
!= 0)
6965 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
6966 shndx_list
= ppool
+ j
* 4;
6967 /* PR 17531: file: 705e010d. */
6968 if (shndx_list
< ppool
)
6970 warn (_("Section index pool located before start of section\n"));
6975 printf (_(" [%3d] Signature: 0x%s Sections: "),
6976 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6977 buf
, sizeof (buf
)));
6980 if (shndx_list
>= limit
)
6982 warn (_("Section %s too small for shndx pool\n"),
6986 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
6990 printf (" %d", shndx
);
6992 add_shndx_to_cu_tu_entry (shndx
);
7004 else if (version
== 2)
7007 unsigned int dw_sect
;
7008 unsigned char *ph
= phash
;
7009 unsigned char *pi
= pindex
;
7010 unsigned char *poffsets
= ppool
+ ncols
* 4;
7011 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
7012 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
7013 bfd_boolean is_tu_index
;
7014 struct cu_tu_set
*this_set
= NULL
;
7016 unsigned char *prow
;
7018 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
7020 /* PR 17531: file: 0dd159bf.
7021 Check for wraparound with an overlarge ncols value. */
7022 if ((unsigned int) ((poffsets
- ppool
) / 4) != ncols
)
7024 warn (_("Overlarge number of columns: %x\n"), ncols
);
7030 warn (_("Section %s too small for offset and size tables\n"),
7037 printf (_(" Offset table\n"));
7038 printf (" slot %-16s ",
7039 is_tu_index
? _("signature") : _("dwo_id"));
7046 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
7052 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
7059 for (j
= 0; j
< ncols
; j
++)
7061 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7062 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
7067 for (i
= 0; i
< nslots
; i
++)
7069 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
7071 SAFE_BYTE_GET (row
, pi
, 4, limit
);
7074 /* PR 17531: file: a05f6ab3. */
7077 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7083 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
7085 prow
= poffsets
+ (row
- 1) * ncols
* 4;
7088 printf (_(" [%3d] 0x%s"),
7089 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7090 buf
, sizeof (buf
)));
7091 for (j
= 0; j
< ncols
; j
++)
7093 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
7095 printf (" %8d", val
);
7098 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7100 /* PR 17531: file: 10796eb3. */
7101 if (dw_sect
>= DW_SECT_MAX
)
7102 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7104 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
7120 printf (_(" Size table\n"));
7121 printf (" slot %-16s ",
7122 is_tu_index
? _("signature") : _("dwo_id"));
7125 for (j
= 0; j
< ncols
; j
++)
7127 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
7129 printf (" %8s", get_DW_SECT_short_name (val
));
7135 for (i
= 0; i
< nslots
; i
++)
7137 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
7139 SAFE_BYTE_GET (row
, pi
, 4, limit
);
7142 prow
= psizes
+ (row
- 1) * ncols
* 4;
7145 printf (_(" [%3d] 0x%s"),
7146 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7147 buf
, sizeof (buf
)));
7149 for (j
= 0; j
< ncols
; j
++)
7151 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
7153 printf (" %8d", val
);
7156 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7157 if (dw_sect
>= DW_SECT_MAX
)
7158 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7160 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
7172 else if (do_display
)
7173 printf (_(" Unsupported version (%d)\n"), version
);
7181 /* Load the CU and TU indexes if present. This will build a list of
7182 section sets that we can use to associate a .debug_info.dwo section
7183 with its associated .debug_abbrev.dwo section in a .dwp file. */
7186 load_cu_tu_indexes (void *file
)
7188 /* If we have already loaded (or tried to load) the CU and TU indexes
7189 then do not bother to repeat the task. */
7190 if (cu_tu_indexes_read
)
7193 if (load_debug_section (dwp_cu_index
, file
))
7194 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
7196 if (load_debug_section (dwp_tu_index
, file
))
7197 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
7199 cu_tu_indexes_read
= 1;
7202 /* Find the set of sections that includes section SHNDX. */
7205 find_cu_tu_set (void *file
, unsigned int shndx
)
7209 load_cu_tu_indexes (file
);
7211 /* Find SHNDX in the shndx pool. */
7212 for (i
= 0; i
< shndx_pool_used
; i
++)
7213 if (shndx_pool
[i
] == shndx
)
7216 if (i
>= shndx_pool_used
)
7219 /* Now backup to find the first entry in the set. */
7220 while (i
> 0 && shndx_pool
[i
- 1] != 0)
7223 return shndx_pool
+ i
;
7226 /* Display a .debug_cu_index or .debug_tu_index section. */
7229 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
7231 return process_cu_tu_index (section
, 1);
7235 display_debug_not_supported (struct dwarf_section
*section
,
7236 void *file ATTRIBUTE_UNUSED
)
7238 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7244 /* Like malloc, but takes two parameters like calloc.
7245 Verifies that the first parameter is not too large.
7246 Note: does *not* initialise the allocated memory to zero. */
7248 cmalloc (size_t nmemb
, size_t size
)
7250 /* Check for overflow. */
7251 if (nmemb
>= ~(size_t) 0 / size
)
7254 return xmalloc (nmemb
* size
);
7257 /* Like xmalloc, but takes two parameters like calloc.
7258 Verifies that the first parameter is not too large.
7259 Note: does *not* initialise the allocated memory to zero. */
7261 xcmalloc (size_t nmemb
, size_t size
)
7263 /* Check for overflow. */
7264 if (nmemb
>= ~(size_t) 0 / size
)
7267 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7272 return xmalloc (nmemb
* size
);
7275 /* Like xrealloc, but takes three parameters.
7276 Verifies that the second parameter is not too large.
7277 Note: does *not* initialise any new memory to zero. */
7279 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
7281 /* Check for overflow. */
7282 if (nmemb
>= ~(size_t) 0 / size
)
7285 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7290 return xrealloc (ptr
, nmemb
* size
);
7293 /* Like xcalloc, but verifies that the first parameter is not too large. */
7295 xcalloc2 (size_t nmemb
, size_t size
)
7297 /* Check for overflow. */
7298 if (nmemb
>= ~(size_t) 0 / size
)
7301 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7306 return xcalloc (nmemb
, size
);
7310 free_debug_memory (void)
7316 for (i
= 0; i
< max
; i
++)
7317 free_debug_section ((enum dwarf_section_display_enum
) i
);
7319 if (debug_information
!= NULL
)
7321 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
7323 for (i
= 0; i
< num_debug_info_entries
; i
++)
7325 if (!debug_information
[i
].max_loc_offsets
)
7327 free (debug_information
[i
].loc_offsets
);
7328 free (debug_information
[i
].have_frame_base
);
7330 if (!debug_information
[i
].max_range_lists
)
7331 free (debug_information
[i
].range_lists
);
7334 free (debug_information
);
7335 debug_information
= NULL
;
7336 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
7341 dwarf_select_sections_by_names (const char *names
)
7345 const char * option
;
7349 debug_dump_long_opts
;
7351 static const debug_dump_long_opts opts_table
[] =
7353 /* Please keep this table alpha- sorted. */
7354 { "Ranges", & do_debug_ranges
, 1 },
7355 { "abbrev", & do_debug_abbrevs
, 1 },
7356 { "addr", & do_debug_addr
, 1 },
7357 { "aranges", & do_debug_aranges
, 1 },
7358 { "cu_index", & do_debug_cu_index
, 1 },
7359 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
7360 { "frames", & do_debug_frames
, 1 },
7361 { "frames-interp", & do_debug_frames_interp
, 1 },
7362 /* The special .gdb_index section. */
7363 { "gdb_index", & do_gdb_index
, 1 },
7364 { "info", & do_debug_info
, 1 },
7365 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
7366 { "loc", & do_debug_loc
, 1 },
7367 { "macro", & do_debug_macinfo
, 1 },
7368 { "pubnames", & do_debug_pubnames
, 1 },
7369 { "pubtypes", & do_debug_pubtypes
, 1 },
7370 /* This entry is for compatability
7371 with earlier versions of readelf. */
7372 { "ranges", & do_debug_aranges
, 1 },
7373 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
7374 { "str", & do_debug_str
, 1 },
7375 /* These trace_* sections are used by Itanium VMS. */
7376 { "trace_abbrev", & do_trace_abbrevs
, 1 },
7377 { "trace_aranges", & do_trace_aranges
, 1 },
7378 { "trace_info", & do_trace_info
, 1 },
7387 const debug_dump_long_opts
* entry
;
7389 for (entry
= opts_table
; entry
->option
; entry
++)
7391 size_t len
= strlen (entry
->option
);
7393 if (strncmp (p
, entry
->option
, len
) == 0
7394 && (p
[len
] == ',' || p
[len
] == '\0'))
7396 * entry
->variable
|= entry
->val
;
7398 /* The --debug-dump=frames-interp option also
7399 enables the --debug-dump=frames option. */
7400 if (do_debug_frames_interp
)
7401 do_debug_frames
= 1;
7408 if (entry
->option
== NULL
)
7410 warn (_("Unrecognized debug option '%s'\n"), p
);
7411 p
= strchr (p
, ',');
7422 dwarf_select_sections_by_letters (const char *letters
)
7424 unsigned int lindex
= 0;
7426 while (letters
[lindex
])
7427 switch (letters
[lindex
++])
7434 do_debug_abbrevs
= 1;
7438 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
7442 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
7446 do_debug_pubnames
= 1;
7450 do_debug_pubtypes
= 1;
7454 do_debug_aranges
= 1;
7458 do_debug_ranges
= 1;
7462 do_debug_frames_interp
= 1;
7464 do_debug_frames
= 1;
7468 do_debug_macinfo
= 1;
7480 warn (_("Unrecognized debug option '%s'\n"), letters
);
7486 dwarf_select_sections_all (void)
7489 do_debug_abbrevs
= 1;
7490 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
7491 do_debug_pubnames
= 1;
7492 do_debug_pubtypes
= 1;
7493 do_debug_aranges
= 1;
7494 do_debug_ranges
= 1;
7495 do_debug_frames
= 1;
7496 do_debug_macinfo
= 1;
7501 do_trace_abbrevs
= 1;
7502 do_trace_aranges
= 1;
7504 do_debug_cu_index
= 1;
7507 struct dwarf_section_display debug_displays
[] =
7509 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0, NULL
},
7510 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7511 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0, NULL
},
7512 display_debug_aranges
, &do_debug_aranges
, 1 },
7513 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0, NULL
},
7514 display_debug_frames
, &do_debug_frames
, 1 },
7515 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
, NULL
},
7516 display_debug_info
, &do_debug_info
, 1 },
7517 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0, NULL
},
7518 display_debug_lines
, &do_debug_lines
, 1 },
7519 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0, NULL
},
7520 display_debug_pubnames
, &do_debug_pubnames
, 0 },
7521 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0, NULL
},
7522 display_debug_gnu_pubnames
, &do_debug_pubnames
, 0 },
7523 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0, NULL
},
7524 display_debug_frames
, &do_debug_frames
, 1 },
7525 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0, NULL
},
7526 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7527 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0, NULL
},
7528 display_debug_macro
, &do_debug_macinfo
, 1 },
7529 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0, NULL
},
7530 display_debug_str
, &do_debug_str
, 0 },
7531 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0, NULL
},
7532 display_debug_loc
, &do_debug_loc
, 1 },
7533 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
},
7534 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
7535 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
},
7536 display_debug_gnu_pubnames
, &do_debug_pubtypes
, 0 },
7537 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0, NULL
},
7538 display_debug_ranges
, &do_debug_ranges
, 1 },
7539 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0, NULL
},
7540 display_debug_not_supported
, NULL
, 0 },
7541 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0, NULL
},
7542 display_debug_not_supported
, NULL
, 0 },
7543 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
, NULL
},
7544 display_debug_types
, &do_debug_info
, 1 },
7545 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0, NULL
},
7546 display_debug_not_supported
, NULL
, 0 },
7547 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7548 display_gdb_index
, &do_gdb_index
, 0 },
7549 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
, NULL
},
7550 display_trace_info
, &do_trace_info
, 1 },
7551 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0, NULL
},
7552 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
7553 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0, NULL
},
7554 display_debug_aranges
, &do_trace_aranges
, 0 },
7555 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
},
7556 display_debug_info
, &do_debug_info
, 1 },
7557 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7558 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7559 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
},
7560 display_debug_types
, &do_debug_info
, 1 },
7561 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7562 display_debug_lines
, &do_debug_lines
, 1 },
7563 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7564 display_debug_loc
, &do_debug_loc
, 1 },
7565 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7566 display_debug_macro
, &do_debug_macinfo
, 1 },
7567 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7568 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7569 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7570 display_debug_str
, &do_debug_str
, 1 },
7571 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0, NULL
},
7572 display_debug_str_offsets
, NULL
, 0 },
7573 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7574 display_debug_str_offsets
, NULL
, 0 },
7575 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0, NULL
},
7576 display_debug_addr
, &do_debug_addr
, 1 },
7577 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7578 display_cu_index
, &do_debug_cu_index
, 0 },
7579 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7580 display_cu_index
, &do_debug_cu_index
, 0 },