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 alloc_num_debug_info_entries
= num_units
;
2312 if (dwarf_start_die
== 0)
2313 printf (_("Contents of the %s section:\n\n"), section
->name
);
2315 load_debug_section (str
, file
);
2316 load_debug_section (str_dwo
, file
);
2317 load_debug_section (str_index
, file
);
2318 load_debug_section (str_index_dwo
, file
);
2319 load_debug_section (debug_addr
, file
);
2322 load_debug_section (abbrev_sec
, file
);
2323 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2325 warn (_("Unable to locate %s section!\n"),
2326 debug_displays
[abbrev_sec
].section
.name
);
2330 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2332 DWARF2_Internal_CompUnit compunit
;
2333 unsigned char *hdrptr
;
2334 unsigned char *tags
;
2335 int level
, last_level
, saved_level
;
2336 dwarf_vma cu_offset
;
2337 unsigned int offset_size
;
2338 int initial_length_size
;
2339 dwarf_vma signature_high
= 0;
2340 dwarf_vma signature_low
= 0;
2341 dwarf_vma type_offset
= 0;
2342 struct cu_tu_set
*this_set
;
2343 dwarf_vma abbrev_base
;
2348 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2350 if (compunit
.cu_length
== 0xffffffff)
2352 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2354 initial_length_size
= 12;
2359 initial_length_size
= 4;
2362 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2364 cu_offset
= start
- section_begin
;
2366 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2368 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2370 if (this_set
== NULL
)
2373 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2377 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2378 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2381 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2382 /* PR 17512: file: 001-108546-0.001:0.1. */
2383 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2385 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2386 compunit
.cu_pointer_size
, offset_size
);
2387 compunit
.cu_pointer_size
= offset_size
;
2392 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2394 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2397 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2398 && num_debug_info_entries
== 0
2401 debug_information
[unit
].cu_offset
= cu_offset
;
2402 debug_information
[unit
].pointer_size
2403 = compunit
.cu_pointer_size
;
2404 debug_information
[unit
].offset_size
= offset_size
;
2405 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2406 debug_information
[unit
].base_address
= 0;
2407 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2408 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2409 debug_information
[unit
].loc_offsets
= NULL
;
2410 debug_information
[unit
].have_frame_base
= NULL
;
2411 debug_information
[unit
].max_loc_offsets
= 0;
2412 debug_information
[unit
].num_loc_offsets
= 0;
2413 debug_information
[unit
].range_lists
= NULL
;
2414 debug_information
[unit
].max_range_lists
= 0;
2415 debug_information
[unit
].num_range_lists
= 0;
2418 if (!do_loc
&& dwarf_start_die
== 0)
2420 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2421 dwarf_vmatoa ("x", cu_offset
));
2422 printf (_(" Length: 0x%s (%s)\n"),
2423 dwarf_vmatoa ("x", compunit
.cu_length
),
2424 offset_size
== 8 ? "64-bit" : "32-bit");
2425 printf (_(" Version: %d\n"), compunit
.cu_version
);
2426 printf (_(" Abbrev Offset: 0x%s\n"),
2427 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2428 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2433 printf (_(" Signature: 0x%s\n"),
2434 dwarf_vmatoa64 (signature_high
, signature_low
,
2435 buf
, sizeof (buf
)));
2436 printf (_(" Type Offset: 0x%s\n"),
2437 dwarf_vmatoa ("x", type_offset
));
2439 if (this_set
!= NULL
)
2441 dwarf_vma
*offsets
= this_set
->section_offsets
;
2442 size_t *sizes
= this_set
->section_sizes
;
2444 printf (_(" Section contributions:\n"));
2445 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2446 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2447 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2448 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2449 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2450 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2451 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2452 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2453 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2454 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2455 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2456 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2460 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2463 warn (_("Debug info is corrupted, length of CU at %s"
2464 " extends beyond end of section (length = %s)\n"),
2465 dwarf_vmatoa ("x", cu_offset
),
2466 dwarf_vmatoa ("x", compunit
.cu_length
));
2471 start
+= compunit
.cu_length
+ initial_length_size
;
2475 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2476 dwarf_vmatoa ("x", cu_offset
));
2480 if (compunit
.cu_version
!= 2
2481 && compunit
.cu_version
!= 3
2482 && compunit
.cu_version
!= 4)
2484 warn (_("CU at offset %s contains corrupt or "
2485 "unsupported version number: %d.\n"),
2486 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2492 /* Process the abbrevs used by this compilation unit. */
2493 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2494 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2495 (unsigned long) compunit
.cu_abbrev_offset
,
2496 (unsigned long) abbrev_size
);
2497 /* PR 17531: file:4bcd9ce9. */
2498 else if ((abbrev_base
+ abbrev_size
)
2499 > debug_displays
[abbrev_sec
].section
.size
)
2500 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2501 (unsigned long) abbrev_base
+ abbrev_size
,
2502 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
2504 process_abbrev_section
2505 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2506 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2507 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2508 + abbrev_base
+ abbrev_size
));
2513 while (tags
< start
)
2515 unsigned int bytes_read
;
2516 unsigned long abbrev_number
;
2517 unsigned long die_offset
;
2518 abbrev_entry
*entry
;
2520 int do_printing
= 1;
2522 die_offset
= tags
- section_begin
;
2524 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2527 /* A null DIE marks the end of a list of siblings or it may also be
2528 a section padding. */
2529 if (abbrev_number
== 0)
2531 /* Check if it can be a section padding for the last CU. */
2532 if (level
== 0 && start
== end
)
2536 for (chk
= tags
; chk
< start
; chk
++)
2543 if (!do_loc
&& die_offset
>= dwarf_start_die
2544 && (dwarf_cutoff_level
== -1
2545 || level
< dwarf_cutoff_level
))
2546 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2552 static unsigned num_bogus_warns
= 0;
2554 if (num_bogus_warns
< 3)
2556 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2557 die_offset
, section
->name
);
2559 if (num_bogus_warns
== 3)
2560 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2563 if (dwarf_start_die
!= 0 && level
< saved_level
)
2570 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2574 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2575 saved_level
= level
;
2576 do_printing
= (dwarf_cutoff_level
== -1
2577 || level
< dwarf_cutoff_level
);
2579 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2580 level
, die_offset
, abbrev_number
);
2581 else if (dwarf_cutoff_level
== -1
2582 || last_level
< dwarf_cutoff_level
)
2583 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2588 /* Scan through the abbreviation list until we reach the
2590 for (entry
= first_abbrev
;
2591 entry
&& entry
->entry
!= abbrev_number
;
2592 entry
= entry
->next
)
2597 if (!do_loc
&& do_printing
)
2602 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2603 die_offset
, abbrev_number
);
2607 if (!do_loc
&& do_printing
)
2608 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2613 need_base_address
= 0;
2615 case DW_TAG_compile_unit
:
2616 need_base_address
= 1;
2618 case DW_TAG_entry_point
:
2619 case DW_TAG_subprogram
:
2620 need_base_address
= 0;
2621 /* Assuming that there is no DW_AT_frame_base. */
2622 have_frame_base
= 0;
2626 for (attr
= entry
->first_attr
;
2627 attr
&& attr
->attribute
;
2632 if (! do_loc
&& do_printing
)
2633 /* Show the offset from where the tag was extracted. */
2634 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2636 if (debug_information
&& unit
< alloc_num_debug_info_entries
)
2637 arg
= debug_information
+ unit
;
2641 tags
= read_and_display_attr (attr
->attribute
,
2646 compunit
.cu_pointer_size
,
2648 compunit
.cu_version
,
2650 do_loc
|| ! do_printing
,
2655 if (entry
->children
)
2660 /* Set num_debug_info_entries here so that it can be used to check if
2661 we need to process .debug_loc and .debug_ranges sections. */
2662 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2663 && num_debug_info_entries
== 0
2666 if (num_units
> alloc_num_debug_info_entries
)
2667 num_debug_info_entries
= alloc_num_debug_info_entries
;
2669 num_debug_info_entries
= num_units
;
2678 /* Locate and scan the .debug_info section in the file and record the pointer
2679 sizes and offsets for the compilation units in it. Usually an executable
2680 will have just one pointer size, but this is not guaranteed, and so we try
2681 not to make any assumptions. Returns zero upon failure, or the number of
2682 compilation units upon success. */
2685 load_debug_info (void * file
)
2687 /* Reset the last pointer size so that we can issue correct error
2688 messages if we are displaying the contents of more than one section. */
2689 last_pointer_size
= 0;
2690 warned_about_missing_comp_units
= FALSE
;
2692 /* If we have already tried and failed to load the .debug_info
2693 section then do not bother to repeat the task. */
2694 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2697 /* If we already have the information there is nothing else to do. */
2698 if (num_debug_info_entries
> 0)
2699 return num_debug_info_entries
;
2701 /* If this is a DWARF package file, load the CU and TU indexes. */
2702 load_cu_tu_indexes (file
);
2704 if (load_debug_section (info
, file
)
2705 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2706 return num_debug_info_entries
;
2708 if (load_debug_section (info_dwo
, file
)
2709 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2711 return num_debug_info_entries
;
2713 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2717 /* Read a DWARF .debug_line section header starting at DATA.
2718 Upon success returns an updated DATA pointer and the LINFO
2719 structure and the END_OF_SEQUENCE pointer will be filled in.
2720 Otherwise returns NULL. */
2722 static unsigned char *
2723 read_debug_line_header (struct dwarf_section
* section
,
2724 unsigned char * data
,
2725 unsigned char * end
,
2726 DWARF2_Internal_LineInfo
* linfo
,
2727 unsigned char ** end_of_sequence
)
2729 unsigned char *hdrptr
;
2730 unsigned int offset_size
;
2731 unsigned int initial_length_size
;
2733 /* Extract information from the Line Number Program Header.
2734 (section 6.2.4 in the Dwarf3 doc). */
2737 /* Get and check the length of the block. */
2738 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2740 if (linfo
->li_length
== 0xffffffff)
2742 /* This section is 64-bit DWARF 3. */
2743 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2745 initial_length_size
= 12;
2750 initial_length_size
= 4;
2753 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2755 /* If the length is just a bias against the initial_length_size then
2756 this means that the field has a relocation against it which has not
2757 been applied. (Ie we are dealing with an object file, not a linked
2758 binary). Do not complain but instead assume that the rest of the
2759 section applies to this particular header. */
2760 if (linfo
->li_length
== - initial_length_size
)
2762 linfo
->li_length
= section
->size
- initial_length_size
;
2766 warn (_("The line info appears to be corrupt - the section is too small\n"));
2771 /* Get and check the version number. */
2772 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2774 if (linfo
->li_version
!= 2
2775 && linfo
->li_version
!= 3
2776 && linfo
->li_version
!= 4)
2778 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2782 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2783 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2785 if (linfo
->li_version
>= 4)
2787 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2789 if (linfo
->li_max_ops_per_insn
== 0)
2791 warn (_("Invalid maximum operations per insn.\n"));
2796 linfo
->li_max_ops_per_insn
= 1;
2798 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2799 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2800 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2801 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2803 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2804 /* PR 17512: file:002-117414-0.004. */
2805 if (* end_of_sequence
> end
)
2807 warn (_("Line length %s extends beyond end of section\n"),
2808 dwarf_vmatoa ("u", linfo
->li_length
));
2809 * end_of_sequence
= end
;
2817 display_debug_lines_raw (struct dwarf_section
*section
,
2818 unsigned char *data
,
2821 unsigned char *start
= section
->start
;
2823 printf (_("Raw dump of debug contents of section %s:\n\n"),
2828 static DWARF2_Internal_LineInfo saved_linfo
;
2829 DWARF2_Internal_LineInfo linfo
;
2830 unsigned char *standard_opcodes
;
2831 unsigned char *end_of_sequence
;
2832 unsigned int last_dir_entry
= 0;
2835 if (const_strneq (section
->name
, ".debug_line.")
2836 /* Note: the following does not apply to .debug_line.dwo sections.
2837 These are full debug_line sections. */
2838 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2840 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2841 section containing just the Line Number Statements. They are
2842 created by the assembler and intended to be used alongside gcc's
2843 -ffunction-sections command line option. When the linker's
2844 garbage collection decides to discard a .text.<foo> section it
2845 can then also discard the line number information in .debug_line.<foo>.
2847 Since the section is a fragment it does not have the details
2848 needed to fill out a LineInfo structure, so instead we use the
2849 details from the last full debug_line section that we processed. */
2850 end_of_sequence
= end
;
2851 standard_opcodes
= NULL
;
2852 linfo
= saved_linfo
;
2853 /* PR 17531: file: 0522b371. */
2854 if (linfo
.li_line_range
== 0)
2856 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2859 reset_state_machine (linfo
.li_default_is_stmt
);
2863 unsigned char * hdrptr
;
2865 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2866 & end_of_sequence
)) == NULL
)
2869 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2870 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2871 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2872 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
2873 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2874 if (linfo
.li_version
>= 4)
2875 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2876 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2877 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2878 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2879 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2881 /* PR 17512: file: 1665-6428-0.004. */
2882 if (linfo
.li_line_range
== 0)
2884 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2885 linfo
.li_line_range
= 1;
2888 reset_state_machine (linfo
.li_default_is_stmt
);
2890 /* Display the contents of the Opcodes table. */
2891 standard_opcodes
= hdrptr
;
2893 /* PR 17512: file: 002-417945-0.004. */
2894 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
2896 warn (_("Line Base extends beyond end of section\n"));
2900 printf (_("\n Opcodes:\n"));
2902 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2903 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2905 /* Display the contents of the Directory table. */
2906 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2909 printf (_("\n The Directory Table is empty.\n"));
2912 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2913 (long)(data
- start
));
2915 while (data
< end
&& *data
!= 0)
2917 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
2919 data
+= strnlen ((char *) data
, end
- data
) + 1;
2922 /* PR 17512: file: 002-132094-0.004. */
2923 if (data
>= end
- 1)
2927 /* Skip the NUL at the end of the table. */
2930 /* Display the contents of the File Name table. */
2932 printf (_("\n The File Name Table is empty.\n"));
2935 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2936 (long)(data
- start
));
2937 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2939 while (data
< end
&& *data
!= 0)
2941 unsigned char *name
;
2942 unsigned int bytes_read
;
2944 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2946 data
+= strnlen ((char *) data
, end
- data
) + 1;
2949 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2952 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2955 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2957 printf ("%.*s\n", (int)(end
- name
), name
);
2961 warn (_("Corrupt file name table entry\n"));
2967 /* Skip the NUL at the end of the table. */
2970 saved_linfo
= linfo
;
2973 /* Now display the statements. */
2974 if (data
>= end_of_sequence
)
2975 printf (_(" No Line Number Statements.\n"));
2978 printf (_(" Line Number Statements:\n"));
2980 while (data
< end_of_sequence
)
2982 unsigned char op_code
;
2983 dwarf_signed_vma adv
;
2985 unsigned int bytes_read
;
2987 printf (" [0x%08lx]", (long)(data
- start
));
2991 if (op_code
>= linfo
.li_opcode_base
)
2993 op_code
-= linfo
.li_opcode_base
;
2994 uladv
= (op_code
/ linfo
.li_line_range
);
2995 if (linfo
.li_max_ops_per_insn
== 1)
2997 uladv
*= linfo
.li_min_insn_length
;
2998 state_machine_regs
.address
+= uladv
;
2999 printf (_(" Special opcode %d: "
3000 "advance Address by %s to 0x%s"),
3001 op_code
, dwarf_vmatoa ("u", uladv
),
3002 dwarf_vmatoa ("x", state_machine_regs
.address
));
3006 state_machine_regs
.address
3007 += ((state_machine_regs
.op_index
+ uladv
)
3008 / linfo
.li_max_ops_per_insn
)
3009 * linfo
.li_min_insn_length
;
3010 state_machine_regs
.op_index
3011 = (state_machine_regs
.op_index
+ uladv
)
3012 % linfo
.li_max_ops_per_insn
;
3013 printf (_(" Special opcode %d: "
3014 "advance Address by %s to 0x%s[%d]"),
3015 op_code
, dwarf_vmatoa ("u", uladv
),
3016 dwarf_vmatoa ("x", state_machine_regs
.address
),
3017 state_machine_regs
.op_index
);
3019 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3020 state_machine_regs
.line
+= adv
;
3021 printf (_(" and Line by %s to %d\n"),
3022 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
3024 else switch (op_code
)
3026 case DW_LNS_extended_op
:
3027 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3031 printf (_(" Copy\n"));
3034 case DW_LNS_advance_pc
:
3035 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3037 if (linfo
.li_max_ops_per_insn
== 1)
3039 uladv
*= linfo
.li_min_insn_length
;
3040 state_machine_regs
.address
+= uladv
;
3041 printf (_(" Advance PC by %s to 0x%s\n"),
3042 dwarf_vmatoa ("u", uladv
),
3043 dwarf_vmatoa ("x", state_machine_regs
.address
));
3047 state_machine_regs
.address
3048 += ((state_machine_regs
.op_index
+ uladv
)
3049 / linfo
.li_max_ops_per_insn
)
3050 * linfo
.li_min_insn_length
;
3051 state_machine_regs
.op_index
3052 = (state_machine_regs
.op_index
+ uladv
)
3053 % linfo
.li_max_ops_per_insn
;
3054 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3055 dwarf_vmatoa ("u", uladv
),
3056 dwarf_vmatoa ("x", state_machine_regs
.address
),
3057 state_machine_regs
.op_index
);
3061 case DW_LNS_advance_line
:
3062 adv
= read_sleb128 (data
, & bytes_read
, end
);
3064 state_machine_regs
.line
+= adv
;
3065 printf (_(" Advance Line by %s to %d\n"),
3066 dwarf_vmatoa ("d", adv
),
3067 state_machine_regs
.line
);
3070 case DW_LNS_set_file
:
3071 adv
= read_uleb128 (data
, & bytes_read
, end
);
3073 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3074 dwarf_vmatoa ("d", adv
));
3075 state_machine_regs
.file
= adv
;
3078 case DW_LNS_set_column
:
3079 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3081 printf (_(" Set column to %s\n"),
3082 dwarf_vmatoa ("u", uladv
));
3083 state_machine_regs
.column
= uladv
;
3086 case DW_LNS_negate_stmt
:
3087 adv
= state_machine_regs
.is_stmt
;
3089 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3090 state_machine_regs
.is_stmt
= adv
;
3093 case DW_LNS_set_basic_block
:
3094 printf (_(" Set basic block\n"));
3095 state_machine_regs
.basic_block
= 1;
3098 case DW_LNS_const_add_pc
:
3099 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3100 if (linfo
.li_max_ops_per_insn
)
3102 uladv
*= linfo
.li_min_insn_length
;
3103 state_machine_regs
.address
+= uladv
;
3104 printf (_(" Advance PC by constant %s to 0x%s\n"),
3105 dwarf_vmatoa ("u", uladv
),
3106 dwarf_vmatoa ("x", state_machine_regs
.address
));
3110 state_machine_regs
.address
3111 += ((state_machine_regs
.op_index
+ uladv
)
3112 / linfo
.li_max_ops_per_insn
)
3113 * linfo
.li_min_insn_length
;
3114 state_machine_regs
.op_index
3115 = (state_machine_regs
.op_index
+ uladv
)
3116 % linfo
.li_max_ops_per_insn
;
3117 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3118 dwarf_vmatoa ("u", uladv
),
3119 dwarf_vmatoa ("x", state_machine_regs
.address
),
3120 state_machine_regs
.op_index
);
3124 case DW_LNS_fixed_advance_pc
:
3125 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3126 state_machine_regs
.address
+= uladv
;
3127 state_machine_regs
.op_index
= 0;
3128 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3129 dwarf_vmatoa ("u", uladv
),
3130 dwarf_vmatoa ("x", state_machine_regs
.address
));
3133 case DW_LNS_set_prologue_end
:
3134 printf (_(" Set prologue_end to true\n"));
3137 case DW_LNS_set_epilogue_begin
:
3138 printf (_(" Set epilogue_begin to true\n"));
3141 case DW_LNS_set_isa
:
3142 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3144 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3148 printf (_(" Unknown opcode %d with operands: "), op_code
);
3150 if (standard_opcodes
!= NULL
)
3151 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3153 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3155 i
== 1 ? "" : ", ");
3171 unsigned char *name
;
3172 unsigned int directory_index
;
3173 unsigned int modification_date
;
3174 unsigned int length
;
3177 /* Output a decoded representation of the .debug_line section. */
3180 display_debug_lines_decoded (struct dwarf_section
*section
,
3181 unsigned char *data
,
3184 static DWARF2_Internal_LineInfo saved_linfo
;
3186 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3191 /* This loop amounts to one iteration per compilation unit. */
3192 DWARF2_Internal_LineInfo linfo
;
3193 unsigned char *standard_opcodes
;
3194 unsigned char *end_of_sequence
;
3196 File_Entry
*file_table
= NULL
;
3197 unsigned int n_files
= 0;
3198 unsigned char **directory_table
= NULL
;
3199 unsigned int n_directories
= 0;
3201 if (const_strneq (section
->name
, ".debug_line.")
3202 /* Note: the following does not apply to .debug_line.dwo sections.
3203 These are full debug_line sections. */
3204 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3206 /* See comment in display_debug_lines_raw(). */
3207 end_of_sequence
= end
;
3208 standard_opcodes
= NULL
;
3209 linfo
= saved_linfo
;
3210 /* PR 17531: file: 0522b371. */
3211 if (linfo
.li_line_range
== 0)
3213 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3216 reset_state_machine (linfo
.li_default_is_stmt
);
3220 unsigned char *hdrptr
;
3222 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3223 & end_of_sequence
)) == NULL
)
3226 /* PR 17531: file: 0522b371. */
3227 if (linfo
.li_line_range
== 0)
3229 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3230 linfo
.li_line_range
= 1;
3232 reset_state_machine (linfo
.li_default_is_stmt
);
3234 /* Save a pointer to the contents of the Opcodes table. */
3235 standard_opcodes
= hdrptr
;
3237 /* Traverse the Directory table just to count entries. */
3238 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3241 unsigned char *ptr_directory_table
= data
;
3245 data
+= strnlen ((char *) data
, end
- data
) + 1;
3249 /* Go through the directory table again to save the directories. */
3250 directory_table
= (unsigned char **)
3251 xmalloc (n_directories
* sizeof (unsigned char *));
3254 while (*ptr_directory_table
!= 0)
3256 directory_table
[i
] = ptr_directory_table
;
3257 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3258 ptr_directory_table
- end
) + 1;
3262 /* Skip the NUL at the end of the table. */
3265 /* Traverse the File Name table just to count the entries. */
3268 unsigned char *ptr_file_name_table
= data
;
3272 unsigned int bytes_read
;
3274 /* Skip Name, directory index, last modification time and length
3276 data
+= strnlen ((char *) data
, end
- data
) + 1;
3277 read_uleb128 (data
, & bytes_read
, end
);
3279 read_uleb128 (data
, & bytes_read
, end
);
3281 read_uleb128 (data
, & bytes_read
, end
);
3287 /* Go through the file table again to save the strings. */
3288 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3291 while (*ptr_file_name_table
!= 0)
3293 unsigned int bytes_read
;
3295 file_table
[i
].name
= ptr_file_name_table
;
3296 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3297 end
- ptr_file_name_table
) + 1;
3299 /* We are not interested in directory, time or size. */
3300 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3302 ptr_file_name_table
+= bytes_read
;
3303 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3305 ptr_file_name_table
+= bytes_read
;
3306 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3307 ptr_file_name_table
+= bytes_read
;
3312 /* Print the Compilation Unit's name and a header. */
3313 if (directory_table
== NULL
)
3315 printf (_("CU: %s:\n"), file_table
[0].name
);
3316 printf (_("File name Line number Starting address\n"));
3320 unsigned int ix
= file_table
[0].directory_index
;
3321 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3323 if (do_wide
|| strlen (directory
) < 76)
3324 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3326 printf ("%s:\n", file_table
[0].name
);
3328 printf (_("File name Line number Starting address\n"));
3332 /* Skip the NUL at the end of the table. */
3335 saved_linfo
= linfo
;
3338 /* This loop iterates through the Dwarf Line Number Program. */
3339 while (data
< end_of_sequence
)
3341 unsigned char op_code
;
3343 unsigned long int uladv
;
3344 unsigned int bytes_read
;
3345 int is_special_opcode
= 0;
3349 if (op_code
>= linfo
.li_opcode_base
)
3351 op_code
-= linfo
.li_opcode_base
;
3352 uladv
= (op_code
/ linfo
.li_line_range
);
3353 if (linfo
.li_max_ops_per_insn
== 1)
3355 uladv
*= linfo
.li_min_insn_length
;
3356 state_machine_regs
.address
+= uladv
;
3360 state_machine_regs
.address
3361 += ((state_machine_regs
.op_index
+ uladv
)
3362 / linfo
.li_max_ops_per_insn
)
3363 * linfo
.li_min_insn_length
;
3364 state_machine_regs
.op_index
3365 = (state_machine_regs
.op_index
+ uladv
)
3366 % linfo
.li_max_ops_per_insn
;
3369 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3370 state_machine_regs
.line
+= adv
;
3371 is_special_opcode
= 1;
3373 else switch (op_code
)
3375 case DW_LNS_extended_op
:
3377 unsigned int ext_op_code_len
;
3378 unsigned char ext_op_code
;
3379 unsigned char *op_code_data
= data
;
3381 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3383 op_code_data
+= bytes_read
;
3385 if (ext_op_code_len
== 0)
3387 warn (_("Badly formed extended line op encountered!\n"));
3390 ext_op_code_len
+= bytes_read
;
3391 ext_op_code
= *op_code_data
++;
3393 switch (ext_op_code
)
3395 case DW_LNE_end_sequence
:
3396 reset_state_machine (linfo
.li_default_is_stmt
);
3398 case DW_LNE_set_address
:
3399 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3401 ext_op_code_len
- bytes_read
- 1,
3403 state_machine_regs
.op_index
= 0;
3405 case DW_LNE_define_file
:
3407 file_table
= (File_Entry
*) xrealloc
3408 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3410 ++state_machine_regs
.last_file_entry
;
3411 /* Source file name. */
3412 file_table
[n_files
].name
= op_code_data
;
3413 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3414 /* Directory index. */
3415 file_table
[n_files
].directory_index
=
3416 read_uleb128 (op_code_data
, & bytes_read
,
3418 op_code_data
+= bytes_read
;
3419 /* Last modification time. */
3420 file_table
[n_files
].modification_date
=
3421 read_uleb128 (op_code_data
, & bytes_read
,
3423 op_code_data
+= bytes_read
;
3425 file_table
[n_files
].length
=
3426 read_uleb128 (op_code_data
, & bytes_read
,
3432 case DW_LNE_set_discriminator
:
3433 case DW_LNE_HP_set_sequence
:
3434 /* Simply ignored. */
3438 printf (_("UNKNOWN (%u): length %d\n"),
3439 ext_op_code
, ext_op_code_len
- bytes_read
);
3442 data
+= ext_op_code_len
;
3448 case DW_LNS_advance_pc
:
3449 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3451 if (linfo
.li_max_ops_per_insn
== 1)
3453 uladv
*= linfo
.li_min_insn_length
;
3454 state_machine_regs
.address
+= uladv
;
3458 state_machine_regs
.address
3459 += ((state_machine_regs
.op_index
+ uladv
)
3460 / linfo
.li_max_ops_per_insn
)
3461 * linfo
.li_min_insn_length
;
3462 state_machine_regs
.op_index
3463 = (state_machine_regs
.op_index
+ uladv
)
3464 % linfo
.li_max_ops_per_insn
;
3468 case DW_LNS_advance_line
:
3469 adv
= read_sleb128 (data
, & bytes_read
, end
);
3471 state_machine_regs
.line
+= adv
;
3474 case DW_LNS_set_file
:
3475 adv
= read_uleb128 (data
, & bytes_read
, end
);
3477 state_machine_regs
.file
= adv
;
3479 if (file_table
== NULL
)
3480 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3481 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3482 /* If directory index is 0, that means current directory. */
3483 printf ("\n./%s:[++]\n",
3484 file_table
[state_machine_regs
.file
- 1].name
);
3485 else if (directory_table
== NULL
)
3486 printf (_("\n [Use directory table entry %d]\n"),
3487 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3489 /* The directory index starts counting at 1. */
3490 printf ("\n%s/%s:\n",
3491 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3492 file_table
[state_machine_regs
.file
- 1].name
);
3495 case DW_LNS_set_column
:
3496 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3498 state_machine_regs
.column
= uladv
;
3501 case DW_LNS_negate_stmt
:
3502 adv
= state_machine_regs
.is_stmt
;
3504 state_machine_regs
.is_stmt
= adv
;
3507 case DW_LNS_set_basic_block
:
3508 state_machine_regs
.basic_block
= 1;
3511 case DW_LNS_const_add_pc
:
3512 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3513 if (linfo
.li_max_ops_per_insn
== 1)
3515 uladv
*= linfo
.li_min_insn_length
;
3516 state_machine_regs
.address
+= uladv
;
3520 state_machine_regs
.address
3521 += ((state_machine_regs
.op_index
+ uladv
)
3522 / linfo
.li_max_ops_per_insn
)
3523 * linfo
.li_min_insn_length
;
3524 state_machine_regs
.op_index
3525 = (state_machine_regs
.op_index
+ uladv
)
3526 % linfo
.li_max_ops_per_insn
;
3530 case DW_LNS_fixed_advance_pc
:
3531 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3532 state_machine_regs
.address
+= uladv
;
3533 state_machine_regs
.op_index
= 0;
3536 case DW_LNS_set_prologue_end
:
3539 case DW_LNS_set_epilogue_begin
:
3542 case DW_LNS_set_isa
:
3543 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3545 printf (_(" Set ISA to %lu\n"), uladv
);
3549 printf (_(" Unknown opcode %d with operands: "), op_code
);
3551 if (standard_opcodes
!= NULL
)
3552 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3554 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3556 i
== 1 ? "" : ", ");
3563 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3564 to the DWARF address/line matrix. */
3565 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3566 || (op_code
== DW_LNS_copy
))
3568 const unsigned int MAX_FILENAME_LENGTH
= 35;
3570 char *newFileName
= NULL
;
3571 size_t fileNameLength
;
3574 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3576 fileName
= "<unknown>";
3578 fileNameLength
= strlen (fileName
);
3580 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3582 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3583 /* Truncate file name */
3584 strncpy (newFileName
,
3585 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3586 MAX_FILENAME_LENGTH
+ 1);
3590 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3591 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3594 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3596 if (linfo
.li_max_ops_per_insn
== 1)
3597 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3598 newFileName
, state_machine_regs
.line
,
3599 state_machine_regs
.address
);
3601 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3602 newFileName
, state_machine_regs
.line
,
3603 state_machine_regs
.address
,
3604 state_machine_regs
.op_index
);
3608 if (linfo
.li_max_ops_per_insn
== 1)
3609 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3610 newFileName
, state_machine_regs
.line
,
3611 state_machine_regs
.address
);
3613 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3614 newFileName
, state_machine_regs
.line
,
3615 state_machine_regs
.address
,
3616 state_machine_regs
.op_index
);
3619 if (op_code
== DW_LNE_end_sequence
)
3633 if (directory_table
)
3635 free (directory_table
);
3636 directory_table
= NULL
;
3647 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3649 unsigned char *data
= section
->start
;
3650 unsigned char *end
= data
+ section
->size
;
3652 int retValDecoded
= 1;
3654 if (do_debug_lines
== 0)
3655 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3657 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3658 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3660 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3661 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3663 if (!retValRaw
|| !retValDecoded
)
3670 find_debug_info_for_offset (unsigned long offset
)
3674 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3677 for (i
= 0; i
< num_debug_info_entries
; i
++)
3678 if (debug_information
[i
].cu_offset
== offset
)
3679 return debug_information
+ i
;
3685 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
3687 /* See gdb/gdb-index.h. */
3688 static const char * const kinds
[] =
3700 return _ (kinds
[kind
]);
3704 display_debug_pubnames_worker (struct dwarf_section
*section
,
3705 void *file ATTRIBUTE_UNUSED
,
3708 DWARF2_Internal_PubNames names
;
3709 unsigned char *start
= section
->start
;
3710 unsigned char *end
= start
+ section
->size
;
3712 /* It does not matter if this load fails,
3713 we test for that later on. */
3714 load_debug_info (file
);
3716 printf (_("Contents of the %s section:\n\n"), section
->name
);
3720 unsigned char *data
;
3721 unsigned long offset
;
3722 unsigned int offset_size
, initial_length_size
;
3726 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3727 if (names
.pn_length
== 0xffffffff)
3729 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3731 initial_length_size
= 12;
3736 initial_length_size
= 4;
3739 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3740 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3742 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3743 && num_debug_info_entries
> 0
3744 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3745 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3746 (unsigned long) names
.pn_offset
, section
->name
);
3748 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3750 /* PR 17531: file: 7615b6b2. */
3751 if ((dwarf_signed_vma
) names
.pn_length
< 0
3752 /* PR 17531: file: a5dbeaa7. */
3753 || start
+ names
.pn_length
+ initial_length_size
< start
)
3755 warn (_("Negative length for public name: 0x%lx\n"), (long) names
.pn_length
);
3759 start
+= names
.pn_length
+ initial_length_size
;
3761 printf (_(" Length: %ld\n"),
3762 (long) names
.pn_length
);
3763 printf (_(" Version: %d\n"),
3765 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3766 (unsigned long) names
.pn_offset
);
3767 printf (_(" Size of area in .debug_info section: %ld\n"),
3768 (long) names
.pn_size
);
3770 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3772 static int warned
= 0;
3776 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3784 printf (_("\n Offset Kind Name\n"));
3786 printf (_("\n Offset\tName\n"));
3790 bfd_size_type maxprint
;
3792 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3796 data
+= offset_size
;
3799 maxprint
= (end
- data
) - 1;
3803 unsigned int kind_data
;
3804 gdb_index_symbol_kind kind
;
3805 const char *kind_name
;
3808 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
3811 /* GCC computes the kind as the upper byte in the CU index
3812 word, and then right shifts it by the CU index size.
3813 Left shift KIND to where the gdb-index.h accessor macros
3815 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
3816 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
3817 kind_name
= get_gdb_index_symbol_kind_name (kind
);
3818 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
3819 printf (" %-6lx %s,%-10s %.*s\n",
3820 offset
, is_static
? _("s") : _("g"),
3821 kind_name
, (int) maxprint
, data
);
3824 printf (" %-6lx\t%.*s\n", offset
, (int) maxprint
, data
);
3826 data
+= strnlen ((char *) data
, maxprint
) + 1;
3831 while (offset
!= 0);
3839 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
3841 return display_debug_pubnames_worker (section
, file
, 0);
3845 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
3847 return display_debug_pubnames_worker (section
, file
, 1);
3851 display_debug_macinfo (struct dwarf_section
*section
,
3852 void *file ATTRIBUTE_UNUSED
)
3854 unsigned char *start
= section
->start
;
3855 unsigned char *end
= start
+ section
->size
;
3856 unsigned char *curr
= start
;
3857 unsigned int bytes_read
;
3858 enum dwarf_macinfo_record_type op
;
3860 printf (_("Contents of the %s section:\n\n"), section
->name
);
3864 unsigned int lineno
;
3865 const unsigned char *string
;
3867 op
= (enum dwarf_macinfo_record_type
) *curr
;
3872 case DW_MACINFO_start_file
:
3874 unsigned int filenum
;
3876 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3878 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3881 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3886 case DW_MACINFO_end_file
:
3887 printf (_(" DW_MACINFO_end_file\n"));
3890 case DW_MACINFO_define
:
3891 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3894 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3895 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3899 case DW_MACINFO_undef
:
3900 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3903 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3904 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3908 case DW_MACINFO_vendor_ext
:
3910 unsigned int constant
;
3912 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3915 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3916 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3926 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3927 filename and dirname corresponding to file name table entry with index
3928 FILEIDX. Return NULL on failure. */
3930 static unsigned char *
3931 get_line_filename_and_dirname (dwarf_vma line_offset
,
3933 unsigned char **dir_name
)
3935 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3936 unsigned char *hdrptr
, *dirtable
, *file_name
;
3937 unsigned int offset_size
, initial_length_size
;
3938 unsigned int version
, opcode_base
, bytes_read
;
3939 dwarf_vma length
, diridx
;
3940 const unsigned char * end
;
3943 if (section
->start
== NULL
3944 || line_offset
>= section
->size
3948 hdrptr
= section
->start
+ line_offset
;
3949 end
= section
->start
+ section
->size
;
3951 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3952 if (length
== 0xffffffff)
3954 /* This section is 64-bit DWARF 3. */
3955 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3957 initial_length_size
= 12;
3962 initial_length_size
= 4;
3964 if (length
+ initial_length_size
> section
->size
)
3967 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3968 if (version
!= 2 && version
!= 3 && version
!= 4)
3970 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3972 hdrptr
++; /* Skip max_ops_per_insn. */
3973 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3975 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3976 if (opcode_base
== 0)
3979 hdrptr
+= opcode_base
- 1;
3981 /* Skip over dirname table. */
3982 while (*hdrptr
!= '\0')
3983 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3984 hdrptr
++; /* Skip the NUL at the end of the table. */
3985 /* Now skip over preceding filename table entries. */
3986 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
3988 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3989 read_uleb128 (hdrptr
, &bytes_read
, end
);
3990 hdrptr
+= bytes_read
;
3991 read_uleb128 (hdrptr
, &bytes_read
, end
);
3992 hdrptr
+= bytes_read
;
3993 read_uleb128 (hdrptr
, &bytes_read
, end
);
3994 hdrptr
+= bytes_read
;
3996 if (hdrptr
== end
|| *hdrptr
== '\0')
3999 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4000 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
4003 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
4004 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
4005 if (*dirtable
== '\0')
4007 *dir_name
= dirtable
;
4012 display_debug_macro (struct dwarf_section
*section
,
4015 unsigned char *start
= section
->start
;
4016 unsigned char *end
= start
+ section
->size
;
4017 unsigned char *curr
= start
;
4018 unsigned char *extended_op_buf
[256];
4019 unsigned int bytes_read
;
4021 load_debug_section (str
, file
);
4022 load_debug_section (line
, file
);
4024 printf (_("Contents of the %s section:\n\n"), section
->name
);
4028 unsigned int lineno
, version
, flags
;
4029 unsigned int offset_size
= 4;
4030 const unsigned char *string
;
4031 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
4032 unsigned char **extended_ops
= NULL
;
4034 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
4037 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4042 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
4045 printf (_(" Offset: 0x%lx\n"),
4046 (unsigned long) sec_offset
);
4047 printf (_(" Version: %d\n"), version
);
4048 printf (_(" Offset size: %d\n"), offset_size
);
4051 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
4052 printf (_(" Offset into .debug_line: 0x%lx\n"),
4053 (unsigned long) line_offset
);
4057 unsigned int i
, count
, op
;
4060 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
4062 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
4063 extended_ops
= extended_op_buf
;
4066 printf (_(" Extension opcode arguments:\n"));
4067 for (i
= 0; i
< count
; i
++)
4069 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4070 extended_ops
[op
] = curr
;
4071 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
4074 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
4077 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
4078 for (n
= 0; n
< nargs
; n
++)
4082 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
4083 printf ("%s%s", get_FORM_name (form
),
4084 n
== nargs
- 1 ? "\n" : ", ");
4094 case DW_FORM_block1
:
4095 case DW_FORM_block2
:
4096 case DW_FORM_block4
:
4098 case DW_FORM_string
:
4100 case DW_FORM_sec_offset
:
4103 error (_("Invalid extension opcode form %s\n"),
4104 get_FORM_name (form
));
4120 error (_(".debug_macro section not zero terminated\n"));
4124 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4130 case DW_MACRO_GNU_start_file
:
4132 unsigned int filenum
;
4133 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4135 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4137 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4140 if ((flags
& 2) == 0)
4141 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4144 = get_line_filename_and_dirname (line_offset
, filenum
,
4146 if (file_name
== NULL
)
4147 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4150 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4152 dir_name
!= NULL
? (const char *) dir_name
: "",
4153 dir_name
!= NULL
? "/" : "", file_name
);
4157 case DW_MACRO_GNU_end_file
:
4158 printf (_(" DW_MACRO_GNU_end_file\n"));
4161 case DW_MACRO_GNU_define
:
4162 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4165 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4166 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4170 case DW_MACRO_GNU_undef
:
4171 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4174 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4175 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4179 case DW_MACRO_GNU_define_indirect
:
4180 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4182 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4183 string
= fetch_indirect_string (offset
);
4184 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4188 case DW_MACRO_GNU_undef_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_undef_indirect - lineno : %d macro : %s\n"),
4197 case DW_MACRO_GNU_transparent_include
:
4198 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4199 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4200 (unsigned long) offset
);
4203 case DW_MACRO_GNU_define_indirect_alt
:
4204 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4206 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4207 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4208 lineno
, (unsigned long) offset
);
4211 case DW_MACRO_GNU_undef_indirect_alt
:
4212 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4214 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4215 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4216 lineno
, (unsigned long) offset
);
4219 case DW_MACRO_GNU_transparent_include_alt
:
4220 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4221 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4222 (unsigned long) offset
);
4226 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
4228 error (_(" Unknown macro opcode %02x seen\n"), op
);
4233 /* Skip over unhandled opcodes. */
4235 unsigned char *desc
= extended_ops
[op
];
4236 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
4240 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
4243 printf (_(" DW_MACRO_GNU_%02x -"), op
);
4244 for (n
= 0; n
< nargs
; n
++)
4248 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
4250 = read_and_display_attr_value (0, val
,
4251 curr
, end
, 0, 0, offset_size
,
4252 version
, NULL
, 0, NULL
,
4270 display_debug_abbrev (struct dwarf_section
*section
,
4271 void *file ATTRIBUTE_UNUSED
)
4273 abbrev_entry
*entry
;
4274 unsigned char *start
= section
->start
;
4275 unsigned char *end
= start
+ section
->size
;
4277 printf (_("Contents of the %s section:\n\n"), section
->name
);
4281 unsigned char *last
;
4286 start
= process_abbrev_section (start
, end
);
4288 if (first_abbrev
== NULL
)
4291 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4293 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4297 printf (" %ld %s [%s]\n",
4299 get_TAG_name (entry
->tag
),
4300 entry
->children
? _("has children") : _("no children"));
4302 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4303 printf (" %-18s %s\n",
4304 get_AT_name (attr
->attribute
),
4305 get_FORM_name (attr
->form
));
4315 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4318 display_loc_list (struct dwarf_section
*section
,
4319 unsigned char **start_ptr
,
4320 unsigned int debug_info_entry
,
4321 unsigned long offset
,
4322 unsigned long base_address
,
4325 unsigned char *start
= *start_ptr
;
4326 unsigned char *section_end
= section
->start
+ section
->size
;
4327 unsigned long cu_offset
;
4328 unsigned int pointer_size
;
4329 unsigned int offset_size
;
4334 unsigned short length
;
4335 int need_frame_base
;
4337 if (debug_info_entry
>= num_debug_info_entries
)
4339 warn (_("No debug information available for loc lists of entry: %u\n"),
4344 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4345 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4346 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4347 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4349 if (pointer_size
< 2 || pointer_size
> 8)
4351 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4352 pointer_size
, debug_info_entry
);
4358 if (start
+ 2 * pointer_size
> section_end
)
4360 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4365 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4367 /* Note: we use sign extension here in order to be sure that we can detect
4368 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4369 address will not affect the values that we display since we always show
4370 hex values, and always the bottom 32-bits. */
4371 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4372 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4374 if (begin
== 0 && end
== 0)
4376 printf (_("<End of list>\n"));
4380 /* Check base address specifiers. */
4381 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4384 print_dwarf_vma (begin
, pointer_size
);
4385 print_dwarf_vma (end
, pointer_size
);
4386 printf (_("(base address)\n"));
4390 if (start
+ 2 > section_end
)
4392 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4397 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4399 if (start
+ length
> section_end
)
4401 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4406 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4407 print_dwarf_vma (end
+ base_address
, pointer_size
);
4410 need_frame_base
= decode_location_expression (start
,
4415 cu_offset
, section
);
4418 if (need_frame_base
&& !has_frame_base
)
4419 printf (_(" [without DW_AT_frame_base]"));
4422 fputs (_(" (start == end)"), stdout
);
4423 else if (begin
> end
)
4424 fputs (_(" (start > end)"), stdout
);
4434 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4435 right-adjusted in a field of length LEN, and followed by a space. */
4438 print_addr_index (unsigned int idx
, unsigned int len
)
4440 static char buf
[15];
4441 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4442 printf ("%*s ", len
, buf
);
4445 /* Display a location list from a .dwo section. It uses address indexes rather
4446 than embedded addresses. This code closely follows display_loc_list, but the
4447 two are sufficiently different that combining things is very ugly. */
4450 display_loc_list_dwo (struct dwarf_section
*section
,
4451 unsigned char **start_ptr
,
4452 unsigned int debug_info_entry
,
4453 unsigned long offset
,
4456 unsigned char *start
= *start_ptr
;
4457 unsigned char *section_end
= section
->start
+ section
->size
;
4458 unsigned long cu_offset
;
4459 unsigned int pointer_size
;
4460 unsigned int offset_size
;
4463 unsigned short length
;
4464 int need_frame_base
;
4466 unsigned int bytes_read
;
4468 if (debug_info_entry
>= num_debug_info_entries
)
4470 warn (_("No debug information for loc lists of entry: %u\n"),
4475 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4476 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4477 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4478 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4480 if (pointer_size
< 2 || pointer_size
> 8)
4482 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4483 pointer_size
, debug_info_entry
);
4489 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4491 if (start
>= section_end
)
4493 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4498 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4501 case 0: /* A terminating entry. */
4503 printf (_("<End of list>\n"));
4505 case 1: /* A base-address entry. */
4506 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4507 start
+= bytes_read
;
4508 print_addr_index (idx
, 8);
4510 printf (_("(base address selection entry)\n"));
4512 case 2: /* A start/end entry. */
4513 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4514 start
+= bytes_read
;
4515 print_addr_index (idx
, 8);
4516 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4517 start
+= bytes_read
;
4518 print_addr_index (idx
, 8);
4520 case 3: /* A start/length entry. */
4521 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4522 start
+= bytes_read
;
4523 print_addr_index (idx
, 8);
4524 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4525 printf ("%08x ", idx
);
4527 case 4: /* An offset pair entry. */
4528 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4529 printf ("%08x ", idx
);
4530 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4531 printf ("%08x ", idx
);
4534 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4539 if (start
+ 2 > section_end
)
4541 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4546 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4547 if (start
+ length
> section_end
)
4549 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4555 need_frame_base
= decode_location_expression (start
,
4560 cu_offset
, section
);
4563 if (need_frame_base
&& !has_frame_base
)
4564 printf (_(" [without DW_AT_frame_base]"));
4574 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4576 static dwarf_vma
*loc_offsets
;
4579 loc_offsets_compar (const void *ap
, const void *bp
)
4581 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4582 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4584 return (a
> b
) - (b
> a
);
4588 display_debug_loc (struct dwarf_section
*section
, void *file
)
4590 unsigned char *start
= section
->start
;
4591 unsigned long bytes
;
4592 unsigned char *section_begin
= start
;
4593 unsigned int num_loc_list
= 0;
4594 unsigned long last_offset
= 0;
4595 unsigned int first
= 0;
4599 int seen_first_offset
= 0;
4600 int locs_sorted
= 1;
4601 unsigned char *next
;
4602 unsigned int *array
= NULL
;
4603 const char *suffix
= strrchr (section
->name
, '.');
4606 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4609 bytes
= section
->size
;
4613 printf (_("\nThe %s section is empty.\n"), section
->name
);
4617 if (load_debug_info (file
) == 0)
4619 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4624 /* Check the order of location list in .debug_info section. If
4625 offsets of location lists are in the ascending order, we can
4626 use `debug_information' directly. */
4627 for (i
= 0; i
< num_debug_info_entries
; i
++)
4631 num
= debug_information
[i
].num_loc_offsets
;
4632 if (num
> num_loc_list
)
4635 /* Check if we can use `debug_information' directly. */
4636 if (locs_sorted
&& num
!= 0)
4638 if (!seen_first_offset
)
4640 /* This is the first location list. */
4641 last_offset
= debug_information
[i
].loc_offsets
[0];
4643 seen_first_offset
= 1;
4649 for (; j
< num
; j
++)
4652 debug_information
[i
].loc_offsets
[j
])
4657 last_offset
= debug_information
[i
].loc_offsets
[j
];
4662 if (!seen_first_offset
)
4663 error (_("No location lists in .debug_info section!\n"));
4665 if (debug_information
[first
].num_loc_offsets
> 0
4666 && debug_information
[first
].loc_offsets
[0] != 0)
4667 warn (_("Location lists in %s section start at 0x%s\n"),
4669 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4672 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4673 printf (_("Contents of the %s section:\n\n"), section
->name
);
4674 printf (_(" Offset Begin End Expression\n"));
4676 seen_first_offset
= 0;
4677 for (i
= first
; i
< num_debug_info_entries
; i
++)
4679 unsigned long offset
;
4680 unsigned long base_address
;
4685 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4687 loc_offsets
= debug_information
[i
].loc_offsets
;
4688 qsort (array
, debug_information
[i
].num_loc_offsets
,
4689 sizeof (*array
), loc_offsets_compar
);
4692 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4694 j
= locs_sorted
? k
: array
[k
];
4696 && debug_information
[i
].loc_offsets
[locs_sorted
4697 ? k
- 1 : array
[k
- 1]]
4698 == debug_information
[i
].loc_offsets
[j
])
4700 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4701 offset
= debug_information
[i
].loc_offsets
[j
];
4702 next
= section_begin
+ offset
;
4703 base_address
= debug_information
[i
].base_address
;
4705 if (!seen_first_offset
)
4706 seen_first_offset
= 1;
4710 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4711 (unsigned long) (start
- section_begin
),
4712 (unsigned long) (next
- section_begin
));
4713 else if (start
> next
)
4714 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4715 (unsigned long) (start
- section_begin
),
4716 (unsigned long) (next
- section_begin
));
4720 if (offset
>= bytes
)
4722 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4728 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4730 display_loc_list (section
, &start
, i
, offset
, base_address
,
4735 if (start
< section
->start
+ section
->size
)
4736 warn (_("There are %ld unused bytes at the end of section %s\n"),
4737 (long) (section
->start
+ section
->size
- start
), section
->name
);
4744 display_debug_str (struct dwarf_section
*section
,
4745 void *file ATTRIBUTE_UNUSED
)
4747 unsigned char *start
= section
->start
;
4748 unsigned long bytes
= section
->size
;
4749 dwarf_vma addr
= section
->address
;
4753 printf (_("\nThe %s section is empty.\n"), section
->name
);
4757 printf (_("Contents of the %s section:\n\n"), section
->name
);
4765 lbytes
= (bytes
> 16 ? 16 : bytes
);
4767 printf (" 0x%8.8lx ", (unsigned long) addr
);
4769 for (j
= 0; j
< 16; j
++)
4772 printf ("%2.2x", start
[j
]);
4780 for (j
= 0; j
< lbytes
; j
++)
4783 if (k
>= ' ' && k
< 0x80)
4802 display_debug_info (struct dwarf_section
*section
, void *file
)
4804 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4808 display_debug_types (struct dwarf_section
*section
, void *file
)
4810 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4814 display_trace_info (struct dwarf_section
*section
, void *file
)
4816 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4820 display_debug_aranges (struct dwarf_section
*section
,
4821 void *file ATTRIBUTE_UNUSED
)
4823 unsigned char *start
= section
->start
;
4824 unsigned char *end
= start
+ section
->size
;
4826 printf (_("Contents of the %s section:\n\n"), section
->name
);
4828 /* It does not matter if this load fails,
4829 we test for that later on. */
4830 load_debug_info (file
);
4834 unsigned char *hdrptr
;
4835 DWARF2_Internal_ARange arange
;
4836 unsigned char *addr_ranges
;
4839 unsigned char address_size
;
4841 unsigned int offset_size
;
4842 unsigned int initial_length_size
;
4846 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4847 if (arange
.ar_length
== 0xffffffff)
4849 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4851 initial_length_size
= 12;
4856 initial_length_size
= 4;
4859 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4860 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4862 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4863 && num_debug_info_entries
> 0
4864 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4865 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4866 (unsigned long) arange
.ar_info_offset
, section
->name
);
4868 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4869 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4871 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4873 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4877 printf (_(" Length: %ld\n"),
4878 (long) arange
.ar_length
);
4879 printf (_(" Version: %d\n"), arange
.ar_version
);
4880 printf (_(" Offset into .debug_info: 0x%lx\n"),
4881 (unsigned long) arange
.ar_info_offset
);
4882 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4883 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4885 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4887 /* PR 17512: file: 001-108546-0.001:0.1. */
4888 if (address_size
== 0 || address_size
> 8)
4890 error (_("Invalid address size in %s section!\n"),
4895 /* The DWARF spec does not require that the address size be a power
4896 of two, but we do. This will have to change if we ever encounter
4897 an uneven architecture. */
4898 if ((address_size
& (address_size
- 1)) != 0)
4900 warn (_("Pointer size + Segment size is not a power of two.\n"));
4904 if (address_size
> 4)
4905 printf (_("\n Address Length\n"));
4907 printf (_("\n Address Length\n"));
4909 addr_ranges
= hdrptr
;
4911 /* Must pad to an alignment boundary that is twice the address size. */
4912 excess
= (hdrptr
- start
) % (2 * address_size
);
4914 addr_ranges
+= (2 * address_size
) - excess
;
4916 start
+= arange
.ar_length
+ initial_length_size
;
4918 while (addr_ranges
+ 2 * address_size
<= start
)
4920 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4921 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4924 print_dwarf_vma (address
, address_size
);
4925 print_dwarf_vma (length
, address_size
);
4935 /* Comparison function for qsort. */
4937 comp_addr_base (const void * v0
, const void * v1
)
4939 debug_info
* info0
= (debug_info
*) v0
;
4940 debug_info
* info1
= (debug_info
*) v1
;
4941 return info0
->addr_base
- info1
->addr_base
;
4944 /* Display the debug_addr section. */
4946 display_debug_addr (struct dwarf_section
*section
,
4949 debug_info
**debug_addr_info
;
4950 unsigned char *entry
;
4955 if (section
->size
== 0)
4957 printf (_("\nThe %s section is empty.\n"), section
->name
);
4961 if (load_debug_info (file
) == 0)
4963 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4968 printf (_("Contents of the %s section:\n\n"), section
->name
);
4970 /* PR 17531: file: cf38d01b.
4971 We use xcalloc because a corrupt file may not have initialised all of the
4972 fields in the debug_info structure, which means that the sort below might
4973 try to move uninitialised data. */
4974 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
4975 sizeof (debug_info
*));
4978 for (i
= 0; i
< num_debug_info_entries
; i
++)
4979 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
4981 /* PR 17531: file: cf38d01b. */
4982 if (debug_information
[i
].addr_base
>= section
->size
)
4983 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
4984 (unsigned long) debug_information
[i
].addr_base
, i
);
4986 debug_addr_info
[count
++] = debug_information
+ i
;
4989 /* Add a sentinel to make iteration convenient. */
4990 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
4991 debug_addr_info
[count
]->addr_base
= section
->size
;
4992 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
4994 for (i
= 0; i
< count
; i
++)
4997 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
4999 printf (_(" For compilation unit at offset 0x%s:\n"),
5000 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
5002 printf (_("\tIndex\tAddress\n"));
5003 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
5004 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
5008 dwarf_vma base
= byte_get (entry
, address_size
);
5009 printf (_("\t%d:\t"), idx
);
5010 print_dwarf_vma (base
, address_size
);
5012 entry
+= address_size
;
5018 free (debug_addr_info
);
5022 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5024 display_debug_str_offsets (struct dwarf_section
*section
,
5025 void *file ATTRIBUTE_UNUSED
)
5027 if (section
->size
== 0)
5029 printf (_("\nThe %s section is empty.\n"), section
->name
);
5032 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5033 what the offset size is for this section. */
5037 /* Each debug_information[x].range_lists[y] gets this representation for
5038 sorting purposes. */
5042 /* The debug_information[x].range_lists[y] value. */
5043 unsigned long ranges_offset
;
5045 /* Original debug_information to find parameters of the data. */
5046 debug_info
*debug_info_p
;
5049 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5052 range_entry_compar (const void *ap
, const void *bp
)
5054 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
5055 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
5056 const unsigned long a
= a_re
->ranges_offset
;
5057 const unsigned long b
= b_re
->ranges_offset
;
5059 return (a
> b
) - (b
> a
);
5063 display_debug_ranges (struct dwarf_section
*section
,
5064 void *file ATTRIBUTE_UNUSED
)
5066 unsigned char *start
= section
->start
;
5067 unsigned char *last_start
= start
;
5068 unsigned long bytes
= section
->size
;
5069 unsigned char *section_begin
= start
;
5070 unsigned char *finish
= start
+ bytes
;
5071 unsigned int num_range_list
, i
;
5072 struct range_entry
*range_entries
, *range_entry_fill
;
5076 printf (_("\nThe %s section is empty.\n"), section
->name
);
5080 if (load_debug_info (file
) == 0)
5082 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5088 for (i
= 0; i
< num_debug_info_entries
; i
++)
5089 num_range_list
+= debug_information
[i
].num_range_lists
;
5091 if (num_range_list
== 0)
5093 /* This can happen when the file was compiled with -gsplit-debug
5094 which removes references to range lists from the primary .o file. */
5095 printf (_("No range lists in .debug_info section.\n"));
5099 range_entries
= (struct range_entry
*)
5100 xmalloc (sizeof (*range_entries
) * num_range_list
);
5101 range_entry_fill
= range_entries
;
5103 for (i
= 0; i
< num_debug_info_entries
; i
++)
5105 debug_info
*debug_info_p
= &debug_information
[i
];
5108 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
5110 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
5111 range_entry_fill
->debug_info_p
= debug_info_p
;
5116 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
5117 range_entry_compar
);
5119 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
5120 warn (_("Range lists in %s section start at 0x%lx\n"),
5121 section
->name
, range_entries
[0].ranges_offset
);
5123 printf (_("Contents of the %s section:\n\n"), section
->name
);
5124 printf (_(" Offset Begin End\n"));
5126 for (i
= 0; i
< num_range_list
; i
++)
5128 struct range_entry
*range_entry
= &range_entries
[i
];
5129 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
5130 unsigned int pointer_size
;
5131 unsigned long offset
;
5132 unsigned char *next
;
5133 unsigned long base_address
;
5135 pointer_size
= debug_info_p
->pointer_size
;
5136 offset
= range_entry
->ranges_offset
;
5137 next
= section_begin
+ offset
;
5138 base_address
= debug_info_p
->base_address
;
5140 /* PR 17512: file: 001-101485-0.001:0.1. */
5141 if (pointer_size
< 2 || pointer_size
> 8)
5143 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5144 pointer_size
, offset
);
5148 if (dwarf_check
!= 0 && i
> 0)
5151 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5152 (unsigned long) (start
- section_begin
),
5153 (unsigned long) (next
- section_begin
), section
->name
);
5154 else if (start
> next
)
5156 if (next
== last_start
)
5158 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5159 (unsigned long) (start
- section_begin
),
5160 (unsigned long) (next
- section_begin
), section
->name
);
5166 while (start
< finish
)
5171 /* Note: we use sign extension here in order to be sure that
5172 we can detect the -1 escape value. Sign extension into the
5173 top 32 bits of a 32-bit address will not affect the values
5174 that we display since we always show hex values, and always
5175 the bottom 32-bits. */
5176 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
5177 if (start
>= finish
)
5179 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
5181 printf (" %8.8lx ", offset
);
5183 if (begin
== 0 && end
== 0)
5185 printf (_("<End of list>\n"));
5189 /* Check base address specifiers. */
5190 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
5193 print_dwarf_vma (begin
, pointer_size
);
5194 print_dwarf_vma (end
, pointer_size
);
5195 printf ("(base address)\n");
5199 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5200 print_dwarf_vma (end
+ base_address
, pointer_size
);
5203 fputs (_("(start == end)"), stdout
);
5204 else if (begin
> end
)
5205 fputs (_("(start > end)"), stdout
);
5212 free (range_entries
);
5217 typedef struct Frame_Chunk
5219 struct Frame_Chunk
*next
;
5220 unsigned char *chunk_start
;
5222 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5223 short int *col_type
;
5226 unsigned int code_factor
;
5233 unsigned char fde_encoding
;
5234 unsigned char cfa_exp
;
5235 unsigned char ptr_size
;
5236 unsigned char segment_size
;
5240 static const char *const *dwarf_regnames
;
5241 static unsigned int dwarf_regnames_count
;
5243 /* A marker for a col_type that means this column was never referenced
5244 in the frame info. */
5245 #define DW_CFA_unreferenced (-1)
5247 /* Return 0 if no more space is needed, 1 if more space is needed,
5248 -1 for invalid reg. */
5251 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
5253 unsigned int prev
= fc
->ncols
;
5255 if (reg
< (unsigned int) fc
->ncols
)
5258 if (dwarf_regnames_count
5259 && reg
> dwarf_regnames_count
)
5262 fc
->ncols
= reg
+ 1;
5263 /* PR 17512: file: 10450-2643-0.004.
5264 If reg == -1 then this can happen... */
5268 /* PR 17512: file: 2844a11d. */
5269 if (fc
->ncols
> 1024)
5271 error (_("Unfeasibly large register number: %u\n"), reg
);
5273 /* FIXME: 1024 is an arbitrary limit. Increase it if
5274 we ever encounter a valid binary that exceeds it. */
5278 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
5279 sizeof (short int));
5280 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
5281 /* PR 17512: file:002-10025-0.005. */
5282 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
5284 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5290 while (prev
< fc
->ncols
)
5292 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
5293 fc
->col_offset
[prev
] = 0;
5299 static const char *const dwarf_regnames_i386
[] =
5301 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5302 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5303 "eip", "eflags", NULL
, /* 8 - 10 */
5304 "st0", "st1", "st2", "st3", /* 11 - 14 */
5305 "st4", "st5", "st6", "st7", /* 15 - 18 */
5306 NULL
, NULL
, /* 19 - 20 */
5307 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5308 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5309 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5310 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5311 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5312 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5313 "tr", "ldtr", /* 48 - 49 */
5314 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5315 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5316 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5317 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5318 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5319 NULL
, NULL
, NULL
, /* 90 - 92 */
5320 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5324 init_dwarf_regnames_i386 (void)
5326 dwarf_regnames
= dwarf_regnames_i386
;
5327 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5330 static const char *const dwarf_regnames_x86_64
[] =
5332 "rax", "rdx", "rcx", "rbx",
5333 "rsi", "rdi", "rbp", "rsp",
5334 "r8", "r9", "r10", "r11",
5335 "r12", "r13", "r14", "r15",
5337 "xmm0", "xmm1", "xmm2", "xmm3",
5338 "xmm4", "xmm5", "xmm6", "xmm7",
5339 "xmm8", "xmm9", "xmm10", "xmm11",
5340 "xmm12", "xmm13", "xmm14", "xmm15",
5341 "st0", "st1", "st2", "st3",
5342 "st4", "st5", "st6", "st7",
5343 "mm0", "mm1", "mm2", "mm3",
5344 "mm4", "mm5", "mm6", "mm7",
5346 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5347 "fs.base", "gs.base", NULL
, NULL
,
5349 "mxcsr", "fcw", "fsw",
5350 "xmm16", "xmm17", "xmm18", "xmm19",
5351 "xmm20", "xmm21", "xmm22", "xmm23",
5352 "xmm24", "xmm25", "xmm26", "xmm27",
5353 "xmm28", "xmm29", "xmm30", "xmm31",
5354 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5355 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5356 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5357 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5358 NULL
, NULL
, NULL
, /* 115 - 117 */
5359 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5363 init_dwarf_regnames_x86_64 (void)
5365 dwarf_regnames
= dwarf_regnames_x86_64
;
5366 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5369 static const char *const dwarf_regnames_aarch64
[] =
5371 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5372 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5373 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5374 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5375 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5376 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5377 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5378 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5379 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5380 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5381 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5382 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5386 init_dwarf_regnames_aarch64 (void)
5388 dwarf_regnames
= dwarf_regnames_aarch64
;
5389 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
5393 init_dwarf_regnames (unsigned int e_machine
)
5399 init_dwarf_regnames_i386 ();
5405 init_dwarf_regnames_x86_64 ();
5409 init_dwarf_regnames_aarch64 ();
5418 regname (unsigned int regno
, int row
)
5420 static char reg
[64];
5422 && regno
< dwarf_regnames_count
5423 && dwarf_regnames
[regno
] != NULL
)
5426 return dwarf_regnames
[regno
];
5427 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5428 dwarf_regnames
[regno
]);
5431 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5436 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
5441 if (*max_regs
< fc
->ncols
)
5442 *max_regs
= fc
->ncols
;
5444 if (*need_col_headers
)
5446 static const char *sloc
= " LOC";
5448 *need_col_headers
= 0;
5450 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5452 for (r
= 0; r
< *max_regs
; r
++)
5453 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5458 printf ("%-5s ", regname (r
, 1));
5464 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5466 strcpy (tmp
, "exp");
5468 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), fc
->cfa_offset
);
5469 printf ("%-8s ", tmp
);
5471 for (r
= 0; r
< fc
->ncols
; r
++)
5473 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5475 switch (fc
->col_type
[r
])
5477 case DW_CFA_undefined
:
5480 case DW_CFA_same_value
:
5484 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5486 case DW_CFA_val_offset
:
5487 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5489 case DW_CFA_register
:
5490 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5492 case DW_CFA_expression
:
5493 strcpy (tmp
, "exp");
5495 case DW_CFA_val_expression
:
5496 strcpy (tmp
, "vexp");
5499 strcpy (tmp
, "n/a");
5502 printf ("%-5s ", tmp
);
5508 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5509 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5510 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5512 static unsigned char *
5513 read_cie (unsigned char *start
, unsigned char *end
,
5514 Frame_Chunk
**p_cie
, int *p_version
,
5515 unsigned long *p_aug_len
, unsigned char **p_aug
)
5519 unsigned int length_return
;
5520 unsigned char *augmentation_data
= NULL
;
5521 unsigned long augmentation_data_len
= 0;
5524 /* PR 17512: file: 001-228113-0.004. */
5528 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5529 memset (fc
, 0, sizeof (Frame_Chunk
));
5531 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5532 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5536 fc
->augmentation
= (char *) start
;
5537 /* PR 17512: file: 001-228113-0.004.
5538 Skip past augmentation name, but avoid running off the end of the data. */
5540 if (* start
++ == '\0')
5544 warn (_("No terminator for augmentation name\n"));
5548 if (strcmp (fc
->augmentation
, "eh") == 0)
5549 start
+= eh_addr_size
;
5553 GET (fc
->ptr_size
, 1);
5554 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
5556 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
5560 GET (fc
->segment_size
, 1);
5561 /* PR 17512: file: e99d2804. */
5562 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
5564 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
5568 eh_addr_size
= fc
->ptr_size
;
5572 fc
->ptr_size
= eh_addr_size
;
5573 fc
->segment_size
= 0;
5575 fc
->code_factor
= LEB ();
5576 fc
->data_factor
= SLEB ();
5586 if (fc
->augmentation
[0] == 'z')
5588 augmentation_data_len
= LEB ();
5589 augmentation_data
= start
;
5590 start
+= augmentation_data_len
;
5591 /* PR 17512: file: 11042-2589-0.004. */
5594 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len
);
5599 if (augmentation_data_len
)
5603 unsigned char *qend
;
5605 p
= (unsigned char *) fc
->augmentation
+ 1;
5606 q
= augmentation_data
;
5607 qend
= q
+ augmentation_data_len
;
5609 /* PR 17531: file: 015adfaa. */
5612 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len
);
5613 augmentation_data_len
= 0;
5616 while (p
< end
&& q
< augmentation_data
+ augmentation_data_len
)
5621 q
+= 1 + size_of_encoded_value (*q
);
5623 fc
->fde_encoding
= *q
++;
5630 /* Note - it is OK if this loop terminates with q < qend.
5631 Padding may have been inserted to align the end of the CIE. */
5636 *p_version
= version
;
5639 *p_aug_len
= augmentation_data_len
;
5640 *p_aug
= augmentation_data
;
5646 display_debug_frames (struct dwarf_section
*section
,
5647 void *file ATTRIBUTE_UNUSED
)
5649 unsigned char *start
= section
->start
;
5650 unsigned char *end
= start
+ section
->size
;
5651 unsigned char *section_start
= start
;
5652 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
5653 Frame_Chunk
*remembered_state
= 0;
5655 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5656 unsigned int length_return
;
5657 unsigned int max_regs
= 0;
5658 const char *bad_reg
= _("bad register: ");
5659 unsigned int saved_eh_addr_size
= eh_addr_size
;
5661 printf (_("Contents of the %s section:\n"), section
->name
);
5665 unsigned char *saved_start
;
5666 unsigned char *block_end
;
5671 int need_col_headers
= 1;
5672 unsigned char *augmentation_data
= NULL
;
5673 unsigned long augmentation_data_len
= 0;
5674 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5675 unsigned int offset_size
;
5676 unsigned int initial_length_size
;
5678 saved_start
= start
;
5680 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5684 printf ("\n%08lx ZERO terminator\n\n",
5685 (unsigned long)(saved_start
- section_start
));
5686 /* Skip any zero terminators that directly follow.
5687 A corrupt section size could have loaded a whole
5688 slew of zero filled memory bytes. eg
5689 PR 17512: file: 070-19381-0.004. */
5690 while (start
< end
&& * start
== 0)
5695 if (length
== 0xffffffff)
5697 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5699 initial_length_size
= 12;
5704 initial_length_size
= 4;
5707 block_end
= saved_start
+ length
+ initial_length_size
;
5708 if (block_end
> end
|| block_end
< start
)
5710 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5711 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5712 (unsigned long) (saved_start
- section_start
));
5716 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5718 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5719 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5724 start
= read_cie (start
, end
, &cie
, &version
,
5725 &augmentation_data_len
, &augmentation_data
);
5726 /* PR 17512: file: 027-135133-0.005. */
5733 fc
->chunk_start
= saved_start
;
5734 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5737 if (frame_need_space (fc
, mreg
) < 0)
5739 if (fc
->fde_encoding
)
5740 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5742 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5743 print_dwarf_vma (length
, fc
->ptr_size
);
5744 print_dwarf_vma (cie_id
, offset_size
);
5746 if (do_debug_frames_interp
)
5748 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5749 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5754 printf (" Version: %d\n", version
);
5755 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5758 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5759 printf (" Segment Size: %u\n", fc
->segment_size
);
5761 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5762 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5763 printf (" Return address column: %d\n", fc
->ra
);
5765 if (augmentation_data_len
)
5769 printf (" Augmentation data: ");
5770 for (i
= 0; i
< augmentation_data_len
; ++i
)
5771 /* FIXME: If do_wide is FALSE, then we should
5772 add carriage returns at 80 columns... */
5773 printf (" %02x", augmentation_data
[i
]);
5781 unsigned char *look_for
;
5782 static Frame_Chunk fde_fc
;
5783 unsigned long segment_selector
;
5787 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
5788 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
5791 look_for
= section_start
+ cie_id
;
5793 if (look_for
<= saved_start
)
5795 for (cie
= chunks
; cie
; cie
= cie
->next
)
5796 if (cie
->chunk_start
== look_for
)
5801 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
5802 if (cie
->chunk_start
== look_for
)
5806 unsigned int off_size
;
5807 unsigned char *cie_scan
;
5809 cie_scan
= look_for
;
5811 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
5812 if (length
== 0xffffffff)
5814 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
5821 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
5824 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
5825 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
5830 read_cie (cie_scan
, end
, &cie
, &version
,
5831 &augmentation_data_len
, &augmentation_data
);
5832 /* PR 17512: file: 3450-2098-0.004. */
5835 warn (_("Failed to read CIE information\n"));
5838 cie
->next
= forward_refs
;
5840 cie
->chunk_start
= look_for
;
5841 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5844 if (frame_need_space (cie
, mreg
) < 0)
5846 warn (_("Invalid max register\n"));
5849 if (cie
->fde_encoding
)
5851 = size_of_encoded_value (cie
->fde_encoding
);
5858 memset (fc
, 0, sizeof (Frame_Chunk
));
5862 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5863 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5864 (unsigned long) (saved_start
- section_start
));
5866 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5867 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5868 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
5870 warn (_("Invalid max register\n"));
5874 fc
->augmentation
= "";
5875 fc
->fde_encoding
= 0;
5876 fc
->ptr_size
= eh_addr_size
;
5877 fc
->segment_size
= 0;
5881 fc
->ncols
= cie
->ncols
;
5882 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5883 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5884 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5885 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5886 fc
->augmentation
= cie
->augmentation
;
5887 fc
->ptr_size
= cie
->ptr_size
;
5888 eh_addr_size
= cie
->ptr_size
;
5889 fc
->segment_size
= cie
->segment_size
;
5890 fc
->code_factor
= cie
->code_factor
;
5891 fc
->data_factor
= cie
->data_factor
;
5892 fc
->cfa_reg
= cie
->cfa_reg
;
5893 fc
->cfa_offset
= cie
->cfa_offset
;
5895 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
5897 warn (_("Invalid max register\n"));
5900 fc
->fde_encoding
= cie
->fde_encoding
;
5903 if (fc
->fde_encoding
)
5904 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5906 segment_selector
= 0;
5907 if (fc
->segment_size
)
5908 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5910 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
5912 /* FIXME: It appears that sometimes the final pc_range value is
5913 encoded in less than encoded_ptr_size bytes. See the x86_64
5914 run of the "objcopy on compressed debug sections" test for an
5916 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5918 if (cie
->augmentation
[0] == 'z')
5920 augmentation_data_len
= LEB ();
5921 augmentation_data
= start
;
5922 start
+= augmentation_data_len
;
5923 /* PR 17512: file: 722-8446-0.004. */
5924 if (start
>= end
|| ((signed long) augmentation_data_len
) < 0)
5926 warn (_("Corrupt augmentation data length: %lx\n"),
5927 augmentation_data_len
);
5929 augmentation_data
= NULL
;
5930 augmentation_data_len
= 0;
5934 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
5935 (unsigned long)(saved_start
- section_start
),
5936 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
5937 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5938 (unsigned long)(cie
->chunk_start
- section_start
));
5940 if (fc
->segment_size
)
5941 printf ("%04lx:", segment_selector
);
5944 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
5945 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
5947 if (! do_debug_frames_interp
&& augmentation_data_len
)
5951 printf (" Augmentation data: ");
5952 for (i
= 0; i
< augmentation_data_len
; ++i
)
5953 printf (" %02x", augmentation_data
[i
]);
5959 /* At this point, fc is the current chunk, cie (if any) is set, and
5960 we're about to interpret instructions for the chunk. */
5961 /* ??? At present we need to do this always, since this sizes the
5962 fc->col_type and fc->col_offset arrays, which we write into always.
5963 We should probably split the interpreted and non-interpreted bits
5964 into two different routines, since there's so much that doesn't
5965 really overlap between them. */
5966 if (1 || do_debug_frames_interp
)
5968 /* Start by making a pass over the chunk, allocating storage
5969 and taking note of what registers are used. */
5970 unsigned char *tmp
= start
;
5972 while (start
< block_end
)
5974 unsigned int reg
, op
, opa
;
5976 unsigned char * new_start
;
5983 /* Warning: if you add any more cases to this switch, be
5984 sure to add them to the corresponding switch below. */
5987 case DW_CFA_advance_loc
:
5991 if (frame_need_space (fc
, opa
) >= 0)
5992 fc
->col_type
[opa
] = DW_CFA_undefined
;
5994 case DW_CFA_restore
:
5995 if (frame_need_space (fc
, opa
) >= 0)
5996 fc
->col_type
[opa
] = DW_CFA_undefined
;
5998 case DW_CFA_set_loc
:
5999 start
+= encoded_ptr_size
;
6001 case DW_CFA_advance_loc1
:
6004 case DW_CFA_advance_loc2
:
6007 case DW_CFA_advance_loc4
:
6010 case DW_CFA_offset_extended
:
6011 case DW_CFA_val_offset
:
6012 reg
= LEB (); LEB ();
6013 if (frame_need_space (fc
, reg
) >= 0)
6014 fc
->col_type
[reg
] = DW_CFA_undefined
;
6016 case DW_CFA_restore_extended
:
6018 if (frame_need_space (fc
, reg
) >= 0)
6019 fc
->col_type
[reg
] = DW_CFA_undefined
;
6021 case DW_CFA_undefined
:
6023 if (frame_need_space (fc
, reg
) >= 0)
6024 fc
->col_type
[reg
] = DW_CFA_undefined
;
6026 case DW_CFA_same_value
:
6028 if (frame_need_space (fc
, reg
) >= 0)
6029 fc
->col_type
[reg
] = DW_CFA_undefined
;
6031 case DW_CFA_register
:
6032 reg
= LEB (); LEB ();
6033 if (frame_need_space (fc
, reg
) >= 0)
6034 fc
->col_type
[reg
] = DW_CFA_undefined
;
6036 case DW_CFA_def_cfa
:
6039 case DW_CFA_def_cfa_register
:
6042 case DW_CFA_def_cfa_offset
:
6045 case DW_CFA_def_cfa_expression
:
6047 new_start
= start
+ temp
;
6048 if (new_start
< start
)
6050 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
6056 case DW_CFA_expression
:
6057 case DW_CFA_val_expression
:
6060 new_start
= start
+ temp
;
6061 if (new_start
< start
)
6063 /* PR 17512: file:306-192417-0.005. */
6064 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
6069 if (frame_need_space (fc
, reg
) >= 0)
6070 fc
->col_type
[reg
] = DW_CFA_undefined
;
6072 case DW_CFA_offset_extended_sf
:
6073 case DW_CFA_val_offset_sf
:
6074 reg
= LEB (); SLEB ();
6075 if (frame_need_space (fc
, reg
) >= 0)
6076 fc
->col_type
[reg
] = DW_CFA_undefined
;
6078 case DW_CFA_def_cfa_sf
:
6081 case DW_CFA_def_cfa_offset_sf
:
6084 case DW_CFA_MIPS_advance_loc8
:
6087 case DW_CFA_GNU_args_size
:
6090 case DW_CFA_GNU_negative_offset_extended
:
6091 reg
= LEB (); LEB ();
6092 if (frame_need_space (fc
, reg
) >= 0)
6093 fc
->col_type
[reg
] = DW_CFA_undefined
;
6102 /* Now we know what registers are used, make a second pass over
6103 the chunk, this time actually printing out the info. */
6105 while (start
< block_end
)
6108 unsigned long ul
, reg
, roffs
;
6112 const char *reg_prefix
= "";
6119 /* Warning: if you add any more cases to this switch, be
6120 sure to add them to the corresponding switch above. */
6123 case DW_CFA_advance_loc
:
6124 if (do_debug_frames_interp
)
6125 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6127 printf (" DW_CFA_advance_loc: %d to %s\n",
6128 opa
* fc
->code_factor
,
6129 dwarf_vmatoa_1 (NULL
,
6130 fc
->pc_begin
+ opa
* fc
->code_factor
,
6132 fc
->pc_begin
+= opa
* fc
->code_factor
;
6137 if (opa
>= (unsigned int) fc
->ncols
)
6138 reg_prefix
= bad_reg
;
6139 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6140 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6141 reg_prefix
, regname (opa
, 0),
6142 roffs
* fc
->data_factor
);
6143 if (*reg_prefix
== '\0')
6145 fc
->col_type
[opa
] = DW_CFA_offset
;
6146 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
6150 case DW_CFA_restore
:
6151 if (opa
>= (unsigned int) cie
->ncols
6152 || opa
>= (unsigned int) fc
->ncols
)
6153 reg_prefix
= bad_reg
;
6154 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6155 printf (" DW_CFA_restore: %s%s\n",
6156 reg_prefix
, regname (opa
, 0));
6157 if (*reg_prefix
== '\0')
6159 fc
->col_type
[opa
] = cie
->col_type
[opa
];
6160 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
6161 if (do_debug_frames_interp
6162 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
6163 fc
->col_type
[opa
] = DW_CFA_undefined
;
6167 case DW_CFA_set_loc
:
6168 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
6169 if (do_debug_frames_interp
)
6170 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6172 printf (" DW_CFA_set_loc: %s\n",
6173 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
6177 case DW_CFA_advance_loc1
:
6178 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
6179 if (do_debug_frames_interp
)
6180 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6182 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6183 (unsigned long) (ofs
* fc
->code_factor
),
6184 dwarf_vmatoa_1 (NULL
,
6185 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6187 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6190 case DW_CFA_advance_loc2
:
6191 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
6192 if (do_debug_frames_interp
)
6193 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6195 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6196 (unsigned long) (ofs
* fc
->code_factor
),
6197 dwarf_vmatoa_1 (NULL
,
6198 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6200 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6203 case DW_CFA_advance_loc4
:
6204 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
6205 if (do_debug_frames_interp
)
6206 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6208 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6209 (unsigned long) (ofs
* fc
->code_factor
),
6210 dwarf_vmatoa_1 (NULL
,
6211 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6213 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6216 case DW_CFA_offset_extended
:
6219 if (reg
>= (unsigned int) fc
->ncols
)
6220 reg_prefix
= bad_reg
;
6221 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6222 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6223 reg_prefix
, regname (reg
, 0),
6224 roffs
* fc
->data_factor
);
6225 if (*reg_prefix
== '\0')
6227 fc
->col_type
[reg
] = DW_CFA_offset
;
6228 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6232 case DW_CFA_val_offset
:
6235 if (reg
>= (unsigned int) fc
->ncols
)
6236 reg_prefix
= bad_reg
;
6237 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6238 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6239 reg_prefix
, regname (reg
, 0),
6240 roffs
* fc
->data_factor
);
6241 if (*reg_prefix
== '\0')
6243 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6244 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6248 case DW_CFA_restore_extended
:
6250 if (reg
>= (unsigned int) cie
->ncols
6251 || reg
>= (unsigned int) fc
->ncols
)
6252 reg_prefix
= bad_reg
;
6253 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6254 printf (" DW_CFA_restore_extended: %s%s\n",
6255 reg_prefix
, regname (reg
, 0));
6256 if (*reg_prefix
== '\0')
6258 fc
->col_type
[reg
] = cie
->col_type
[reg
];
6259 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
6263 case DW_CFA_undefined
:
6265 if (reg
>= (unsigned int) fc
->ncols
)
6266 reg_prefix
= bad_reg
;
6267 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6268 printf (" DW_CFA_undefined: %s%s\n",
6269 reg_prefix
, regname (reg
, 0));
6270 if (*reg_prefix
== '\0')
6272 fc
->col_type
[reg
] = DW_CFA_undefined
;
6273 fc
->col_offset
[reg
] = 0;
6277 case DW_CFA_same_value
:
6279 if (reg
>= (unsigned int) fc
->ncols
)
6280 reg_prefix
= bad_reg
;
6281 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6282 printf (" DW_CFA_same_value: %s%s\n",
6283 reg_prefix
, regname (reg
, 0));
6284 if (*reg_prefix
== '\0')
6286 fc
->col_type
[reg
] = DW_CFA_same_value
;
6287 fc
->col_offset
[reg
] = 0;
6291 case DW_CFA_register
:
6294 if (reg
>= (unsigned int) fc
->ncols
)
6295 reg_prefix
= bad_reg
;
6296 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6298 printf (" DW_CFA_register: %s%s in ",
6299 reg_prefix
, regname (reg
, 0));
6300 puts (regname (roffs
, 0));
6302 if (*reg_prefix
== '\0')
6304 fc
->col_type
[reg
] = DW_CFA_register
;
6305 fc
->col_offset
[reg
] = roffs
;
6309 case DW_CFA_remember_state
:
6310 if (! do_debug_frames_interp
)
6311 printf (" DW_CFA_remember_state\n");
6312 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6313 rs
->cfa_offset
= fc
->cfa_offset
;
6314 rs
->cfa_reg
= fc
->cfa_reg
;
6316 rs
->cfa_exp
= fc
->cfa_exp
;
6317 rs
->ncols
= fc
->ncols
;
6318 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
6319 sizeof (* rs
->col_type
));
6320 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
6321 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
6322 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
6323 rs
->next
= remembered_state
;
6324 remembered_state
= rs
;
6327 case DW_CFA_restore_state
:
6328 if (! do_debug_frames_interp
)
6329 printf (" DW_CFA_restore_state\n");
6330 rs
= remembered_state
;
6333 remembered_state
= rs
->next
;
6334 fc
->cfa_offset
= rs
->cfa_offset
;
6335 fc
->cfa_reg
= rs
->cfa_reg
;
6337 fc
->cfa_exp
= rs
->cfa_exp
;
6338 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
6340 warn (_("Invalid column number in saved frame state\n"));
6344 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
6345 memcpy (fc
->col_offset
, rs
->col_offset
,
6346 rs
->ncols
* sizeof (* rs
->col_offset
));
6347 free (rs
->col_type
);
6348 free (rs
->col_offset
);
6351 else if (do_debug_frames_interp
)
6352 printf ("Mismatched DW_CFA_restore_state\n");
6355 case DW_CFA_def_cfa
:
6356 fc
->cfa_reg
= LEB ();
6357 fc
->cfa_offset
= LEB ();
6359 if (! do_debug_frames_interp
)
6360 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6361 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6364 case DW_CFA_def_cfa_register
:
6365 fc
->cfa_reg
= LEB ();
6367 if (! do_debug_frames_interp
)
6368 printf (" DW_CFA_def_cfa_register: %s\n",
6369 regname (fc
->cfa_reg
, 0));
6372 case DW_CFA_def_cfa_offset
:
6373 fc
->cfa_offset
= LEB ();
6374 if (! do_debug_frames_interp
)
6375 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
6379 if (! do_debug_frames_interp
)
6380 printf (" DW_CFA_nop\n");
6383 case DW_CFA_def_cfa_expression
:
6385 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6387 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
6390 if (! do_debug_frames_interp
)
6392 printf (" DW_CFA_def_cfa_expression (");
6393 decode_location_expression (start
, eh_addr_size
, 0, -1,
6401 case DW_CFA_expression
:
6404 if (reg
>= (unsigned int) fc
->ncols
)
6405 reg_prefix
= bad_reg
;
6406 /* PR 17512: file: 069-133014-0.006. */
6407 /* PR 17512: file: 98c02eb4. */
6408 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6410 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
6413 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6415 printf (" DW_CFA_expression: %s%s (",
6416 reg_prefix
, regname (reg
, 0));
6417 decode_location_expression (start
, eh_addr_size
, 0, -1,
6421 if (*reg_prefix
== '\0')
6422 fc
->col_type
[reg
] = DW_CFA_expression
;
6426 case DW_CFA_val_expression
:
6429 if (reg
>= (unsigned int) fc
->ncols
)
6430 reg_prefix
= bad_reg
;
6431 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6433 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
6436 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6438 printf (" DW_CFA_val_expression: %s%s (",
6439 reg_prefix
, regname (reg
, 0));
6440 decode_location_expression (start
, eh_addr_size
, 0, -1,
6444 if (*reg_prefix
== '\0')
6445 fc
->col_type
[reg
] = DW_CFA_val_expression
;
6449 case DW_CFA_offset_extended_sf
:
6452 if (frame_need_space (fc
, reg
) < 0)
6453 reg_prefix
= bad_reg
;
6454 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6455 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6456 reg_prefix
, regname (reg
, 0),
6457 l
* fc
->data_factor
);
6458 if (*reg_prefix
== '\0')
6460 fc
->col_type
[reg
] = DW_CFA_offset
;
6461 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6465 case DW_CFA_val_offset_sf
:
6468 if (frame_need_space (fc
, reg
) < 0)
6469 reg_prefix
= bad_reg
;
6470 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6471 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6472 reg_prefix
, regname (reg
, 0),
6473 l
* fc
->data_factor
);
6474 if (*reg_prefix
== '\0')
6476 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6477 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6481 case DW_CFA_def_cfa_sf
:
6482 fc
->cfa_reg
= LEB ();
6483 fc
->cfa_offset
= SLEB ();
6484 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6486 if (! do_debug_frames_interp
)
6487 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6488 regname (fc
->cfa_reg
, 0), fc
->cfa_offset
);
6491 case DW_CFA_def_cfa_offset_sf
:
6492 fc
->cfa_offset
= SLEB ();
6493 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6494 if (! do_debug_frames_interp
)
6495 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
6498 case DW_CFA_MIPS_advance_loc8
:
6499 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
6500 if (do_debug_frames_interp
)
6501 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6503 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6504 (unsigned long) (ofs
* fc
->code_factor
),
6505 dwarf_vmatoa_1 (NULL
,
6506 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6508 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6511 case DW_CFA_GNU_window_save
:
6512 if (! do_debug_frames_interp
)
6513 printf (" DW_CFA_GNU_window_save\n");
6516 case DW_CFA_GNU_args_size
:
6518 if (! do_debug_frames_interp
)
6519 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
6522 case DW_CFA_GNU_negative_offset_extended
:
6525 if (frame_need_space (fc
, reg
) < 0)
6526 reg_prefix
= bad_reg
;
6527 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6528 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6529 reg_prefix
, regname (reg
, 0),
6530 l
* fc
->data_factor
);
6531 if (*reg_prefix
== '\0')
6533 fc
->col_type
[reg
] = DW_CFA_offset
;
6534 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6539 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
6540 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
6542 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
6547 if (do_debug_frames_interp
)
6548 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6551 eh_addr_size
= saved_eh_addr_size
;
6564 display_gdb_index (struct dwarf_section
*section
,
6565 void *file ATTRIBUTE_UNUSED
)
6567 unsigned char *start
= section
->start
;
6569 uint32_t cu_list_offset
, tu_list_offset
;
6570 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6571 unsigned int cu_list_elements
, tu_list_elements
;
6572 unsigned int address_table_size
, symbol_table_slots
;
6573 unsigned char *cu_list
, *tu_list
;
6574 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6577 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6579 printf (_("Contents of the %s section:\n"), section
->name
);
6581 if (section
->size
< 6 * sizeof (uint32_t))
6583 warn (_("Truncated header in the %s section.\n"), section
->name
);
6587 version
= byte_get_little_endian (start
, 4);
6588 printf (_("Version %ld\n"), (long) version
);
6590 /* Prior versions are obsolete, and future versions may not be
6591 backwards compatible. */
6592 if (version
< 3 || version
> 8)
6594 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6598 warn (_("The address table data in version 3 may be wrong.\n"));
6600 warn (_("Version 4 does not support case insensitive lookups.\n"));
6602 warn (_("Version 5 does not include inlined functions.\n"));
6604 warn (_("Version 6 does not include symbol attributes.\n"));
6605 /* Version 7 indices generated by Gold have bad type unit references,
6606 PR binutils/15021. But we don't know if the index was generated by
6607 Gold or not, so to avoid worrying users with gdb-generated indices
6608 we say nothing for version 7 here. */
6610 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6611 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6612 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6613 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6614 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6616 if (cu_list_offset
> section
->size
6617 || tu_list_offset
> section
->size
6618 || address_table_offset
> section
->size
6619 || symbol_table_offset
> section
->size
6620 || constant_pool_offset
> section
->size
)
6622 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6626 /* PR 17531: file: 418d0a8a. */
6627 if (tu_list_offset
< cu_list_offset
)
6629 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6630 tu_list_offset
, cu_list_offset
);
6634 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6636 if (address_table_offset
< tu_list_offset
)
6638 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6639 address_table_offset
, tu_list_offset
);
6643 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6645 /* PR 17531: file: 18a47d3d. */
6646 if (symbol_table_offset
< address_table_offset
)
6648 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6649 symbol_table_offset
, address_table_offset
);
6653 address_table_size
= symbol_table_offset
- address_table_offset
;
6655 if (constant_pool_offset
< symbol_table_offset
)
6657 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6658 constant_pool_offset
, symbol_table_offset
);
6662 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6664 cu_list
= start
+ cu_list_offset
;
6665 tu_list
= start
+ tu_list_offset
;
6666 address_table
= start
+ address_table_offset
;
6667 symbol_table
= start
+ symbol_table_offset
;
6668 constant_pool
= start
+ constant_pool_offset
;
6670 if (address_table
+ address_table_size
* (2 + 8 + 4) > section
->start
+ section
->size
)
6672 warn (_("Address table extends beyond end of section.\n"));
6676 printf (_("\nCU table:\n"));
6677 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6679 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6680 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6682 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6683 (unsigned long) cu_offset
,
6684 (unsigned long) (cu_offset
+ cu_length
- 1));
6687 printf (_("\nTU table:\n"));
6688 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6690 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6691 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6692 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6694 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6695 (unsigned long) tu_offset
,
6696 (unsigned long) type_offset
);
6697 print_dwarf_vma (signature
, 8);
6701 printf (_("\nAddress table:\n"));
6702 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
6705 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6706 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6707 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6709 print_dwarf_vma (low
, 8);
6710 print_dwarf_vma (high
, 8);
6711 printf (_("%lu\n"), (unsigned long) cu_index
);
6714 printf (_("\nSymbol table:\n"));
6715 for (i
= 0; i
< symbol_table_slots
; ++i
)
6717 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6718 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6719 uint32_t num_cus
, cu
;
6721 if (name_offset
!= 0
6722 || cu_vector_offset
!= 0)
6726 /* PR 17531: file: 5b7b07ad. */
6727 if (constant_pool
+ name_offset
< constant_pool
6728 || constant_pool
+ name_offset
>= section
->start
+ section
->size
)
6730 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
6731 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6735 printf ("[%3u] %.*s:", i
,
6736 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
6737 constant_pool
+ name_offset
);
6739 if (constant_pool
+ cu_vector_offset
< constant_pool
6740 || constant_pool
+ cu_vector_offset
>= section
->start
+ section
->size
- 3)
6742 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
6743 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6744 cu_vector_offset
, i
);
6748 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
6750 if (num_cus
* 4 < num_cus
6751 || constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4
6752 >= section
->start
+ section
->size
6753 || (constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4) < constant_pool
)
6755 printf ("<invalid number of CUs: %d>\n", num_cus
);
6756 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6764 for (j
= 0; j
< num_cus
; ++j
)
6767 gdb_index_symbol_kind kind
;
6769 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6770 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6771 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6772 cu
= GDB_INDEX_CU_VALUE (cu
);
6773 /* Convert to TU number if it's for a type unit. */
6774 if (cu
>= cu_list_elements
/ 2)
6775 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6776 (unsigned long) (cu
- cu_list_elements
/ 2));
6778 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6780 printf (" [%s, %s]",
6781 is_static
? _("static") : _("global"),
6782 get_gdb_index_symbol_kind_name (kind
));
6794 /* Pre-allocate enough space for the CU/TU sets needed. */
6797 prealloc_cu_tu_list (unsigned int nshndx
)
6799 if (shndx_pool
== NULL
)
6801 shndx_pool_size
= nshndx
;
6802 shndx_pool_used
= 0;
6803 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6804 sizeof (unsigned int));
6808 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6809 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6810 sizeof (unsigned int));
6815 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6817 if (shndx_pool_used
>= shndx_pool_size
)
6819 error (_("Internal error: out of space in the shndx pool.\n"));
6822 shndx_pool
[shndx_pool_used
++] = shndx
;
6826 end_cu_tu_entry (void)
6828 if (shndx_pool_used
>= shndx_pool_size
)
6830 error (_("Internal error: out of space in the shndx pool.\n"));
6833 shndx_pool
[shndx_pool_used
++] = 0;
6836 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6839 get_DW_SECT_short_name (unsigned int dw_sect
)
6841 static char buf
[16];
6849 case DW_SECT_ABBREV
:
6855 case DW_SECT_STR_OFFSETS
:
6857 case DW_SECT_MACINFO
:
6865 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6869 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6870 These sections are extensions for Fission.
6871 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6874 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6876 unsigned char *phdr
= section
->start
;
6877 unsigned char *limit
= phdr
+ section
->size
;
6878 unsigned char *phash
;
6879 unsigned char *pindex
;
6880 unsigned char *ppool
;
6881 unsigned int version
;
6882 unsigned int ncols
= 0;
6884 unsigned int nslots
;
6887 dwarf_vma signature_high
;
6888 dwarf_vma signature_low
;
6891 /* PR 17512: file: 002-168123-0.004. */
6894 warn (_("Section %s is empty\n"), section
->name
);
6897 /* PR 17512: file: 002-376-0.004. */
6898 if (section
->size
< 24)
6900 warn (_("Section %s is too small to contain a CU/TU header\n"),
6905 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
6907 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
6908 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
6909 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
6912 pindex
= phash
+ nslots
* 8;
6913 ppool
= pindex
+ nslots
* 4;
6915 /* PR 17531: file: 45d69832. */
6916 if (pindex
< phash
|| ppool
< phdr
)
6918 warn (_("Section %s is too small for %d slots\n"),
6919 section
->name
, nslots
);
6925 printf (_("Contents of the %s section:\n\n"), section
->name
);
6926 printf (_(" Version: %d\n"), version
);
6928 printf (_(" Number of columns: %d\n"), ncols
);
6929 printf (_(" Number of used entries: %d\n"), nused
);
6930 printf (_(" Number of slots: %d\n\n"), nslots
);
6935 warn (_("Section %s too small for %d hash table entries\n"),
6936 section
->name
, nslots
);
6943 prealloc_cu_tu_list ((limit
- ppool
) / 4);
6944 for (i
= 0; i
< nslots
; i
++)
6946 unsigned char *shndx_list
;
6949 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
6950 if (signature_high
!= 0 || signature_low
!= 0)
6952 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
6953 shndx_list
= ppool
+ j
* 4;
6954 /* PR 17531: file: 705e010d. */
6955 if (shndx_list
< ppool
)
6957 warn (_("Section index pool located before start of section\n"));
6962 printf (_(" [%3d] Signature: 0x%s Sections: "),
6963 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
6964 buf
, sizeof (buf
)));
6967 if (shndx_list
>= limit
)
6969 warn (_("Section %s too small for shndx pool\n"),
6973 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
6977 printf (" %d", shndx
);
6979 add_shndx_to_cu_tu_entry (shndx
);
6991 else if (version
== 2)
6994 unsigned int dw_sect
;
6995 unsigned char *ph
= phash
;
6996 unsigned char *pi
= pindex
;
6997 unsigned char *poffsets
= ppool
+ ncols
* 4;
6998 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
6999 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
7000 bfd_boolean is_tu_index
;
7001 struct cu_tu_set
*this_set
= NULL
;
7003 unsigned char *prow
;
7005 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
7009 warn (_("Section %s too small for offset and size tables\n"),
7016 printf (_(" Offset table\n"));
7017 printf (" slot %-16s ",
7018 is_tu_index
? _("signature") : _("dwo_id"));
7025 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
7031 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
7038 for (j
= 0; j
< ncols
; j
++)
7040 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7041 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
7046 for (i
= 0; i
< nslots
; i
++)
7048 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
7050 SAFE_BYTE_GET (row
, pi
, 4, limit
);
7053 /* PR 17531: file: a05f6ab3. */
7056 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7062 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
7064 prow
= poffsets
+ (row
- 1) * ncols
* 4;
7067 printf (_(" [%3d] 0x%s"),
7068 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7069 buf
, sizeof (buf
)));
7070 for (j
= 0; j
< ncols
; j
++)
7072 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
7074 printf (" %8d", val
);
7077 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7079 /* PR 17531: file: 10796eb3. */
7080 if (dw_sect
>= DW_SECT_MAX
)
7081 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7083 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
7099 printf (_(" Size table\n"));
7100 printf (" slot %-16s ",
7101 is_tu_index
? _("signature") : _("dwo_id"));
7104 for (j
= 0; j
< ncols
; j
++)
7106 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
7108 printf (" %8s", get_DW_SECT_short_name (val
));
7114 for (i
= 0; i
< nslots
; i
++)
7116 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
7118 SAFE_BYTE_GET (row
, pi
, 4, limit
);
7121 prow
= psizes
+ (row
- 1) * ncols
* 4;
7124 printf (_(" [%3d] 0x%s"),
7125 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7126 buf
, sizeof (buf
)));
7128 for (j
= 0; j
< ncols
; j
++)
7130 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
7132 printf (" %8d", val
);
7135 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7136 if (dw_sect
>= DW_SECT_MAX
)
7137 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7139 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
7151 else if (do_display
)
7152 printf (_(" Unsupported version (%d)\n"), version
);
7160 /* Load the CU and TU indexes if present. This will build a list of
7161 section sets that we can use to associate a .debug_info.dwo section
7162 with its associated .debug_abbrev.dwo section in a .dwp file. */
7165 load_cu_tu_indexes (void *file
)
7167 /* If we have already loaded (or tried to load) the CU and TU indexes
7168 then do not bother to repeat the task. */
7169 if (cu_tu_indexes_read
)
7172 if (load_debug_section (dwp_cu_index
, file
))
7173 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
7175 if (load_debug_section (dwp_tu_index
, file
))
7176 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
7178 cu_tu_indexes_read
= 1;
7181 /* Find the set of sections that includes section SHNDX. */
7184 find_cu_tu_set (void *file
, unsigned int shndx
)
7188 load_cu_tu_indexes (file
);
7190 /* Find SHNDX in the shndx pool. */
7191 for (i
= 0; i
< shndx_pool_used
; i
++)
7192 if (shndx_pool
[i
] == shndx
)
7195 if (i
>= shndx_pool_used
)
7198 /* Now backup to find the first entry in the set. */
7199 while (i
> 0 && shndx_pool
[i
- 1] != 0)
7202 return shndx_pool
+ i
;
7205 /* Display a .debug_cu_index or .debug_tu_index section. */
7208 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
7210 return process_cu_tu_index (section
, 1);
7214 display_debug_not_supported (struct dwarf_section
*section
,
7215 void *file ATTRIBUTE_UNUSED
)
7217 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7223 /* Like malloc, but takes two parameters like calloc.
7224 Verifies that the first parameter is not too large.
7225 Note: does *not* initialise the allocated memory to zero. */
7227 cmalloc (size_t nmemb
, size_t size
)
7229 /* Check for overflow. */
7230 if (nmemb
>= ~(size_t) 0 / size
)
7233 return xmalloc (nmemb
* size
);
7236 /* Like xmalloc, but takes two parameters like calloc.
7237 Verifies that the first parameter is not too large.
7238 Note: does *not* initialise the allocated memory to zero. */
7240 xcmalloc (size_t nmemb
, size_t size
)
7242 /* Check for overflow. */
7243 if (nmemb
>= ~(size_t) 0 / size
)
7246 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7251 return xmalloc (nmemb
* size
);
7254 /* Like xrealloc, but takes three parameters.
7255 Verifies that the second parameter is not too large.
7256 Note: does *not* initialise any new memory to zero. */
7258 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
7260 /* Check for overflow. */
7261 if (nmemb
>= ~(size_t) 0 / size
)
7264 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7269 return xrealloc (ptr
, nmemb
* size
);
7272 /* Like xcalloc, but verifies that the first parameter is not too large. */
7274 xcalloc2 (size_t nmemb
, size_t size
)
7276 /* Check for overflow. */
7277 if (nmemb
>= ~(size_t) 0 / size
)
7280 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7285 return xcalloc (nmemb
, size
);
7289 free_debug_memory (void)
7295 for (i
= 0; i
< max
; i
++)
7296 free_debug_section ((enum dwarf_section_display_enum
) i
);
7298 if (debug_information
!= NULL
)
7300 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
7302 for (i
= 0; i
< num_debug_info_entries
; i
++)
7304 if (!debug_information
[i
].max_loc_offsets
)
7306 free (debug_information
[i
].loc_offsets
);
7307 free (debug_information
[i
].have_frame_base
);
7309 if (!debug_information
[i
].max_range_lists
)
7310 free (debug_information
[i
].range_lists
);
7313 free (debug_information
);
7314 debug_information
= NULL
;
7315 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
7320 dwarf_select_sections_by_names (const char *names
)
7324 const char * option
;
7328 debug_dump_long_opts
;
7330 static const debug_dump_long_opts opts_table
[] =
7332 /* Please keep this table alpha- sorted. */
7333 { "Ranges", & do_debug_ranges
, 1 },
7334 { "abbrev", & do_debug_abbrevs
, 1 },
7335 { "addr", & do_debug_addr
, 1 },
7336 { "aranges", & do_debug_aranges
, 1 },
7337 { "cu_index", & do_debug_cu_index
, 1 },
7338 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
7339 { "frames", & do_debug_frames
, 1 },
7340 { "frames-interp", & do_debug_frames_interp
, 1 },
7341 /* The special .gdb_index section. */
7342 { "gdb_index", & do_gdb_index
, 1 },
7343 { "info", & do_debug_info
, 1 },
7344 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
7345 { "loc", & do_debug_loc
, 1 },
7346 { "macro", & do_debug_macinfo
, 1 },
7347 { "pubnames", & do_debug_pubnames
, 1 },
7348 { "pubtypes", & do_debug_pubtypes
, 1 },
7349 /* This entry is for compatability
7350 with earlier versions of readelf. */
7351 { "ranges", & do_debug_aranges
, 1 },
7352 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
7353 { "str", & do_debug_str
, 1 },
7354 /* These trace_* sections are used by Itanium VMS. */
7355 { "trace_abbrev", & do_trace_abbrevs
, 1 },
7356 { "trace_aranges", & do_trace_aranges
, 1 },
7357 { "trace_info", & do_trace_info
, 1 },
7366 const debug_dump_long_opts
* entry
;
7368 for (entry
= opts_table
; entry
->option
; entry
++)
7370 size_t len
= strlen (entry
->option
);
7372 if (strncmp (p
, entry
->option
, len
) == 0
7373 && (p
[len
] == ',' || p
[len
] == '\0'))
7375 * entry
->variable
|= entry
->val
;
7377 /* The --debug-dump=frames-interp option also
7378 enables the --debug-dump=frames option. */
7379 if (do_debug_frames_interp
)
7380 do_debug_frames
= 1;
7387 if (entry
->option
== NULL
)
7389 warn (_("Unrecognized debug option '%s'\n"), p
);
7390 p
= strchr (p
, ',');
7401 dwarf_select_sections_by_letters (const char *letters
)
7403 unsigned int lindex
= 0;
7405 while (letters
[lindex
])
7406 switch (letters
[lindex
++])
7413 do_debug_abbrevs
= 1;
7417 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
7421 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
7425 do_debug_pubnames
= 1;
7429 do_debug_pubtypes
= 1;
7433 do_debug_aranges
= 1;
7437 do_debug_ranges
= 1;
7441 do_debug_frames_interp
= 1;
7443 do_debug_frames
= 1;
7447 do_debug_macinfo
= 1;
7459 warn (_("Unrecognized debug option '%s'\n"), letters
);
7465 dwarf_select_sections_all (void)
7468 do_debug_abbrevs
= 1;
7469 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
7470 do_debug_pubnames
= 1;
7471 do_debug_pubtypes
= 1;
7472 do_debug_aranges
= 1;
7473 do_debug_ranges
= 1;
7474 do_debug_frames
= 1;
7475 do_debug_macinfo
= 1;
7480 do_trace_abbrevs
= 1;
7481 do_trace_aranges
= 1;
7483 do_debug_cu_index
= 1;
7486 struct dwarf_section_display debug_displays
[] =
7488 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0, NULL
},
7489 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7490 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0, NULL
},
7491 display_debug_aranges
, &do_debug_aranges
, 1 },
7492 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0, NULL
},
7493 display_debug_frames
, &do_debug_frames
, 1 },
7494 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
, NULL
},
7495 display_debug_info
, &do_debug_info
, 1 },
7496 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0, NULL
},
7497 display_debug_lines
, &do_debug_lines
, 1 },
7498 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0, NULL
},
7499 display_debug_pubnames
, &do_debug_pubnames
, 0 },
7500 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0, NULL
},
7501 display_debug_gnu_pubnames
, &do_debug_pubnames
, 0 },
7502 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0, NULL
},
7503 display_debug_frames
, &do_debug_frames
, 1 },
7504 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0, NULL
},
7505 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7506 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0, NULL
},
7507 display_debug_macro
, &do_debug_macinfo
, 1 },
7508 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0, NULL
},
7509 display_debug_str
, &do_debug_str
, 0 },
7510 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0, NULL
},
7511 display_debug_loc
, &do_debug_loc
, 1 },
7512 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
},
7513 display_debug_pubnames
, &do_debug_pubtypes
, 0 },
7514 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
},
7515 display_debug_gnu_pubnames
, &do_debug_pubtypes
, 0 },
7516 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0, NULL
},
7517 display_debug_ranges
, &do_debug_ranges
, 1 },
7518 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0, NULL
},
7519 display_debug_not_supported
, NULL
, 0 },
7520 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0, NULL
},
7521 display_debug_not_supported
, NULL
, 0 },
7522 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
, NULL
},
7523 display_debug_types
, &do_debug_info
, 1 },
7524 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0, NULL
},
7525 display_debug_not_supported
, NULL
, 0 },
7526 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7527 display_gdb_index
, &do_gdb_index
, 0 },
7528 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
, NULL
},
7529 display_trace_info
, &do_trace_info
, 1 },
7530 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0, NULL
},
7531 display_debug_abbrev
, &do_trace_abbrevs
, 0 },
7532 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0, NULL
},
7533 display_debug_aranges
, &do_trace_aranges
, 0 },
7534 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
},
7535 display_debug_info
, &do_debug_info
, 1 },
7536 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7537 display_debug_abbrev
, &do_debug_abbrevs
, 0 },
7538 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
},
7539 display_debug_types
, &do_debug_info
, 1 },
7540 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7541 display_debug_lines
, &do_debug_lines
, 1 },
7542 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7543 display_debug_loc
, &do_debug_loc
, 1 },
7544 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7545 display_debug_macro
, &do_debug_macinfo
, 1 },
7546 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7547 display_debug_macinfo
, &do_debug_macinfo
, 0 },
7548 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7549 display_debug_str
, &do_debug_str
, 1 },
7550 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0, NULL
},
7551 display_debug_str_offsets
, NULL
, 0 },
7552 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0, NULL
},
7553 display_debug_str_offsets
, NULL
, 0 },
7554 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0, NULL
},
7555 display_debug_addr
, &do_debug_addr
, 1 },
7556 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7557 display_cu_index
, &do_debug_cu_index
, 0 },
7558 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0, NULL
},
7559 display_cu_index
, &do_debug_cu_index
, 0 },