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
) * 8)
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;
2009 /* DWARF 4 values: */
2010 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2013 if (uvalue
>= DW_ATE_lo_user
2014 && uvalue
<= DW_ATE_hi_user
)
2015 printf (_("(user defined type)"));
2017 printf (_("(unknown type)"));
2022 case DW_AT_accessibility
:
2026 case DW_ACCESS_public
: printf ("(public)"); break;
2027 case DW_ACCESS_protected
: printf ("(protected)"); break;
2028 case DW_ACCESS_private
: printf ("(private)"); break;
2030 printf (_("(unknown accessibility)"));
2035 case DW_AT_visibility
:
2039 case DW_VIS_local
: printf ("(local)"); break;
2040 case DW_VIS_exported
: printf ("(exported)"); break;
2041 case DW_VIS_qualified
: printf ("(qualified)"); break;
2042 default: printf (_("(unknown visibility)")); break;
2046 case DW_AT_virtuality
:
2050 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2051 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2052 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2053 default: printf (_("(unknown virtuality)")); break;
2057 case DW_AT_identifier_case
:
2061 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2062 case DW_ID_up_case
: printf ("(up_case)"); break;
2063 case DW_ID_down_case
: printf ("(down_case)"); break;
2064 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2065 default: printf (_("(unknown case)")); break;
2069 case DW_AT_calling_convention
:
2073 case DW_CC_normal
: printf ("(normal)"); break;
2074 case DW_CC_program
: printf ("(program)"); break;
2075 case DW_CC_nocall
: printf ("(nocall)"); break;
2077 if (uvalue
>= DW_CC_lo_user
2078 && uvalue
<= DW_CC_hi_user
)
2079 printf (_("(user defined)"));
2081 printf (_("(unknown convention)"));
2085 case DW_AT_ordering
:
2089 case -1: printf (_("(undefined)")); break;
2090 case 0: printf ("(row major)"); break;
2091 case 1: printf ("(column major)"); break;
2095 case DW_AT_frame_base
:
2096 have_frame_base
= 1;
2097 case DW_AT_location
:
2098 case DW_AT_string_length
:
2099 case DW_AT_return_addr
:
2100 case DW_AT_data_member_location
:
2101 case DW_AT_vtable_elem_location
:
2103 case DW_AT_static_link
:
2104 case DW_AT_use_location
:
2105 case DW_AT_GNU_call_site_value
:
2106 case DW_AT_GNU_call_site_data_value
:
2107 case DW_AT_GNU_call_site_target
:
2108 case DW_AT_GNU_call_site_target_clobbered
:
2109 if ((dwarf_version
< 4
2110 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2111 || form
== DW_FORM_sec_offset
)
2112 printf (_(" (location list)"));
2114 case DW_AT_allocated
:
2115 case DW_AT_associated
:
2116 case DW_AT_data_location
:
2118 case DW_AT_upper_bound
:
2119 case DW_AT_lower_bound
:
2122 int need_frame_base
;
2125 need_frame_base
= decode_location_expression (block_start
,
2130 cu_offset
, section
);
2132 if (need_frame_base
&& !have_frame_base
)
2133 printf (_(" [without DW_AT_frame_base]"));
2139 if (form
== DW_FORM_ref_sig8
2140 || form
== DW_FORM_GNU_ref_alt
)
2143 if (form
== DW_FORM_ref1
2144 || form
== DW_FORM_ref2
2145 || form
== DW_FORM_ref4
2146 || form
== DW_FORM_ref_udata
)
2147 uvalue
+= cu_offset
;
2149 if (uvalue
>= section
->size
)
2150 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2151 dwarf_vmatoa ("x", uvalue
),
2152 (unsigned long) (orig_data
- section
->start
));
2155 unsigned long abbrev_number
;
2156 abbrev_entry
* entry
;
2158 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2160 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2161 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2162 use different abbrev table, and we don't track .debug_info chunks
2164 if (form
!= DW_FORM_ref_addr
)
2166 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2167 if (entry
->entry
== abbrev_number
)
2170 printf (" (%s)", get_TAG_name (entry
->tag
));
2185 get_AT_name (unsigned long attribute
)
2190 return "DW_AT value: 0";
2192 /* One value is shared by the MIPS and HP extensions: */
2193 if (attribute
== DW_AT_MIPS_fde
)
2194 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2196 name
= get_DW_AT_name (attribute
);
2200 static char buffer
[100];
2202 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2210 static unsigned char *
2211 read_and_display_attr (unsigned long attribute
,
2213 unsigned char * data
,
2214 unsigned char * end
,
2215 dwarf_vma cu_offset
,
2216 dwarf_vma pointer_size
,
2217 dwarf_vma offset_size
,
2219 debug_info
* debug_info_p
,
2221 struct dwarf_section
* section
,
2222 struct cu_tu_set
* this_set
)
2225 printf (" %-18s:", get_AT_name (attribute
));
2226 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2227 cu_offset
, pointer_size
, offset_size
,
2228 dwarf_version
, debug_info_p
,
2229 do_loc
, section
, this_set
);
2235 /* Process the contents of a .debug_info section. If do_loc is non-zero
2236 then we are scanning for location lists and we do not want to display
2237 anything to the user. If do_types is non-zero, we are processing
2238 a .debug_types section instead of a .debug_info section. */
2241 process_debug_info (struct dwarf_section
*section
,
2243 enum dwarf_section_display_enum abbrev_sec
,
2247 unsigned char *start
= section
->start
;
2248 unsigned char *end
= start
+ section
->size
;
2249 unsigned char *section_begin
;
2251 unsigned int num_units
= 0;
2253 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2254 && num_debug_info_entries
== 0
2259 /* First scan the section to get the number of comp units. */
2260 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2263 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2264 will be the length. For a 64-bit DWARF section, it'll be
2265 the escape code 0xffffffff followed by an 8 byte length. */
2266 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2268 if (length
== 0xffffffff)
2270 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2271 section_begin
+= length
+ 12;
2273 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2275 warn (_("Reserved length value (0x%s) found in section %s\n"),
2276 dwarf_vmatoa ("x", length
), section
->name
);
2280 section_begin
+= length
+ 4;
2282 /* Negative values are illegal, they may even cause infinite
2283 looping. This can happen if we can't accurately apply
2284 relocations to an object file, or if the file is corrupt. */
2285 if ((signed long) length
<= 0 || section_begin
< start
)
2287 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2288 dwarf_vmatoa ("x", length
), section
->name
);
2295 error (_("No comp units in %s section ?\n"), section
->name
);
2299 /* Then allocate an array to hold the information. */
2300 debug_information
= (debug_info
*) cmalloc (num_units
,
2301 sizeof (* debug_information
));
2302 if (debug_information
== NULL
)
2304 error (_("Not enough memory for a debug info array of %u entries\n"),
2306 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
2309 /* PR 17531: file: 92ca3797.
2310 We cannot rely upon the debug_information array being initialised
2311 before it is used. A corrupt file could easily contain references
2312 to a unit for which information has not been made available. So
2313 we ensure that the array is zeroed here. */
2314 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
2316 alloc_num_debug_info_entries
= num_units
;
2321 if (dwarf_start_die
== 0)
2322 printf (_("Contents of the %s section:\n\n"), section
->name
);
2324 load_debug_section (str
, file
);
2325 load_debug_section (str_dwo
, file
);
2326 load_debug_section (str_index
, file
);
2327 load_debug_section (str_index_dwo
, file
);
2328 load_debug_section (debug_addr
, file
);
2331 load_debug_section (abbrev_sec
, file
);
2332 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2334 warn (_("Unable to locate %s section!\n"),
2335 debug_displays
[abbrev_sec
].section
.name
);
2339 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2341 DWARF2_Internal_CompUnit compunit
;
2342 unsigned char *hdrptr
;
2343 unsigned char *tags
;
2344 int level
, last_level
, saved_level
;
2345 dwarf_vma cu_offset
;
2346 unsigned int offset_size
;
2347 int initial_length_size
;
2348 dwarf_vma signature_high
= 0;
2349 dwarf_vma signature_low
= 0;
2350 dwarf_vma type_offset
= 0;
2351 struct cu_tu_set
*this_set
;
2352 dwarf_vma abbrev_base
;
2357 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2359 if (compunit
.cu_length
== 0xffffffff)
2361 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2363 initial_length_size
= 12;
2368 initial_length_size
= 4;
2371 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2373 cu_offset
= start
- section_begin
;
2375 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2377 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2379 if (this_set
== NULL
)
2382 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2386 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2387 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2390 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2391 /* PR 17512: file: 001-108546-0.001:0.1. */
2392 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2394 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2395 compunit
.cu_pointer_size
, offset_size
);
2396 compunit
.cu_pointer_size
= offset_size
;
2401 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2403 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2406 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2407 && num_debug_info_entries
== 0
2410 debug_information
[unit
].cu_offset
= cu_offset
;
2411 debug_information
[unit
].pointer_size
2412 = compunit
.cu_pointer_size
;
2413 debug_information
[unit
].offset_size
= offset_size
;
2414 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2415 debug_information
[unit
].base_address
= 0;
2416 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2417 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2418 debug_information
[unit
].loc_offsets
= NULL
;
2419 debug_information
[unit
].have_frame_base
= NULL
;
2420 debug_information
[unit
].max_loc_offsets
= 0;
2421 debug_information
[unit
].num_loc_offsets
= 0;
2422 debug_information
[unit
].range_lists
= NULL
;
2423 debug_information
[unit
].max_range_lists
= 0;
2424 debug_information
[unit
].num_range_lists
= 0;
2427 if (!do_loc
&& dwarf_start_die
== 0)
2429 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2430 dwarf_vmatoa ("x", cu_offset
));
2431 printf (_(" Length: 0x%s (%s)\n"),
2432 dwarf_vmatoa ("x", compunit
.cu_length
),
2433 offset_size
== 8 ? "64-bit" : "32-bit");
2434 printf (_(" Version: %d\n"), compunit
.cu_version
);
2435 printf (_(" Abbrev Offset: 0x%s\n"),
2436 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2437 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2442 printf (_(" Signature: 0x%s\n"),
2443 dwarf_vmatoa64 (signature_high
, signature_low
,
2444 buf
, sizeof (buf
)));
2445 printf (_(" Type Offset: 0x%s\n"),
2446 dwarf_vmatoa ("x", type_offset
));
2448 if (this_set
!= NULL
)
2450 dwarf_vma
*offsets
= this_set
->section_offsets
;
2451 size_t *sizes
= this_set
->section_sizes
;
2453 printf (_(" Section contributions:\n"));
2454 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2455 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2456 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2457 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2458 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2459 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2460 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2461 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2462 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2463 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2464 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2465 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2469 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2472 warn (_("Debug info is corrupted, length of CU at %s"
2473 " extends beyond end of section (length = %s)\n"),
2474 dwarf_vmatoa ("x", cu_offset
),
2475 dwarf_vmatoa ("x", compunit
.cu_length
));
2480 start
+= compunit
.cu_length
+ initial_length_size
;
2484 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2485 dwarf_vmatoa ("x", cu_offset
));
2489 if (compunit
.cu_version
!= 2
2490 && compunit
.cu_version
!= 3
2491 && compunit
.cu_version
!= 4)
2493 warn (_("CU at offset %s contains corrupt or "
2494 "unsupported version number: %d.\n"),
2495 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2501 /* Process the abbrevs used by this compilation unit. */
2502 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2503 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2504 (unsigned long) compunit
.cu_abbrev_offset
,
2505 (unsigned long) abbrev_size
);
2506 /* PR 17531: file:4bcd9ce9. */
2507 else if ((abbrev_base
+ abbrev_size
)
2508 > debug_displays
[abbrev_sec
].section
.size
)
2509 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2510 (unsigned long) abbrev_base
+ abbrev_size
,
2511 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
2513 process_abbrev_section
2514 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2515 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2516 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2517 + abbrev_base
+ abbrev_size
));
2522 while (tags
< start
)
2524 unsigned int bytes_read
;
2525 unsigned long abbrev_number
;
2526 unsigned long die_offset
;
2527 abbrev_entry
*entry
;
2529 int do_printing
= 1;
2531 die_offset
= tags
- section_begin
;
2533 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2536 /* A null DIE marks the end of a list of siblings or it may also be
2537 a section padding. */
2538 if (abbrev_number
== 0)
2540 /* Check if it can be a section padding for the last CU. */
2541 if (level
== 0 && start
== end
)
2545 for (chk
= tags
; chk
< start
; chk
++)
2552 if (!do_loc
&& die_offset
>= dwarf_start_die
2553 && (dwarf_cutoff_level
== -1
2554 || level
< dwarf_cutoff_level
))
2555 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2561 static unsigned num_bogus_warns
= 0;
2563 if (num_bogus_warns
< 3)
2565 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2566 die_offset
, section
->name
);
2568 if (num_bogus_warns
== 3)
2569 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2572 if (dwarf_start_die
!= 0 && level
< saved_level
)
2579 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2583 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2584 saved_level
= level
;
2585 do_printing
= (dwarf_cutoff_level
== -1
2586 || level
< dwarf_cutoff_level
);
2588 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2589 level
, die_offset
, abbrev_number
);
2590 else if (dwarf_cutoff_level
== -1
2591 || last_level
< dwarf_cutoff_level
)
2592 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2597 /* Scan through the abbreviation list until we reach the
2599 for (entry
= first_abbrev
;
2600 entry
&& entry
->entry
!= abbrev_number
;
2601 entry
= entry
->next
)
2606 if (!do_loc
&& do_printing
)
2611 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2612 die_offset
, abbrev_number
);
2616 if (!do_loc
&& do_printing
)
2617 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2622 need_base_address
= 0;
2624 case DW_TAG_compile_unit
:
2625 need_base_address
= 1;
2627 case DW_TAG_entry_point
:
2628 case DW_TAG_subprogram
:
2629 need_base_address
= 0;
2630 /* Assuming that there is no DW_AT_frame_base. */
2631 have_frame_base
= 0;
2635 for (attr
= entry
->first_attr
;
2636 attr
&& attr
->attribute
;
2641 if (! do_loc
&& do_printing
)
2642 /* Show the offset from where the tag was extracted. */
2643 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2645 if (debug_information
&& unit
< alloc_num_debug_info_entries
)
2646 arg
= debug_information
+ unit
;
2650 tags
= read_and_display_attr (attr
->attribute
,
2655 compunit
.cu_pointer_size
,
2657 compunit
.cu_version
,
2659 do_loc
|| ! do_printing
,
2664 if (entry
->children
)
2669 /* Set num_debug_info_entries here so that it can be used to check if
2670 we need to process .debug_loc and .debug_ranges sections. */
2671 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2672 && num_debug_info_entries
== 0
2675 if (num_units
> alloc_num_debug_info_entries
)
2676 num_debug_info_entries
= alloc_num_debug_info_entries
;
2678 num_debug_info_entries
= num_units
;
2687 /* Locate and scan the .debug_info section in the file and record the pointer
2688 sizes and offsets for the compilation units in it. Usually an executable
2689 will have just one pointer size, but this is not guaranteed, and so we try
2690 not to make any assumptions. Returns zero upon failure, or the number of
2691 compilation units upon success. */
2694 load_debug_info (void * file
)
2696 /* Reset the last pointer size so that we can issue correct error
2697 messages if we are displaying the contents of more than one section. */
2698 last_pointer_size
= 0;
2699 warned_about_missing_comp_units
= FALSE
;
2701 /* If we have already tried and failed to load the .debug_info
2702 section then do not bother to repeat the task. */
2703 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2706 /* If we already have the information there is nothing else to do. */
2707 if (num_debug_info_entries
> 0)
2708 return num_debug_info_entries
;
2710 /* If this is a DWARF package file, load the CU and TU indexes. */
2711 load_cu_tu_indexes (file
);
2713 if (load_debug_section (info
, file
)
2714 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2715 return num_debug_info_entries
;
2717 if (load_debug_section (info_dwo
, file
)
2718 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2720 return num_debug_info_entries
;
2722 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2726 /* Read a DWARF .debug_line section header starting at DATA.
2727 Upon success returns an updated DATA pointer and the LINFO
2728 structure and the END_OF_SEQUENCE pointer will be filled in.
2729 Otherwise returns NULL. */
2731 static unsigned char *
2732 read_debug_line_header (struct dwarf_section
* section
,
2733 unsigned char * data
,
2734 unsigned char * end
,
2735 DWARF2_Internal_LineInfo
* linfo
,
2736 unsigned char ** end_of_sequence
)
2738 unsigned char *hdrptr
;
2739 unsigned int offset_size
;
2740 unsigned int initial_length_size
;
2742 /* Extract information from the Line Number Program Header.
2743 (section 6.2.4 in the Dwarf3 doc). */
2746 /* Get and check the length of the block. */
2747 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2749 if (linfo
->li_length
== 0xffffffff)
2751 /* This section is 64-bit DWARF 3. */
2752 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2754 initial_length_size
= 12;
2759 initial_length_size
= 4;
2762 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2764 /* If the length field has a relocation against it, then we should
2765 not complain if it is inaccurate (and probably negative). This
2766 happens in object files when the .debug_line section is actually
2767 comprised of several different .debug_line.* sections, (some of
2768 which may be removed by linker garbage collection), and a relocation
2769 is used to compute the correct length once that is done. */
2770 if (reloc_at (section
, (hdrptr
- section
->start
) - offset_size
))
2772 linfo
->li_length
= (end
- data
) - initial_length_size
;
2776 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
2777 (long) linfo
->li_length
);
2782 /* Get and check the version number. */
2783 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2785 if (linfo
->li_version
!= 2
2786 && linfo
->li_version
!= 3
2787 && linfo
->li_version
!= 4)
2789 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2793 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2794 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2796 if (linfo
->li_version
>= 4)
2798 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2800 if (linfo
->li_max_ops_per_insn
== 0)
2802 warn (_("Invalid maximum operations per insn.\n"));
2807 linfo
->li_max_ops_per_insn
= 1;
2809 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2810 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2811 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2812 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2814 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2815 /* PR 17512: file:002-117414-0.004. */
2816 if (* end_of_sequence
> end
)
2818 warn (_("Line length %s extends beyond end of section\n"),
2819 dwarf_vmatoa ("u", linfo
->li_length
));
2820 * end_of_sequence
= end
;
2828 display_debug_lines_raw (struct dwarf_section
*section
,
2829 unsigned char *data
,
2832 unsigned char *start
= section
->start
;
2834 printf (_("Raw dump of debug contents of section %s:\n\n"),
2839 static DWARF2_Internal_LineInfo saved_linfo
;
2840 DWARF2_Internal_LineInfo linfo
;
2841 unsigned char *standard_opcodes
;
2842 unsigned char *end_of_sequence
;
2843 unsigned int last_dir_entry
= 0;
2846 if (const_strneq (section
->name
, ".debug_line.")
2847 /* Note: the following does not apply to .debug_line.dwo sections.
2848 These are full debug_line sections. */
2849 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2851 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2852 section containing just the Line Number Statements. They are
2853 created by the assembler and intended to be used alongside gcc's
2854 -ffunction-sections command line option. When the linker's
2855 garbage collection decides to discard a .text.<foo> section it
2856 can then also discard the line number information in .debug_line.<foo>.
2858 Since the section is a fragment it does not have the details
2859 needed to fill out a LineInfo structure, so instead we use the
2860 details from the last full debug_line section that we processed. */
2861 end_of_sequence
= end
;
2862 standard_opcodes
= NULL
;
2863 linfo
= saved_linfo
;
2864 /* PR 17531: file: 0522b371. */
2865 if (linfo
.li_line_range
== 0)
2867 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2870 reset_state_machine (linfo
.li_default_is_stmt
);
2874 unsigned char * hdrptr
;
2876 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2877 & end_of_sequence
)) == NULL
)
2880 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2881 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2882 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2883 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
2884 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2885 if (linfo
.li_version
>= 4)
2886 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2887 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2888 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2889 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2890 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2892 /* PR 17512: file: 1665-6428-0.004. */
2893 if (linfo
.li_line_range
== 0)
2895 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2896 linfo
.li_line_range
= 1;
2899 reset_state_machine (linfo
.li_default_is_stmt
);
2901 /* Display the contents of the Opcodes table. */
2902 standard_opcodes
= hdrptr
;
2904 /* PR 17512: file: 002-417945-0.004. */
2905 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
2907 warn (_("Line Base extends beyond end of section\n"));
2911 printf (_("\n Opcodes:\n"));
2913 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2914 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2916 /* Display the contents of the Directory table. */
2917 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2920 printf (_("\n The Directory Table is empty.\n"));
2923 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2924 (long)(data
- start
));
2926 while (data
< end
&& *data
!= 0)
2928 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
2930 data
+= strnlen ((char *) data
, end
- data
) + 1;
2933 /* PR 17512: file: 002-132094-0.004. */
2934 if (data
>= end
- 1)
2938 /* Skip the NUL at the end of the table. */
2941 /* Display the contents of the File Name table. */
2943 printf (_("\n The File Name Table is empty.\n"));
2946 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2947 (long)(data
- start
));
2948 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2950 while (data
< end
&& *data
!= 0)
2952 unsigned char *name
;
2953 unsigned int bytes_read
;
2955 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2957 data
+= strnlen ((char *) data
, end
- data
) + 1;
2960 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2963 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2966 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2968 printf ("%.*s\n", (int)(end
- name
), name
);
2972 warn (_("Corrupt file name table entry\n"));
2978 /* Skip the NUL at the end of the table. */
2981 saved_linfo
= linfo
;
2984 /* Now display the statements. */
2985 if (data
>= end_of_sequence
)
2986 printf (_(" No Line Number Statements.\n"));
2989 printf (_(" Line Number Statements:\n"));
2991 while (data
< end_of_sequence
)
2993 unsigned char op_code
;
2994 dwarf_signed_vma adv
;
2996 unsigned int bytes_read
;
2998 printf (" [0x%08lx]", (long)(data
- start
));
3002 if (op_code
>= linfo
.li_opcode_base
)
3004 op_code
-= linfo
.li_opcode_base
;
3005 uladv
= (op_code
/ linfo
.li_line_range
);
3006 if (linfo
.li_max_ops_per_insn
== 1)
3008 uladv
*= linfo
.li_min_insn_length
;
3009 state_machine_regs
.address
+= uladv
;
3010 printf (_(" Special opcode %d: "
3011 "advance Address by %s to 0x%s"),
3012 op_code
, dwarf_vmatoa ("u", uladv
),
3013 dwarf_vmatoa ("x", state_machine_regs
.address
));
3017 state_machine_regs
.address
3018 += ((state_machine_regs
.op_index
+ uladv
)
3019 / linfo
.li_max_ops_per_insn
)
3020 * linfo
.li_min_insn_length
;
3021 state_machine_regs
.op_index
3022 = (state_machine_regs
.op_index
+ uladv
)
3023 % linfo
.li_max_ops_per_insn
;
3024 printf (_(" Special opcode %d: "
3025 "advance Address by %s to 0x%s[%d]"),
3026 op_code
, dwarf_vmatoa ("u", uladv
),
3027 dwarf_vmatoa ("x", state_machine_regs
.address
),
3028 state_machine_regs
.op_index
);
3030 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3031 state_machine_regs
.line
+= adv
;
3032 printf (_(" and Line by %s to %d\n"),
3033 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
3035 else switch (op_code
)
3037 case DW_LNS_extended_op
:
3038 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3042 printf (_(" Copy\n"));
3045 case DW_LNS_advance_pc
:
3046 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3048 if (linfo
.li_max_ops_per_insn
== 1)
3050 uladv
*= linfo
.li_min_insn_length
;
3051 state_machine_regs
.address
+= uladv
;
3052 printf (_(" Advance PC by %s to 0x%s\n"),
3053 dwarf_vmatoa ("u", uladv
),
3054 dwarf_vmatoa ("x", state_machine_regs
.address
));
3058 state_machine_regs
.address
3059 += ((state_machine_regs
.op_index
+ uladv
)
3060 / linfo
.li_max_ops_per_insn
)
3061 * linfo
.li_min_insn_length
;
3062 state_machine_regs
.op_index
3063 = (state_machine_regs
.op_index
+ uladv
)
3064 % linfo
.li_max_ops_per_insn
;
3065 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3066 dwarf_vmatoa ("u", uladv
),
3067 dwarf_vmatoa ("x", state_machine_regs
.address
),
3068 state_machine_regs
.op_index
);
3072 case DW_LNS_advance_line
:
3073 adv
= read_sleb128 (data
, & bytes_read
, end
);
3075 state_machine_regs
.line
+= adv
;
3076 printf (_(" Advance Line by %s to %d\n"),
3077 dwarf_vmatoa ("d", adv
),
3078 state_machine_regs
.line
);
3081 case DW_LNS_set_file
:
3082 adv
= read_uleb128 (data
, & bytes_read
, end
);
3084 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3085 dwarf_vmatoa ("d", adv
));
3086 state_machine_regs
.file
= adv
;
3089 case DW_LNS_set_column
:
3090 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3092 printf (_(" Set column to %s\n"),
3093 dwarf_vmatoa ("u", uladv
));
3094 state_machine_regs
.column
= uladv
;
3097 case DW_LNS_negate_stmt
:
3098 adv
= state_machine_regs
.is_stmt
;
3100 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3101 state_machine_regs
.is_stmt
= adv
;
3104 case DW_LNS_set_basic_block
:
3105 printf (_(" Set basic block\n"));
3106 state_machine_regs
.basic_block
= 1;
3109 case DW_LNS_const_add_pc
:
3110 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3111 if (linfo
.li_max_ops_per_insn
)
3113 uladv
*= linfo
.li_min_insn_length
;
3114 state_machine_regs
.address
+= uladv
;
3115 printf (_(" Advance PC by constant %s to 0x%s\n"),
3116 dwarf_vmatoa ("u", uladv
),
3117 dwarf_vmatoa ("x", state_machine_regs
.address
));
3121 state_machine_regs
.address
3122 += ((state_machine_regs
.op_index
+ uladv
)
3123 / linfo
.li_max_ops_per_insn
)
3124 * linfo
.li_min_insn_length
;
3125 state_machine_regs
.op_index
3126 = (state_machine_regs
.op_index
+ uladv
)
3127 % linfo
.li_max_ops_per_insn
;
3128 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3129 dwarf_vmatoa ("u", uladv
),
3130 dwarf_vmatoa ("x", state_machine_regs
.address
),
3131 state_machine_regs
.op_index
);
3135 case DW_LNS_fixed_advance_pc
:
3136 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3137 state_machine_regs
.address
+= uladv
;
3138 state_machine_regs
.op_index
= 0;
3139 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3140 dwarf_vmatoa ("u", uladv
),
3141 dwarf_vmatoa ("x", state_machine_regs
.address
));
3144 case DW_LNS_set_prologue_end
:
3145 printf (_(" Set prologue_end to true\n"));
3148 case DW_LNS_set_epilogue_begin
:
3149 printf (_(" Set epilogue_begin to true\n"));
3152 case DW_LNS_set_isa
:
3153 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3155 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3159 printf (_(" Unknown opcode %d with operands: "), op_code
);
3161 if (standard_opcodes
!= NULL
)
3162 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3164 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3166 i
== 1 ? "" : ", ");
3182 unsigned char *name
;
3183 unsigned int directory_index
;
3184 unsigned int modification_date
;
3185 unsigned int length
;
3188 /* Output a decoded representation of the .debug_line section. */
3191 display_debug_lines_decoded (struct dwarf_section
*section
,
3192 unsigned char *data
,
3195 static DWARF2_Internal_LineInfo saved_linfo
;
3197 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3202 /* This loop amounts to one iteration per compilation unit. */
3203 DWARF2_Internal_LineInfo linfo
;
3204 unsigned char *standard_opcodes
;
3205 unsigned char *end_of_sequence
;
3207 File_Entry
*file_table
= NULL
;
3208 unsigned int n_files
= 0;
3209 unsigned char **directory_table
= NULL
;
3210 unsigned int n_directories
= 0;
3212 if (const_strneq (section
->name
, ".debug_line.")
3213 /* Note: the following does not apply to .debug_line.dwo sections.
3214 These are full debug_line sections. */
3215 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3217 /* See comment in display_debug_lines_raw(). */
3218 end_of_sequence
= end
;
3219 standard_opcodes
= NULL
;
3220 linfo
= saved_linfo
;
3221 /* PR 17531: file: 0522b371. */
3222 if (linfo
.li_line_range
== 0)
3224 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3227 reset_state_machine (linfo
.li_default_is_stmt
);
3231 unsigned char *hdrptr
;
3233 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3234 & end_of_sequence
)) == NULL
)
3237 /* PR 17531: file: 0522b371. */
3238 if (linfo
.li_line_range
== 0)
3240 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3241 linfo
.li_line_range
= 1;
3243 reset_state_machine (linfo
.li_default_is_stmt
);
3245 /* Save a pointer to the contents of the Opcodes table. */
3246 standard_opcodes
= hdrptr
;
3248 /* Traverse the Directory table just to count entries. */
3249 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3252 unsigned char *ptr_directory_table
= data
;
3256 data
+= strnlen ((char *) data
, end
- data
) + 1;
3260 /* Go through the directory table again to save the directories. */
3261 directory_table
= (unsigned char **)
3262 xmalloc (n_directories
* sizeof (unsigned char *));
3265 while (*ptr_directory_table
!= 0)
3267 directory_table
[i
] = ptr_directory_table
;
3268 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3269 ptr_directory_table
- end
) + 1;
3273 /* Skip the NUL at the end of the table. */
3276 /* Traverse the File Name table just to count the entries. */
3279 unsigned char *ptr_file_name_table
= data
;
3283 unsigned int bytes_read
;
3285 /* Skip Name, directory index, last modification time and length
3287 data
+= strnlen ((char *) data
, end
- data
) + 1;
3288 read_uleb128 (data
, & bytes_read
, end
);
3290 read_uleb128 (data
, & bytes_read
, end
);
3292 read_uleb128 (data
, & bytes_read
, end
);
3298 /* Go through the file table again to save the strings. */
3299 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3302 while (*ptr_file_name_table
!= 0)
3304 unsigned int bytes_read
;
3306 file_table
[i
].name
= ptr_file_name_table
;
3307 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3308 end
- ptr_file_name_table
) + 1;
3310 /* We are not interested in directory, time or size. */
3311 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3313 ptr_file_name_table
+= bytes_read
;
3314 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3316 ptr_file_name_table
+= bytes_read
;
3317 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3318 ptr_file_name_table
+= bytes_read
;
3323 /* Print the Compilation Unit's name and a header. */
3324 if (directory_table
== NULL
)
3326 printf (_("CU: %s:\n"), file_table
[0].name
);
3327 printf (_("File name Line number Starting address\n"));
3331 unsigned int ix
= file_table
[0].directory_index
;
3332 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3334 if (do_wide
|| strlen (directory
) < 76)
3335 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3337 printf ("%s:\n", file_table
[0].name
);
3339 printf (_("File name Line number Starting address\n"));
3343 /* Skip the NUL at the end of the table. */
3346 saved_linfo
= linfo
;
3349 /* This loop iterates through the Dwarf Line Number Program. */
3350 while (data
< end_of_sequence
)
3352 unsigned char op_code
;
3354 unsigned long int uladv
;
3355 unsigned int bytes_read
;
3356 int is_special_opcode
= 0;
3360 if (op_code
>= linfo
.li_opcode_base
)
3362 op_code
-= linfo
.li_opcode_base
;
3363 uladv
= (op_code
/ linfo
.li_line_range
);
3364 if (linfo
.li_max_ops_per_insn
== 1)
3366 uladv
*= linfo
.li_min_insn_length
;
3367 state_machine_regs
.address
+= uladv
;
3371 state_machine_regs
.address
3372 += ((state_machine_regs
.op_index
+ uladv
)
3373 / linfo
.li_max_ops_per_insn
)
3374 * linfo
.li_min_insn_length
;
3375 state_machine_regs
.op_index
3376 = (state_machine_regs
.op_index
+ uladv
)
3377 % linfo
.li_max_ops_per_insn
;
3380 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3381 state_machine_regs
.line
+= adv
;
3382 is_special_opcode
= 1;
3384 else switch (op_code
)
3386 case DW_LNS_extended_op
:
3388 unsigned int ext_op_code_len
;
3389 unsigned char ext_op_code
;
3390 unsigned char *op_code_data
= data
;
3392 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3394 op_code_data
+= bytes_read
;
3396 if (ext_op_code_len
== 0)
3398 warn (_("Badly formed extended line op encountered!\n"));
3401 ext_op_code_len
+= bytes_read
;
3402 ext_op_code
= *op_code_data
++;
3404 switch (ext_op_code
)
3406 case DW_LNE_end_sequence
:
3407 reset_state_machine (linfo
.li_default_is_stmt
);
3409 case DW_LNE_set_address
:
3410 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3412 ext_op_code_len
- bytes_read
- 1,
3414 state_machine_regs
.op_index
= 0;
3416 case DW_LNE_define_file
:
3418 file_table
= (File_Entry
*) xrealloc
3419 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3421 ++state_machine_regs
.last_file_entry
;
3422 /* Source file name. */
3423 file_table
[n_files
].name
= op_code_data
;
3424 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3425 /* Directory index. */
3426 file_table
[n_files
].directory_index
=
3427 read_uleb128 (op_code_data
, & bytes_read
,
3429 op_code_data
+= bytes_read
;
3430 /* Last modification time. */
3431 file_table
[n_files
].modification_date
=
3432 read_uleb128 (op_code_data
, & bytes_read
,
3434 op_code_data
+= bytes_read
;
3436 file_table
[n_files
].length
=
3437 read_uleb128 (op_code_data
, & bytes_read
,
3443 case DW_LNE_set_discriminator
:
3444 case DW_LNE_HP_set_sequence
:
3445 /* Simply ignored. */
3449 printf (_("UNKNOWN (%u): length %d\n"),
3450 ext_op_code
, ext_op_code_len
- bytes_read
);
3453 data
+= ext_op_code_len
;
3459 case DW_LNS_advance_pc
:
3460 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3462 if (linfo
.li_max_ops_per_insn
== 1)
3464 uladv
*= linfo
.li_min_insn_length
;
3465 state_machine_regs
.address
+= uladv
;
3469 state_machine_regs
.address
3470 += ((state_machine_regs
.op_index
+ uladv
)
3471 / linfo
.li_max_ops_per_insn
)
3472 * linfo
.li_min_insn_length
;
3473 state_machine_regs
.op_index
3474 = (state_machine_regs
.op_index
+ uladv
)
3475 % linfo
.li_max_ops_per_insn
;
3479 case DW_LNS_advance_line
:
3480 adv
= read_sleb128 (data
, & bytes_read
, end
);
3482 state_machine_regs
.line
+= adv
;
3485 case DW_LNS_set_file
:
3486 adv
= read_uleb128 (data
, & bytes_read
, end
);
3488 state_machine_regs
.file
= adv
;
3490 if (file_table
== NULL
)
3491 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3492 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3493 /* If directory index is 0, that means current directory. */
3494 printf ("\n./%s:[++]\n",
3495 file_table
[state_machine_regs
.file
- 1].name
);
3496 else if (directory_table
== NULL
)
3497 printf (_("\n [Use directory table entry %d]\n"),
3498 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3500 /* The directory index starts counting at 1. */
3501 printf ("\n%s/%s:\n",
3502 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3503 file_table
[state_machine_regs
.file
- 1].name
);
3506 case DW_LNS_set_column
:
3507 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3509 state_machine_regs
.column
= uladv
;
3512 case DW_LNS_negate_stmt
:
3513 adv
= state_machine_regs
.is_stmt
;
3515 state_machine_regs
.is_stmt
= adv
;
3518 case DW_LNS_set_basic_block
:
3519 state_machine_regs
.basic_block
= 1;
3522 case DW_LNS_const_add_pc
:
3523 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3524 if (linfo
.li_max_ops_per_insn
== 1)
3526 uladv
*= linfo
.li_min_insn_length
;
3527 state_machine_regs
.address
+= uladv
;
3531 state_machine_regs
.address
3532 += ((state_machine_regs
.op_index
+ uladv
)
3533 / linfo
.li_max_ops_per_insn
)
3534 * linfo
.li_min_insn_length
;
3535 state_machine_regs
.op_index
3536 = (state_machine_regs
.op_index
+ uladv
)
3537 % linfo
.li_max_ops_per_insn
;
3541 case DW_LNS_fixed_advance_pc
:
3542 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3543 state_machine_regs
.address
+= uladv
;
3544 state_machine_regs
.op_index
= 0;
3547 case DW_LNS_set_prologue_end
:
3550 case DW_LNS_set_epilogue_begin
:
3553 case DW_LNS_set_isa
:
3554 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3556 printf (_(" Set ISA to %lu\n"), uladv
);
3560 printf (_(" Unknown opcode %d with operands: "), op_code
);
3562 if (standard_opcodes
!= NULL
)
3563 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3565 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3567 i
== 1 ? "" : ", ");
3574 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3575 to the DWARF address/line matrix. */
3576 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3577 || (op_code
== DW_LNS_copy
))
3579 const unsigned int MAX_FILENAME_LENGTH
= 35;
3581 char *newFileName
= NULL
;
3582 size_t fileNameLength
;
3585 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3587 fileName
= "<unknown>";
3589 fileNameLength
= strlen (fileName
);
3591 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3593 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3594 /* Truncate file name */
3595 strncpy (newFileName
,
3596 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3597 MAX_FILENAME_LENGTH
+ 1);
3601 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3602 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3605 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3607 if (linfo
.li_max_ops_per_insn
== 1)
3608 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3609 newFileName
, state_machine_regs
.line
,
3610 state_machine_regs
.address
);
3612 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3613 newFileName
, state_machine_regs
.line
,
3614 state_machine_regs
.address
,
3615 state_machine_regs
.op_index
);
3619 if (linfo
.li_max_ops_per_insn
== 1)
3620 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3621 newFileName
, state_machine_regs
.line
,
3622 state_machine_regs
.address
);
3624 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3625 newFileName
, state_machine_regs
.line
,
3626 state_machine_regs
.address
,
3627 state_machine_regs
.op_index
);
3630 if (op_code
== DW_LNE_end_sequence
)
3644 if (directory_table
)
3646 free (directory_table
);
3647 directory_table
= NULL
;
3658 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3660 unsigned char *data
= section
->start
;
3661 unsigned char *end
= data
+ section
->size
;
3663 int retValDecoded
= 1;
3665 if (do_debug_lines
== 0)
3666 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3668 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3669 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3671 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3672 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3674 if (!retValRaw
|| !retValDecoded
)
3681 find_debug_info_for_offset (unsigned long offset
)
3685 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3688 for (i
= 0; i
< num_debug_info_entries
; i
++)
3689 if (debug_information
[i
].cu_offset
== offset
)
3690 return debug_information
+ i
;
3696 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
3698 /* See gdb/gdb-index.h. */
3699 static const char * const kinds
[] =
3711 return _ (kinds
[kind
]);
3715 display_debug_pubnames_worker (struct dwarf_section
*section
,
3716 void *file ATTRIBUTE_UNUSED
,
3719 DWARF2_Internal_PubNames names
;
3720 unsigned char *start
= section
->start
;
3721 unsigned char *end
= start
+ section
->size
;
3723 /* It does not matter if this load fails,
3724 we test for that later on. */
3725 load_debug_info (file
);
3727 printf (_("Contents of the %s section:\n\n"), section
->name
);
3731 unsigned char *data
;
3734 unsigned int offset_size
, initial_length_size
;
3738 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3739 if (names
.pn_length
== 0xffffffff)
3741 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3743 initial_length_size
= 12;
3748 initial_length_size
= 4;
3751 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3752 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3754 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3755 && num_debug_info_entries
> 0
3756 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3757 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3758 (unsigned long) names
.pn_offset
, section
->name
);
3760 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3762 adr
= start
+ names
.pn_length
+ initial_length_size
;
3763 /* PR 17531: file: 7615b6b2. */
3764 if ((dwarf_signed_vma
) names
.pn_length
< 0
3765 /* PR 17531: file: a5dbeaa7. */
3768 warn (_("Negative length for public name: 0x%lx\n"), (long) names
.pn_length
);
3774 printf (_(" Length: %ld\n"),
3775 (long) names
.pn_length
);
3776 printf (_(" Version: %d\n"),
3778 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3779 (unsigned long) names
.pn_offset
);
3780 printf (_(" Size of area in .debug_info section: %ld\n"),
3781 (long) names
.pn_size
);
3783 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3785 static int warned
= 0;
3789 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3797 printf (_("\n Offset Kind Name\n"));
3799 printf (_("\n Offset\tName\n"));
3803 bfd_size_type maxprint
;
3805 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3809 data
+= offset_size
;
3812 maxprint
= (end
- data
) - 1;
3816 unsigned int kind_data
;
3817 gdb_index_symbol_kind kind
;
3818 const char *kind_name
;
3821 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
3824 /* GCC computes the kind as the upper byte in the CU index
3825 word, and then right shifts it by the CU index size.
3826 Left shift KIND to where the gdb-index.h accessor macros
3828 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
3829 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
3830 kind_name
= get_gdb_index_symbol_kind_name (kind
);
3831 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
3832 printf (" %-6lx %s,%-10s %.*s\n",
3833 (unsigned long) offset
, is_static
? _("s") : _("g"),
3834 kind_name
, (int) maxprint
, data
);
3837 printf (" %-6lx\t%.*s\n",
3838 (unsigned long) offset
, (int) maxprint
, data
);
3840 data
+= strnlen ((char *) data
, maxprint
) + 1;
3845 while (offset
!= 0);
3853 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
3855 return display_debug_pubnames_worker (section
, file
, 0);
3859 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
3861 return display_debug_pubnames_worker (section
, file
, 1);
3865 display_debug_macinfo (struct dwarf_section
*section
,
3866 void *file ATTRIBUTE_UNUSED
)
3868 unsigned char *start
= section
->start
;
3869 unsigned char *end
= start
+ section
->size
;
3870 unsigned char *curr
= start
;
3871 unsigned int bytes_read
;
3872 enum dwarf_macinfo_record_type op
;
3874 printf (_("Contents of the %s section:\n\n"), section
->name
);
3878 unsigned int lineno
;
3879 const unsigned char *string
;
3881 op
= (enum dwarf_macinfo_record_type
) *curr
;
3886 case DW_MACINFO_start_file
:
3888 unsigned int filenum
;
3890 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3892 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3895 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3900 case DW_MACINFO_end_file
:
3901 printf (_(" DW_MACINFO_end_file\n"));
3904 case DW_MACINFO_define
:
3905 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3908 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3909 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3913 case DW_MACINFO_undef
:
3914 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3917 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3918 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3922 case DW_MACINFO_vendor_ext
:
3924 unsigned int constant
;
3926 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3929 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3930 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3940 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3941 filename and dirname corresponding to file name table entry with index
3942 FILEIDX. Return NULL on failure. */
3944 static unsigned char *
3945 get_line_filename_and_dirname (dwarf_vma line_offset
,
3947 unsigned char **dir_name
)
3949 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3950 unsigned char *hdrptr
, *dirtable
, *file_name
;
3951 unsigned int offset_size
, initial_length_size
;
3952 unsigned int version
, opcode_base
, bytes_read
;
3953 dwarf_vma length
, diridx
;
3954 const unsigned char * end
;
3957 if (section
->start
== NULL
3958 || line_offset
>= section
->size
3962 hdrptr
= section
->start
+ line_offset
;
3963 end
= section
->start
+ section
->size
;
3965 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3966 if (length
== 0xffffffff)
3968 /* This section is 64-bit DWARF 3. */
3969 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3971 initial_length_size
= 12;
3976 initial_length_size
= 4;
3978 if (length
+ initial_length_size
> section
->size
)
3981 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3982 if (version
!= 2 && version
!= 3 && version
!= 4)
3984 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3986 hdrptr
++; /* Skip max_ops_per_insn. */
3987 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3989 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3990 if (opcode_base
== 0)
3993 hdrptr
+= opcode_base
- 1;
3995 /* Skip over dirname table. */
3996 while (*hdrptr
!= '\0')
3997 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
3998 hdrptr
++; /* Skip the NUL at the end of the table. */
3999 /* Now skip over preceding filename table entries. */
4000 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
4002 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4003 read_uleb128 (hdrptr
, &bytes_read
, end
);
4004 hdrptr
+= bytes_read
;
4005 read_uleb128 (hdrptr
, &bytes_read
, end
);
4006 hdrptr
+= bytes_read
;
4007 read_uleb128 (hdrptr
, &bytes_read
, end
);
4008 hdrptr
+= bytes_read
;
4010 if (hdrptr
== end
|| *hdrptr
== '\0')
4013 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4014 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
4017 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
4018 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
4019 if (*dirtable
== '\0')
4021 *dir_name
= dirtable
;
4026 display_debug_macro (struct dwarf_section
*section
,
4029 unsigned char *start
= section
->start
;
4030 unsigned char *end
= start
+ section
->size
;
4031 unsigned char *curr
= start
;
4032 unsigned char *extended_op_buf
[256];
4033 unsigned int bytes_read
;
4035 load_debug_section (str
, file
);
4036 load_debug_section (line
, file
);
4038 printf (_("Contents of the %s section:\n\n"), section
->name
);
4042 unsigned int lineno
, version
, flags
;
4043 unsigned int offset_size
= 4;
4044 const unsigned char *string
;
4045 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
4046 unsigned char **extended_ops
= NULL
;
4048 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
4051 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4056 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
4059 printf (_(" Offset: 0x%lx\n"),
4060 (unsigned long) sec_offset
);
4061 printf (_(" Version: %d\n"), version
);
4062 printf (_(" Offset size: %d\n"), offset_size
);
4065 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
4066 printf (_(" Offset into .debug_line: 0x%lx\n"),
4067 (unsigned long) line_offset
);
4071 unsigned int i
, count
, op
;
4074 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
4076 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
4077 extended_ops
= extended_op_buf
;
4080 printf (_(" Extension opcode arguments:\n"));
4081 for (i
= 0; i
< count
; i
++)
4083 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4084 extended_ops
[op
] = curr
;
4085 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
4088 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
4091 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
4092 for (n
= 0; n
< nargs
; n
++)
4096 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
4097 printf ("%s%s", get_FORM_name (form
),
4098 n
== nargs
- 1 ? "\n" : ", ");
4108 case DW_FORM_block1
:
4109 case DW_FORM_block2
:
4110 case DW_FORM_block4
:
4112 case DW_FORM_string
:
4114 case DW_FORM_sec_offset
:
4117 error (_("Invalid extension opcode form %s\n"),
4118 get_FORM_name (form
));
4134 error (_(".debug_macro section not zero terminated\n"));
4138 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4144 case DW_MACRO_GNU_start_file
:
4146 unsigned int filenum
;
4147 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4149 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4151 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4154 if ((flags
& 2) == 0)
4155 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4158 = get_line_filename_and_dirname (line_offset
, filenum
,
4160 if (file_name
== NULL
)
4161 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4164 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4166 dir_name
!= NULL
? (const char *) dir_name
: "",
4167 dir_name
!= NULL
? "/" : "", file_name
);
4171 case DW_MACRO_GNU_end_file
:
4172 printf (_(" DW_MACRO_GNU_end_file\n"));
4175 case DW_MACRO_GNU_define
:
4176 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4179 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4180 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4184 case DW_MACRO_GNU_undef
:
4185 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4188 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4189 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4193 case DW_MACRO_GNU_define_indirect
:
4194 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4196 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4197 string
= fetch_indirect_string (offset
);
4198 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4202 case DW_MACRO_GNU_undef_indirect
:
4203 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4205 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4206 string
= fetch_indirect_string (offset
);
4207 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4211 case DW_MACRO_GNU_transparent_include
:
4212 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4213 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4214 (unsigned long) offset
);
4217 case DW_MACRO_GNU_define_indirect_alt
:
4218 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4220 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4221 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4222 lineno
, (unsigned long) offset
);
4225 case DW_MACRO_GNU_undef_indirect_alt
:
4226 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4228 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4229 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4230 lineno
, (unsigned long) offset
);
4233 case DW_MACRO_GNU_transparent_include_alt
:
4234 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4235 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4236 (unsigned long) offset
);
4240 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
4242 error (_(" Unknown macro opcode %02x seen\n"), op
);
4247 /* Skip over unhandled opcodes. */
4249 unsigned char *desc
= extended_ops
[op
];
4250 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
4254 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
4257 printf (_(" DW_MACRO_GNU_%02x -"), op
);
4258 for (n
= 0; n
< nargs
; n
++)
4262 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
4264 = read_and_display_attr_value (0, val
,
4265 curr
, end
, 0, 0, offset_size
,
4266 version
, NULL
, 0, NULL
,
4284 display_debug_abbrev (struct dwarf_section
*section
,
4285 void *file ATTRIBUTE_UNUSED
)
4287 abbrev_entry
*entry
;
4288 unsigned char *start
= section
->start
;
4289 unsigned char *end
= start
+ section
->size
;
4291 printf (_("Contents of the %s section:\n\n"), section
->name
);
4295 unsigned char *last
;
4300 start
= process_abbrev_section (start
, end
);
4302 if (first_abbrev
== NULL
)
4305 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4307 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4311 printf (" %ld %s [%s]\n",
4313 get_TAG_name (entry
->tag
),
4314 entry
->children
? _("has children") : _("no children"));
4316 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4317 printf (" %-18s %s\n",
4318 get_AT_name (attr
->attribute
),
4319 get_FORM_name (attr
->form
));
4329 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4332 display_loc_list (struct dwarf_section
*section
,
4333 unsigned char **start_ptr
,
4334 unsigned int debug_info_entry
,
4335 unsigned long offset
,
4336 unsigned long base_address
,
4339 unsigned char *start
= *start_ptr
;
4340 unsigned char *section_end
= section
->start
+ section
->size
;
4341 unsigned long cu_offset
;
4342 unsigned int pointer_size
;
4343 unsigned int offset_size
;
4348 unsigned short length
;
4349 int need_frame_base
;
4351 if (debug_info_entry
>= num_debug_info_entries
)
4353 warn (_("No debug information available for loc lists of entry: %u\n"),
4358 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4359 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4360 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4361 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4363 if (pointer_size
< 2 || pointer_size
> 8)
4365 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4366 pointer_size
, debug_info_entry
);
4372 unsigned long off
= offset
+ (start
- *start_ptr
);
4374 if (start
+ 2 * pointer_size
> section_end
)
4376 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4381 printf (" %8.8lx ", off
);
4383 /* Note: we use sign extension here in order to be sure that we can detect
4384 the -1 escape value. Sign extension into the top 32 bits of a 32-bit
4385 address will not affect the values that we display since we always show
4386 hex values, and always the bottom 32-bits. */
4387 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4388 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4390 if (begin
== 0 && end
== 0)
4392 /* PR 18374: In a object file we can have a location list that
4393 starts with a begin and end of 0 because there are relocations
4394 that need to be applied to the addresses. Actually applying
4395 the relocations now does not help as they will probably resolve
4396 to 0, since the object file has not been fully linked. Real
4397 end of list markers will not have any relocations against them. */
4398 if (! reloc_at (section
, off
)
4399 && ! reloc_at (section
, off
+ pointer_size
))
4401 printf (_("<End of list>\n"));
4406 /* Check base address specifiers. */
4407 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
4410 print_dwarf_vma (begin
, pointer_size
);
4411 print_dwarf_vma (end
, pointer_size
);
4412 printf (_("(base address)\n"));
4416 if (start
+ 2 > section_end
)
4418 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4423 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4425 if (start
+ length
> section_end
)
4427 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4432 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4433 print_dwarf_vma (end
+ base_address
, pointer_size
);
4436 need_frame_base
= decode_location_expression (start
,
4441 cu_offset
, section
);
4444 if (need_frame_base
&& !has_frame_base
)
4445 printf (_(" [without DW_AT_frame_base]"));
4448 fputs (_(" (start == end)"), stdout
);
4449 else if (begin
> end
)
4450 fputs (_(" (start > end)"), stdout
);
4460 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4461 right-adjusted in a field of length LEN, and followed by a space. */
4464 print_addr_index (unsigned int idx
, unsigned int len
)
4466 static char buf
[15];
4467 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4468 printf ("%*s ", len
, buf
);
4471 /* Display a location list from a .dwo section. It uses address indexes rather
4472 than embedded addresses. This code closely follows display_loc_list, but the
4473 two are sufficiently different that combining things is very ugly. */
4476 display_loc_list_dwo (struct dwarf_section
*section
,
4477 unsigned char **start_ptr
,
4478 unsigned int debug_info_entry
,
4479 unsigned long offset
,
4482 unsigned char *start
= *start_ptr
;
4483 unsigned char *section_end
= section
->start
+ section
->size
;
4484 unsigned long cu_offset
;
4485 unsigned int pointer_size
;
4486 unsigned int offset_size
;
4489 unsigned short length
;
4490 int need_frame_base
;
4492 unsigned int bytes_read
;
4494 if (debug_info_entry
>= num_debug_info_entries
)
4496 warn (_("No debug information for loc lists of entry: %u\n"),
4501 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4502 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4503 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4504 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4506 if (pointer_size
< 2 || pointer_size
> 8)
4508 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4509 pointer_size
, debug_info_entry
);
4515 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4517 if (start
>= section_end
)
4519 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4524 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4527 case 0: /* A terminating entry. */
4529 printf (_("<End of list>\n"));
4531 case 1: /* A base-address entry. */
4532 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4533 start
+= bytes_read
;
4534 print_addr_index (idx
, 8);
4536 printf (_("(base address selection entry)\n"));
4538 case 2: /* A start/end entry. */
4539 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4540 start
+= bytes_read
;
4541 print_addr_index (idx
, 8);
4542 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4543 start
+= bytes_read
;
4544 print_addr_index (idx
, 8);
4546 case 3: /* A start/length entry. */
4547 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4548 start
+= bytes_read
;
4549 print_addr_index (idx
, 8);
4550 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4551 printf ("%08x ", idx
);
4553 case 4: /* An offset pair entry. */
4554 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4555 printf ("%08x ", idx
);
4556 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4557 printf ("%08x ", idx
);
4560 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4565 if (start
+ 2 > section_end
)
4567 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4572 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4573 if (start
+ length
> section_end
)
4575 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4581 need_frame_base
= decode_location_expression (start
,
4586 cu_offset
, section
);
4589 if (need_frame_base
&& !has_frame_base
)
4590 printf (_(" [without DW_AT_frame_base]"));
4600 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4602 static dwarf_vma
*loc_offsets
;
4605 loc_offsets_compar (const void *ap
, const void *bp
)
4607 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4608 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4610 return (a
> b
) - (b
> a
);
4614 display_debug_loc (struct dwarf_section
*section
, void *file
)
4616 unsigned char *start
= section
->start
;
4617 unsigned long bytes
;
4618 unsigned char *section_begin
= start
;
4619 unsigned int num_loc_list
= 0;
4620 unsigned long last_offset
= 0;
4621 unsigned int first
= 0;
4624 int seen_first_offset
= 0;
4625 int locs_sorted
= 1;
4626 unsigned char *next
;
4627 unsigned int *array
= NULL
;
4628 const char *suffix
= strrchr (section
->name
, '.');
4631 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4634 bytes
= section
->size
;
4638 printf (_("\nThe %s section is empty.\n"), section
->name
);
4642 if (load_debug_info (file
) == 0)
4644 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4649 /* Check the order of location list in .debug_info section. If
4650 offsets of location lists are in the ascending order, we can
4651 use `debug_information' directly. */
4652 for (i
= 0; i
< num_debug_info_entries
; i
++)
4656 num
= debug_information
[i
].num_loc_offsets
;
4657 if (num
> num_loc_list
)
4660 /* Check if we can use `debug_information' directly. */
4661 if (locs_sorted
&& num
!= 0)
4663 if (!seen_first_offset
)
4665 /* This is the first location list. */
4666 last_offset
= debug_information
[i
].loc_offsets
[0];
4668 seen_first_offset
= 1;
4674 for (; j
< num
; j
++)
4677 debug_information
[i
].loc_offsets
[j
])
4682 last_offset
= debug_information
[i
].loc_offsets
[j
];
4687 if (!seen_first_offset
)
4688 error (_("No location lists in .debug_info section!\n"));
4690 if (debug_information
[first
].num_loc_offsets
> 0
4691 && debug_information
[first
].loc_offsets
[0] != 0)
4692 warn (_("Location lists in %s section start at 0x%s\n"),
4694 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4697 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4698 printf (_("Contents of the %s section:\n\n"), section
->name
);
4699 if (reloc_at (section
, 0))
4700 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
4701 printf (_(" Offset Begin End Expression\n"));
4703 seen_first_offset
= 0;
4704 for (i
= first
; i
< num_debug_info_entries
; i
++)
4706 unsigned long offset
;
4707 unsigned long base_address
;
4713 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4715 loc_offsets
= debug_information
[i
].loc_offsets
;
4716 qsort (array
, debug_information
[i
].num_loc_offsets
,
4717 sizeof (*array
), loc_offsets_compar
);
4720 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4722 j
= locs_sorted
? k
: array
[k
];
4724 && debug_information
[i
].loc_offsets
[locs_sorted
4725 ? k
- 1 : array
[k
- 1]]
4726 == debug_information
[i
].loc_offsets
[j
])
4728 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4729 offset
= debug_information
[i
].loc_offsets
[j
];
4730 next
= section_begin
+ offset
;
4731 base_address
= debug_information
[i
].base_address
;
4733 if (!seen_first_offset
)
4734 seen_first_offset
= 1;
4738 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4739 (unsigned long) (start
- section_begin
),
4740 (unsigned long) offset
);
4741 else if (start
> next
)
4742 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4743 (unsigned long) (start
- section_begin
),
4744 (unsigned long) offset
);
4748 if (offset
>= bytes
)
4750 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4756 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4758 display_loc_list (section
, &start
, i
, offset
, base_address
,
4763 if (start
< section
->start
+ section
->size
)
4764 warn (_("There are %ld unused bytes at the end of section %s\n"),
4765 (long) (section
->start
+ section
->size
- start
), section
->name
);
4772 display_debug_str (struct dwarf_section
*section
,
4773 void *file ATTRIBUTE_UNUSED
)
4775 unsigned char *start
= section
->start
;
4776 unsigned long bytes
= section
->size
;
4777 dwarf_vma addr
= section
->address
;
4781 printf (_("\nThe %s section is empty.\n"), section
->name
);
4785 printf (_("Contents of the %s section:\n\n"), section
->name
);
4793 lbytes
= (bytes
> 16 ? 16 : bytes
);
4795 printf (" 0x%8.8lx ", (unsigned long) addr
);
4797 for (j
= 0; j
< 16; j
++)
4800 printf ("%2.2x", start
[j
]);
4808 for (j
= 0; j
< lbytes
; j
++)
4811 if (k
>= ' ' && k
< 0x80)
4830 display_debug_info (struct dwarf_section
*section
, void *file
)
4832 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4836 display_debug_types (struct dwarf_section
*section
, void *file
)
4838 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4842 display_trace_info (struct dwarf_section
*section
, void *file
)
4844 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4848 display_debug_aranges (struct dwarf_section
*section
,
4849 void *file ATTRIBUTE_UNUSED
)
4851 unsigned char *start
= section
->start
;
4852 unsigned char *end
= start
+ section
->size
;
4854 printf (_("Contents of the %s section:\n\n"), section
->name
);
4856 /* It does not matter if this load fails,
4857 we test for that later on. */
4858 load_debug_info (file
);
4862 unsigned char *hdrptr
;
4863 DWARF2_Internal_ARange arange
;
4864 unsigned char *addr_ranges
;
4867 unsigned char address_size
;
4869 unsigned int offset_size
;
4870 unsigned int initial_length_size
;
4874 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4875 if (arange
.ar_length
== 0xffffffff)
4877 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4879 initial_length_size
= 12;
4884 initial_length_size
= 4;
4887 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4888 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4890 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4891 && num_debug_info_entries
> 0
4892 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4893 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4894 (unsigned long) arange
.ar_info_offset
, section
->name
);
4896 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4897 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4899 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4901 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4905 printf (_(" Length: %ld\n"),
4906 (long) arange
.ar_length
);
4907 printf (_(" Version: %d\n"), arange
.ar_version
);
4908 printf (_(" Offset into .debug_info: 0x%lx\n"),
4909 (unsigned long) arange
.ar_info_offset
);
4910 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4911 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4913 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4915 /* PR 17512: file: 001-108546-0.001:0.1. */
4916 if (address_size
== 0 || address_size
> 8)
4918 error (_("Invalid address size in %s section!\n"),
4923 /* The DWARF spec does not require that the address size be a power
4924 of two, but we do. This will have to change if we ever encounter
4925 an uneven architecture. */
4926 if ((address_size
& (address_size
- 1)) != 0)
4928 warn (_("Pointer size + Segment size is not a power of two.\n"));
4932 if (address_size
> 4)
4933 printf (_("\n Address Length\n"));
4935 printf (_("\n Address Length\n"));
4937 addr_ranges
= hdrptr
;
4939 /* Must pad to an alignment boundary that is twice the address size. */
4940 excess
= (hdrptr
- start
) % (2 * address_size
);
4942 addr_ranges
+= (2 * address_size
) - excess
;
4944 hdrptr
= start
+ arange
.ar_length
+ initial_length_size
;
4945 if (hdrptr
< start
|| hdrptr
> end
)
4947 error (_("Excessive header length: %lx\n"), (long) arange
.ar_length
);
4952 while (addr_ranges
+ 2 * address_size
<= start
)
4954 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4955 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4958 print_dwarf_vma (address
, address_size
);
4959 print_dwarf_vma (length
, address_size
);
4969 /* Comparison function for qsort. */
4971 comp_addr_base (const void * v0
, const void * v1
)
4973 debug_info
* info0
= (debug_info
*) v0
;
4974 debug_info
* info1
= (debug_info
*) v1
;
4975 return info0
->addr_base
- info1
->addr_base
;
4978 /* Display the debug_addr section. */
4980 display_debug_addr (struct dwarf_section
*section
,
4983 debug_info
**debug_addr_info
;
4984 unsigned char *entry
;
4989 if (section
->size
== 0)
4991 printf (_("\nThe %s section is empty.\n"), section
->name
);
4995 if (load_debug_info (file
) == 0)
4997 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5002 printf (_("Contents of the %s section:\n\n"), section
->name
);
5004 /* PR 17531: file: cf38d01b.
5005 We use xcalloc because a corrupt file may not have initialised all of the
5006 fields in the debug_info structure, which means that the sort below might
5007 try to move uninitialised data. */
5008 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
5009 sizeof (debug_info
*));
5012 for (i
= 0; i
< num_debug_info_entries
; i
++)
5013 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
5015 /* PR 17531: file: cf38d01b. */
5016 if (debug_information
[i
].addr_base
>= section
->size
)
5017 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
5018 (unsigned long) debug_information
[i
].addr_base
, i
);
5020 debug_addr_info
[count
++] = debug_information
+ i
;
5023 /* Add a sentinel to make iteration convenient. */
5024 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
5025 debug_addr_info
[count
]->addr_base
= section
->size
;
5026 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
5028 for (i
= 0; i
< count
; i
++)
5031 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
5033 printf (_(" For compilation unit at offset 0x%s:\n"),
5034 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
5036 printf (_("\tIndex\tAddress\n"));
5037 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
5038 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
5042 dwarf_vma base
= byte_get (entry
, address_size
);
5043 printf (_("\t%d:\t"), idx
);
5044 print_dwarf_vma (base
, address_size
);
5046 entry
+= address_size
;
5052 free (debug_addr_info
);
5056 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5058 display_debug_str_offsets (struct dwarf_section
*section
,
5059 void *file ATTRIBUTE_UNUSED
)
5061 if (section
->size
== 0)
5063 printf (_("\nThe %s section is empty.\n"), section
->name
);
5066 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5067 what the offset size is for this section. */
5071 /* Each debug_information[x].range_lists[y] gets this representation for
5072 sorting purposes. */
5076 /* The debug_information[x].range_lists[y] value. */
5077 unsigned long ranges_offset
;
5079 /* Original debug_information to find parameters of the data. */
5080 debug_info
*debug_info_p
;
5083 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5086 range_entry_compar (const void *ap
, const void *bp
)
5088 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
5089 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
5090 const unsigned long a
= a_re
->ranges_offset
;
5091 const unsigned long b
= b_re
->ranges_offset
;
5093 return (a
> b
) - (b
> a
);
5097 display_debug_ranges (struct dwarf_section
*section
,
5098 void *file ATTRIBUTE_UNUSED
)
5100 unsigned char *start
= section
->start
;
5101 unsigned char *last_start
= start
;
5102 unsigned long bytes
= section
->size
;
5103 unsigned char *section_begin
= start
;
5104 unsigned char *finish
= start
+ bytes
;
5105 unsigned int num_range_list
, i
;
5106 struct range_entry
*range_entries
, *range_entry_fill
;
5110 printf (_("\nThe %s section is empty.\n"), section
->name
);
5114 if (load_debug_info (file
) == 0)
5116 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5122 for (i
= 0; i
< num_debug_info_entries
; i
++)
5123 num_range_list
+= debug_information
[i
].num_range_lists
;
5125 if (num_range_list
== 0)
5127 /* This can happen when the file was compiled with -gsplit-debug
5128 which removes references to range lists from the primary .o file. */
5129 printf (_("No range lists in .debug_info section.\n"));
5133 range_entries
= (struct range_entry
*)
5134 xmalloc (sizeof (*range_entries
) * num_range_list
);
5135 range_entry_fill
= range_entries
;
5137 for (i
= 0; i
< num_debug_info_entries
; i
++)
5139 debug_info
*debug_info_p
= &debug_information
[i
];
5142 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
5144 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
5145 range_entry_fill
->debug_info_p
= debug_info_p
;
5150 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
5151 range_entry_compar
);
5153 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
5154 warn (_("Range lists in %s section start at 0x%lx\n"),
5155 section
->name
, range_entries
[0].ranges_offset
);
5157 printf (_("Contents of the %s section:\n\n"), section
->name
);
5158 printf (_(" Offset Begin End\n"));
5160 for (i
= 0; i
< num_range_list
; i
++)
5162 struct range_entry
*range_entry
= &range_entries
[i
];
5163 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
5164 unsigned int pointer_size
;
5165 unsigned long offset
;
5166 unsigned char *next
;
5167 unsigned long base_address
;
5169 pointer_size
= debug_info_p
->pointer_size
;
5170 offset
= range_entry
->ranges_offset
;
5171 next
= section_begin
+ offset
;
5172 base_address
= debug_info_p
->base_address
;
5174 /* PR 17512: file: 001-101485-0.001:0.1. */
5175 if (pointer_size
< 2 || pointer_size
> 8)
5177 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5178 pointer_size
, offset
);
5182 if (dwarf_check
!= 0 && i
> 0)
5185 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5186 (unsigned long) (start
- section_begin
),
5187 (unsigned long) (next
- section_begin
), section
->name
);
5188 else if (start
> next
)
5190 if (next
== last_start
)
5192 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5193 (unsigned long) (start
- section_begin
),
5194 (unsigned long) (next
- section_begin
), section
->name
);
5200 while (start
< finish
)
5205 /* Note: we use sign extension here in order to be sure that
5206 we can detect the -1 escape value. Sign extension into the
5207 top 32 bits of a 32-bit address will not affect the values
5208 that we display since we always show hex values, and always
5209 the bottom 32-bits. */
5210 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
5211 if (start
>= finish
)
5213 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
5215 printf (" %8.8lx ", offset
);
5217 if (begin
== 0 && end
== 0)
5219 printf (_("<End of list>\n"));
5223 /* Check base address specifiers. */
5224 if (begin
== (dwarf_vma
) -1 && end
!= (dwarf_vma
) -1)
5227 print_dwarf_vma (begin
, pointer_size
);
5228 print_dwarf_vma (end
, pointer_size
);
5229 printf ("(base address)\n");
5233 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5234 print_dwarf_vma (end
+ base_address
, pointer_size
);
5237 fputs (_("(start == end)"), stdout
);
5238 else if (begin
> end
)
5239 fputs (_("(start > end)"), stdout
);
5246 free (range_entries
);
5251 typedef struct Frame_Chunk
5253 struct Frame_Chunk
*next
;
5254 unsigned char *chunk_start
;
5256 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5257 short int *col_type
;
5260 unsigned int code_factor
;
5265 dwarf_vma cfa_offset
;
5267 unsigned char fde_encoding
;
5268 unsigned char cfa_exp
;
5269 unsigned char ptr_size
;
5270 unsigned char segment_size
;
5274 static const char *const *dwarf_regnames
;
5275 static unsigned int dwarf_regnames_count
;
5277 /* A marker for a col_type that means this column was never referenced
5278 in the frame info. */
5279 #define DW_CFA_unreferenced (-1)
5281 /* Return 0 if no more space is needed, 1 if more space is needed,
5282 -1 for invalid reg. */
5285 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
5287 unsigned int prev
= fc
->ncols
;
5289 if (reg
< (unsigned int) fc
->ncols
)
5292 if (dwarf_regnames_count
5293 && reg
> dwarf_regnames_count
)
5296 fc
->ncols
= reg
+ 1;
5297 /* PR 17512: file: 10450-2643-0.004.
5298 If reg == -1 then this can happen... */
5302 /* PR 17512: file: 2844a11d. */
5303 if (fc
->ncols
> 1024)
5305 error (_("Unfeasibly large register number: %u\n"), reg
);
5307 /* FIXME: 1024 is an arbitrary limit. Increase it if
5308 we ever encounter a valid binary that exceeds it. */
5312 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
5313 sizeof (short int));
5314 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
5315 /* PR 17512: file:002-10025-0.005. */
5316 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
5318 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5324 while (prev
< fc
->ncols
)
5326 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
5327 fc
->col_offset
[prev
] = 0;
5333 static const char *const dwarf_regnames_i386
[] =
5335 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5336 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5337 "eip", "eflags", NULL
, /* 8 - 10 */
5338 "st0", "st1", "st2", "st3", /* 11 - 14 */
5339 "st4", "st5", "st6", "st7", /* 15 - 18 */
5340 NULL
, NULL
, /* 19 - 20 */
5341 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5342 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5343 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5344 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5345 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5346 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5347 "tr", "ldtr", /* 48 - 49 */
5348 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5349 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5350 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5351 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5352 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5353 NULL
, NULL
, NULL
, /* 90 - 92 */
5354 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5357 static const char *const dwarf_regnames_iamcu
[] =
5359 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5360 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5361 "eip", "eflags", NULL
, /* 8 - 10 */
5362 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
5363 NULL
, NULL
, /* 19 - 20 */
5364 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
5365 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
5366 NULL
, NULL
, NULL
, /* 37 - 39 */
5367 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5368 "tr", "ldtr", /* 48 - 49 */
5369 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5370 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5371 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5372 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5373 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5374 NULL
, NULL
, NULL
, /* 90 - 92 */
5375 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
5379 init_dwarf_regnames_i386 (void)
5381 dwarf_regnames
= dwarf_regnames_i386
;
5382 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5386 init_dwarf_regnames_iamcu (void)
5388 dwarf_regnames
= dwarf_regnames_iamcu
;
5389 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
5392 static const char *const dwarf_regnames_x86_64
[] =
5394 "rax", "rdx", "rcx", "rbx",
5395 "rsi", "rdi", "rbp", "rsp",
5396 "r8", "r9", "r10", "r11",
5397 "r12", "r13", "r14", "r15",
5399 "xmm0", "xmm1", "xmm2", "xmm3",
5400 "xmm4", "xmm5", "xmm6", "xmm7",
5401 "xmm8", "xmm9", "xmm10", "xmm11",
5402 "xmm12", "xmm13", "xmm14", "xmm15",
5403 "st0", "st1", "st2", "st3",
5404 "st4", "st5", "st6", "st7",
5405 "mm0", "mm1", "mm2", "mm3",
5406 "mm4", "mm5", "mm6", "mm7",
5408 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5409 "fs.base", "gs.base", NULL
, NULL
,
5411 "mxcsr", "fcw", "fsw",
5412 "xmm16", "xmm17", "xmm18", "xmm19",
5413 "xmm20", "xmm21", "xmm22", "xmm23",
5414 "xmm24", "xmm25", "xmm26", "xmm27",
5415 "xmm28", "xmm29", "xmm30", "xmm31",
5416 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5417 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5418 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5419 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5420 NULL
, NULL
, NULL
, /* 115 - 117 */
5421 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5425 init_dwarf_regnames_x86_64 (void)
5427 dwarf_regnames
= dwarf_regnames_x86_64
;
5428 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5431 static const char *const dwarf_regnames_aarch64
[] =
5433 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5434 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5435 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5436 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5437 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5438 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5439 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5440 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5441 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5442 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5443 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5444 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5448 init_dwarf_regnames_aarch64 (void)
5450 dwarf_regnames
= dwarf_regnames_aarch64
;
5451 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
5455 init_dwarf_regnames (unsigned int e_machine
)
5460 init_dwarf_regnames_i386 ();
5464 init_dwarf_regnames_iamcu ();
5470 init_dwarf_regnames_x86_64 ();
5474 init_dwarf_regnames_aarch64 ();
5483 regname (unsigned int regno
, int row
)
5485 static char reg
[64];
5487 && regno
< dwarf_regnames_count
5488 && dwarf_regnames
[regno
] != NULL
)
5491 return dwarf_regnames
[regno
];
5492 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5493 dwarf_regnames
[regno
]);
5496 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5501 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
5506 if (*max_regs
< fc
->ncols
)
5507 *max_regs
= fc
->ncols
;
5509 if (*need_col_headers
)
5511 static const char *sloc
= " LOC";
5513 *need_col_headers
= 0;
5515 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5517 for (r
= 0; r
< *max_regs
; r
++)
5518 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5523 printf ("%-5s ", regname (r
, 1));
5529 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5531 strcpy (tmp
, "exp");
5533 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
5534 printf ("%-8s ", tmp
);
5536 for (r
= 0; r
< fc
->ncols
; r
++)
5538 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5540 switch (fc
->col_type
[r
])
5542 case DW_CFA_undefined
:
5545 case DW_CFA_same_value
:
5549 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5551 case DW_CFA_val_offset
:
5552 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5554 case DW_CFA_register
:
5555 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5557 case DW_CFA_expression
:
5558 strcpy (tmp
, "exp");
5560 case DW_CFA_val_expression
:
5561 strcpy (tmp
, "vexp");
5564 strcpy (tmp
, "n/a");
5567 printf ("%-5s ", tmp
);
5573 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5574 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5575 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5577 static unsigned char *
5578 read_cie (unsigned char *start
, unsigned char *end
,
5579 Frame_Chunk
**p_cie
, int *p_version
,
5580 unsigned long *p_aug_len
, unsigned char **p_aug
)
5584 unsigned int length_return
;
5585 unsigned char *augmentation_data
= NULL
;
5586 unsigned long augmentation_data_len
= 0;
5589 /* PR 17512: file: 001-228113-0.004. */
5593 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5594 memset (fc
, 0, sizeof (Frame_Chunk
));
5596 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5597 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5601 fc
->augmentation
= (char *) start
;
5602 /* PR 17512: file: 001-228113-0.004.
5603 Skip past augmentation name, but avoid running off the end of the data. */
5605 if (* start
++ == '\0')
5609 warn (_("No terminator for augmentation name\n"));
5613 if (strcmp (fc
->augmentation
, "eh") == 0)
5614 start
+= eh_addr_size
;
5618 GET (fc
->ptr_size
, 1);
5619 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
5621 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
5625 GET (fc
->segment_size
, 1);
5626 /* PR 17512: file: e99d2804. */
5627 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
5629 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
5633 eh_addr_size
= fc
->ptr_size
;
5637 fc
->ptr_size
= eh_addr_size
;
5638 fc
->segment_size
= 0;
5640 fc
->code_factor
= LEB ();
5641 fc
->data_factor
= SLEB ();
5651 if (fc
->augmentation
[0] == 'z')
5653 augmentation_data_len
= LEB ();
5654 augmentation_data
= start
;
5655 start
+= augmentation_data_len
;
5656 /* PR 17512: file: 11042-2589-0.004. */
5659 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len
);
5664 if (augmentation_data_len
)
5668 unsigned char *qend
;
5670 p
= (unsigned char *) fc
->augmentation
+ 1;
5671 q
= augmentation_data
;
5672 qend
= q
+ augmentation_data_len
;
5674 /* PR 17531: file: 015adfaa. */
5677 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len
);
5678 augmentation_data_len
= 0;
5681 while (p
< end
&& q
< augmentation_data
+ augmentation_data_len
)
5686 q
+= 1 + size_of_encoded_value (*q
);
5688 fc
->fde_encoding
= *q
++;
5695 /* Note - it is OK if this loop terminates with q < qend.
5696 Padding may have been inserted to align the end of the CIE. */
5701 *p_version
= version
;
5704 *p_aug_len
= augmentation_data_len
;
5705 *p_aug
= augmentation_data
;
5711 display_debug_frames (struct dwarf_section
*section
,
5712 void *file ATTRIBUTE_UNUSED
)
5714 unsigned char *start
= section
->start
;
5715 unsigned char *end
= start
+ section
->size
;
5716 unsigned char *section_start
= start
;
5717 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
5718 Frame_Chunk
*remembered_state
= 0;
5720 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5721 unsigned int length_return
;
5722 unsigned int max_regs
= 0;
5723 const char *bad_reg
= _("bad register: ");
5724 unsigned int saved_eh_addr_size
= eh_addr_size
;
5726 printf (_("Contents of the %s section:\n"), section
->name
);
5730 unsigned char *saved_start
;
5731 unsigned char *block_end
;
5736 int need_col_headers
= 1;
5737 unsigned char *augmentation_data
= NULL
;
5738 unsigned long augmentation_data_len
= 0;
5739 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5740 unsigned int offset_size
;
5741 unsigned int initial_length_size
;
5743 saved_start
= start
;
5745 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5749 printf ("\n%08lx ZERO terminator\n\n",
5750 (unsigned long)(saved_start
- section_start
));
5751 /* Skip any zero terminators that directly follow.
5752 A corrupt section size could have loaded a whole
5753 slew of zero filled memory bytes. eg
5754 PR 17512: file: 070-19381-0.004. */
5755 while (start
< end
&& * start
== 0)
5760 if (length
== 0xffffffff)
5762 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5764 initial_length_size
= 12;
5769 initial_length_size
= 4;
5772 block_end
= saved_start
+ length
+ initial_length_size
;
5773 if (block_end
> end
|| block_end
< start
)
5775 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5776 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5777 (unsigned long) (saved_start
- section_start
));
5781 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5783 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5784 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5789 start
= read_cie (start
, end
, &cie
, &version
,
5790 &augmentation_data_len
, &augmentation_data
);
5791 /* PR 17512: file: 027-135133-0.005. */
5798 fc
->chunk_start
= saved_start
;
5799 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5802 if (frame_need_space (fc
, mreg
) < 0)
5804 if (fc
->fde_encoding
)
5805 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5807 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5808 print_dwarf_vma (length
, fc
->ptr_size
);
5809 print_dwarf_vma (cie_id
, offset_size
);
5811 if (do_debug_frames_interp
)
5813 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5814 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5819 printf (" Version: %d\n", version
);
5820 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5823 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5824 printf (" Segment Size: %u\n", fc
->segment_size
);
5826 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5827 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5828 printf (" Return address column: %d\n", fc
->ra
);
5830 if (augmentation_data_len
)
5834 printf (" Augmentation data: ");
5835 for (i
= 0; i
< augmentation_data_len
; ++i
)
5836 /* FIXME: If do_wide is FALSE, then we should
5837 add carriage returns at 80 columns... */
5838 printf (" %02x", augmentation_data
[i
]);
5846 unsigned char *look_for
;
5847 static Frame_Chunk fde_fc
;
5848 unsigned long segment_selector
;
5852 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
5853 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
5856 look_for
= section_start
+ cie_id
;
5858 if (look_for
<= saved_start
)
5860 for (cie
= chunks
; cie
; cie
= cie
->next
)
5861 if (cie
->chunk_start
== look_for
)
5866 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
5867 if (cie
->chunk_start
== look_for
)
5871 unsigned int off_size
;
5872 unsigned char *cie_scan
;
5874 cie_scan
= look_for
;
5876 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
5877 if (length
== 0xffffffff)
5879 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
5886 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
5889 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
5890 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
5895 read_cie (cie_scan
, end
, &cie
, &version
,
5896 &augmentation_data_len
, &augmentation_data
);
5897 /* PR 17512: file: 3450-2098-0.004. */
5900 warn (_("Failed to read CIE information\n"));
5903 cie
->next
= forward_refs
;
5905 cie
->chunk_start
= look_for
;
5906 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5909 if (frame_need_space (cie
, mreg
) < 0)
5911 warn (_("Invalid max register\n"));
5914 if (cie
->fde_encoding
)
5916 = size_of_encoded_value (cie
->fde_encoding
);
5923 memset (fc
, 0, sizeof (Frame_Chunk
));
5927 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5928 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5929 (unsigned long) (saved_start
- section_start
));
5931 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5932 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5933 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
5935 warn (_("Invalid max register\n"));
5939 fc
->augmentation
= "";
5940 fc
->fde_encoding
= 0;
5941 fc
->ptr_size
= eh_addr_size
;
5942 fc
->segment_size
= 0;
5946 fc
->ncols
= cie
->ncols
;
5947 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5948 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5949 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5950 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5951 fc
->augmentation
= cie
->augmentation
;
5952 fc
->ptr_size
= cie
->ptr_size
;
5953 eh_addr_size
= cie
->ptr_size
;
5954 fc
->segment_size
= cie
->segment_size
;
5955 fc
->code_factor
= cie
->code_factor
;
5956 fc
->data_factor
= cie
->data_factor
;
5957 fc
->cfa_reg
= cie
->cfa_reg
;
5958 fc
->cfa_offset
= cie
->cfa_offset
;
5960 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
5962 warn (_("Invalid max register\n"));
5965 fc
->fde_encoding
= cie
->fde_encoding
;
5968 if (fc
->fde_encoding
)
5969 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5971 segment_selector
= 0;
5972 if (fc
->segment_size
)
5974 if (fc
->segment_size
> sizeof (segment_selector
))
5976 /* PR 17512: file: 9e196b3e. */
5977 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
5978 fc
->segment_size
= 4;
5980 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5983 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
5985 /* FIXME: It appears that sometimes the final pc_range value is
5986 encoded in less than encoded_ptr_size bytes. See the x86_64
5987 run of the "objcopy on compressed debug sections" test for an
5989 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
5991 if (cie
->augmentation
[0] == 'z')
5993 augmentation_data_len
= LEB ();
5994 augmentation_data
= start
;
5995 start
+= augmentation_data_len
;
5996 /* PR 17512: file: 722-8446-0.004. */
5997 if (start
>= end
|| ((signed long) augmentation_data_len
) < 0)
5999 warn (_("Corrupt augmentation data length: %lx\n"),
6000 augmentation_data_len
);
6002 augmentation_data
= NULL
;
6003 augmentation_data_len
= 0;
6007 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
6008 (unsigned long)(saved_start
- section_start
),
6009 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
6010 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
6011 (unsigned long)(cie
->chunk_start
- section_start
));
6013 if (fc
->segment_size
)
6014 printf ("%04lx:", segment_selector
);
6017 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
6018 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
6020 if (! do_debug_frames_interp
&& augmentation_data_len
)
6024 printf (" Augmentation data: ");
6025 for (i
= 0; i
< augmentation_data_len
; ++i
)
6026 printf (" %02x", augmentation_data
[i
]);
6032 /* At this point, fc is the current chunk, cie (if any) is set, and
6033 we're about to interpret instructions for the chunk. */
6034 /* ??? At present we need to do this always, since this sizes the
6035 fc->col_type and fc->col_offset arrays, which we write into always.
6036 We should probably split the interpreted and non-interpreted bits
6037 into two different routines, since there's so much that doesn't
6038 really overlap between them. */
6039 if (1 || do_debug_frames_interp
)
6041 /* Start by making a pass over the chunk, allocating storage
6042 and taking note of what registers are used. */
6043 unsigned char *tmp
= start
;
6045 while (start
< block_end
)
6047 unsigned int reg
, op
, opa
;
6049 unsigned char * new_start
;
6056 /* Warning: if you add any more cases to this switch, be
6057 sure to add them to the corresponding switch below. */
6060 case DW_CFA_advance_loc
:
6064 if (frame_need_space (fc
, opa
) >= 0)
6065 fc
->col_type
[opa
] = DW_CFA_undefined
;
6067 case DW_CFA_restore
:
6068 if (frame_need_space (fc
, opa
) >= 0)
6069 fc
->col_type
[opa
] = DW_CFA_undefined
;
6071 case DW_CFA_set_loc
:
6072 start
+= encoded_ptr_size
;
6074 case DW_CFA_advance_loc1
:
6077 case DW_CFA_advance_loc2
:
6080 case DW_CFA_advance_loc4
:
6083 case DW_CFA_offset_extended
:
6084 case DW_CFA_val_offset
:
6085 reg
= LEB (); LEB ();
6086 if (frame_need_space (fc
, reg
) >= 0)
6087 fc
->col_type
[reg
] = DW_CFA_undefined
;
6089 case DW_CFA_restore_extended
:
6091 if (frame_need_space (fc
, reg
) >= 0)
6092 fc
->col_type
[reg
] = DW_CFA_undefined
;
6094 case DW_CFA_undefined
:
6096 if (frame_need_space (fc
, reg
) >= 0)
6097 fc
->col_type
[reg
] = DW_CFA_undefined
;
6099 case DW_CFA_same_value
:
6101 if (frame_need_space (fc
, reg
) >= 0)
6102 fc
->col_type
[reg
] = DW_CFA_undefined
;
6104 case DW_CFA_register
:
6105 reg
= LEB (); LEB ();
6106 if (frame_need_space (fc
, reg
) >= 0)
6107 fc
->col_type
[reg
] = DW_CFA_undefined
;
6109 case DW_CFA_def_cfa
:
6112 case DW_CFA_def_cfa_register
:
6115 case DW_CFA_def_cfa_offset
:
6118 case DW_CFA_def_cfa_expression
:
6120 new_start
= start
+ temp
;
6121 if (new_start
< start
)
6123 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
6129 case DW_CFA_expression
:
6130 case DW_CFA_val_expression
:
6133 new_start
= start
+ temp
;
6134 if (new_start
< start
)
6136 /* PR 17512: file:306-192417-0.005. */
6137 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
6142 if (frame_need_space (fc
, reg
) >= 0)
6143 fc
->col_type
[reg
] = DW_CFA_undefined
;
6145 case DW_CFA_offset_extended_sf
:
6146 case DW_CFA_val_offset_sf
:
6147 reg
= LEB (); SLEB ();
6148 if (frame_need_space (fc
, reg
) >= 0)
6149 fc
->col_type
[reg
] = DW_CFA_undefined
;
6151 case DW_CFA_def_cfa_sf
:
6154 case DW_CFA_def_cfa_offset_sf
:
6157 case DW_CFA_MIPS_advance_loc8
:
6160 case DW_CFA_GNU_args_size
:
6163 case DW_CFA_GNU_negative_offset_extended
:
6164 reg
= LEB (); LEB ();
6165 if (frame_need_space (fc
, reg
) >= 0)
6166 fc
->col_type
[reg
] = DW_CFA_undefined
;
6175 /* Now we know what registers are used, make a second pass over
6176 the chunk, this time actually printing out the info. */
6178 while (start
< block_end
)
6180 unsigned char * tmp
;
6182 unsigned long ul
, reg
, roffs
;
6186 const char *reg_prefix
= "";
6193 /* Warning: if you add any more cases to this switch, be
6194 sure to add them to the corresponding switch above. */
6197 case DW_CFA_advance_loc
:
6198 if (do_debug_frames_interp
)
6199 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6201 printf (" DW_CFA_advance_loc: %d to %s\n",
6202 opa
* fc
->code_factor
,
6203 dwarf_vmatoa_1 (NULL
,
6204 fc
->pc_begin
+ opa
* fc
->code_factor
,
6206 fc
->pc_begin
+= opa
* fc
->code_factor
;
6211 if (opa
>= (unsigned int) fc
->ncols
)
6212 reg_prefix
= bad_reg
;
6213 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6214 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6215 reg_prefix
, regname (opa
, 0),
6216 roffs
* fc
->data_factor
);
6217 if (*reg_prefix
== '\0')
6219 fc
->col_type
[opa
] = DW_CFA_offset
;
6220 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
6224 case DW_CFA_restore
:
6225 if (opa
>= (unsigned int) cie
->ncols
6226 || opa
>= (unsigned int) fc
->ncols
)
6227 reg_prefix
= bad_reg
;
6228 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6229 printf (" DW_CFA_restore: %s%s\n",
6230 reg_prefix
, regname (opa
, 0));
6231 if (*reg_prefix
== '\0')
6233 fc
->col_type
[opa
] = cie
->col_type
[opa
];
6234 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
6235 if (do_debug_frames_interp
6236 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
6237 fc
->col_type
[opa
] = DW_CFA_undefined
;
6241 case DW_CFA_set_loc
:
6242 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
6243 if (do_debug_frames_interp
)
6244 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6246 printf (" DW_CFA_set_loc: %s\n",
6247 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
6251 case DW_CFA_advance_loc1
:
6252 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
6253 if (do_debug_frames_interp
)
6254 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6256 printf (" DW_CFA_advance_loc1: %ld to %s\n",
6257 (unsigned long) (ofs
* fc
->code_factor
),
6258 dwarf_vmatoa_1 (NULL
,
6259 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6261 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6264 case DW_CFA_advance_loc2
:
6265 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
6266 if (do_debug_frames_interp
)
6267 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6269 printf (" DW_CFA_advance_loc2: %ld to %s\n",
6270 (unsigned long) (ofs
* fc
->code_factor
),
6271 dwarf_vmatoa_1 (NULL
,
6272 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6274 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6277 case DW_CFA_advance_loc4
:
6278 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
6279 if (do_debug_frames_interp
)
6280 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6282 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6283 (unsigned long) (ofs
* fc
->code_factor
),
6284 dwarf_vmatoa_1 (NULL
,
6285 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6287 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6290 case DW_CFA_offset_extended
:
6293 if (reg
>= (unsigned int) fc
->ncols
)
6294 reg_prefix
= bad_reg
;
6295 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6296 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6297 reg_prefix
, regname (reg
, 0),
6298 roffs
* fc
->data_factor
);
6299 if (*reg_prefix
== '\0')
6301 fc
->col_type
[reg
] = DW_CFA_offset
;
6302 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6306 case DW_CFA_val_offset
:
6309 if (reg
>= (unsigned int) fc
->ncols
)
6310 reg_prefix
= bad_reg
;
6311 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6312 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6313 reg_prefix
, regname (reg
, 0),
6314 roffs
* fc
->data_factor
);
6315 if (*reg_prefix
== '\0')
6317 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6318 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6322 case DW_CFA_restore_extended
:
6324 if (reg
>= (unsigned int) cie
->ncols
6325 || reg
>= (unsigned int) fc
->ncols
)
6326 reg_prefix
= bad_reg
;
6327 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6328 printf (" DW_CFA_restore_extended: %s%s\n",
6329 reg_prefix
, regname (reg
, 0));
6330 if (*reg_prefix
== '\0')
6332 fc
->col_type
[reg
] = cie
->col_type
[reg
];
6333 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
6337 case DW_CFA_undefined
:
6339 if (reg
>= (unsigned int) fc
->ncols
)
6340 reg_prefix
= bad_reg
;
6341 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6342 printf (" DW_CFA_undefined: %s%s\n",
6343 reg_prefix
, regname (reg
, 0));
6344 if (*reg_prefix
== '\0')
6346 fc
->col_type
[reg
] = DW_CFA_undefined
;
6347 fc
->col_offset
[reg
] = 0;
6351 case DW_CFA_same_value
:
6353 if (reg
>= (unsigned int) fc
->ncols
)
6354 reg_prefix
= bad_reg
;
6355 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6356 printf (" DW_CFA_same_value: %s%s\n",
6357 reg_prefix
, regname (reg
, 0));
6358 if (*reg_prefix
== '\0')
6360 fc
->col_type
[reg
] = DW_CFA_same_value
;
6361 fc
->col_offset
[reg
] = 0;
6365 case DW_CFA_register
:
6368 if (reg
>= (unsigned int) fc
->ncols
)
6369 reg_prefix
= bad_reg
;
6370 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6372 printf (" DW_CFA_register: %s%s in ",
6373 reg_prefix
, regname (reg
, 0));
6374 puts (regname (roffs
, 0));
6376 if (*reg_prefix
== '\0')
6378 fc
->col_type
[reg
] = DW_CFA_register
;
6379 fc
->col_offset
[reg
] = roffs
;
6383 case DW_CFA_remember_state
:
6384 if (! do_debug_frames_interp
)
6385 printf (" DW_CFA_remember_state\n");
6386 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6387 rs
->cfa_offset
= fc
->cfa_offset
;
6388 rs
->cfa_reg
= fc
->cfa_reg
;
6390 rs
->cfa_exp
= fc
->cfa_exp
;
6391 rs
->ncols
= fc
->ncols
;
6392 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
6393 sizeof (* rs
->col_type
));
6394 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
6395 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
6396 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
6397 rs
->next
= remembered_state
;
6398 remembered_state
= rs
;
6401 case DW_CFA_restore_state
:
6402 if (! do_debug_frames_interp
)
6403 printf (" DW_CFA_restore_state\n");
6404 rs
= remembered_state
;
6407 remembered_state
= rs
->next
;
6408 fc
->cfa_offset
= rs
->cfa_offset
;
6409 fc
->cfa_reg
= rs
->cfa_reg
;
6411 fc
->cfa_exp
= rs
->cfa_exp
;
6412 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
6414 warn (_("Invalid column number in saved frame state\n"));
6418 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
6419 memcpy (fc
->col_offset
, rs
->col_offset
,
6420 rs
->ncols
* sizeof (* rs
->col_offset
));
6421 free (rs
->col_type
);
6422 free (rs
->col_offset
);
6425 else if (do_debug_frames_interp
)
6426 printf ("Mismatched DW_CFA_restore_state\n");
6429 case DW_CFA_def_cfa
:
6430 fc
->cfa_reg
= LEB ();
6431 fc
->cfa_offset
= LEB ();
6433 if (! do_debug_frames_interp
)
6434 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6435 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
6438 case DW_CFA_def_cfa_register
:
6439 fc
->cfa_reg
= LEB ();
6441 if (! do_debug_frames_interp
)
6442 printf (" DW_CFA_def_cfa_register: %s\n",
6443 regname (fc
->cfa_reg
, 0));
6446 case DW_CFA_def_cfa_offset
:
6447 fc
->cfa_offset
= LEB ();
6448 if (! do_debug_frames_interp
)
6449 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
6453 if (! do_debug_frames_interp
)
6454 printf (" DW_CFA_nop\n");
6457 case DW_CFA_def_cfa_expression
:
6459 if (start
>= block_end
|| start
+ ul
> block_end
|| start
+ ul
< start
)
6461 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
6464 if (! do_debug_frames_interp
)
6466 printf (" DW_CFA_def_cfa_expression (");
6467 decode_location_expression (start
, eh_addr_size
, 0, -1,
6475 case DW_CFA_expression
:
6478 if (reg
>= (unsigned int) fc
->ncols
)
6479 reg_prefix
= bad_reg
;
6480 /* PR 17512: file: 069-133014-0.006. */
6481 /* PR 17512: file: 98c02eb4. */
6483 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
6485 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
6488 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6490 printf (" DW_CFA_expression: %s%s (",
6491 reg_prefix
, regname (reg
, 0));
6492 decode_location_expression (start
, eh_addr_size
, 0, -1,
6496 if (*reg_prefix
== '\0')
6497 fc
->col_type
[reg
] = DW_CFA_expression
;
6501 case DW_CFA_val_expression
:
6504 if (reg
>= (unsigned int) fc
->ncols
)
6505 reg_prefix
= bad_reg
;
6507 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
6509 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
6512 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6514 printf (" DW_CFA_val_expression: %s%s (",
6515 reg_prefix
, regname (reg
, 0));
6516 decode_location_expression (start
, eh_addr_size
, 0, -1,
6520 if (*reg_prefix
== '\0')
6521 fc
->col_type
[reg
] = DW_CFA_val_expression
;
6525 case DW_CFA_offset_extended_sf
:
6528 if (frame_need_space (fc
, reg
) < 0)
6529 reg_prefix
= bad_reg
;
6530 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6531 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6532 reg_prefix
, regname (reg
, 0),
6533 (long)(l
* fc
->data_factor
));
6534 if (*reg_prefix
== '\0')
6536 fc
->col_type
[reg
] = DW_CFA_offset
;
6537 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6541 case DW_CFA_val_offset_sf
:
6544 if (frame_need_space (fc
, reg
) < 0)
6545 reg_prefix
= bad_reg
;
6546 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6547 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6548 reg_prefix
, regname (reg
, 0),
6549 (long)(l
* fc
->data_factor
));
6550 if (*reg_prefix
== '\0')
6552 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6553 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6557 case DW_CFA_def_cfa_sf
:
6558 fc
->cfa_reg
= LEB ();
6559 fc
->cfa_offset
= SLEB ();
6560 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6562 if (! do_debug_frames_interp
)
6563 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6564 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
6567 case DW_CFA_def_cfa_offset_sf
:
6568 fc
->cfa_offset
= SLEB ();
6569 fc
->cfa_offset
*= fc
->data_factor
;
6570 if (! do_debug_frames_interp
)
6571 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
6574 case DW_CFA_MIPS_advance_loc8
:
6575 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
6576 if (do_debug_frames_interp
)
6577 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6579 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6580 (unsigned long) (ofs
* fc
->code_factor
),
6581 dwarf_vmatoa_1 (NULL
,
6582 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6584 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6587 case DW_CFA_GNU_window_save
:
6588 if (! do_debug_frames_interp
)
6589 printf (" DW_CFA_GNU_window_save\n");
6592 case DW_CFA_GNU_args_size
:
6594 if (! do_debug_frames_interp
)
6595 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
6598 case DW_CFA_GNU_negative_offset_extended
:
6601 if (frame_need_space (fc
, reg
) < 0)
6602 reg_prefix
= bad_reg
;
6603 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6604 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6605 reg_prefix
, regname (reg
, 0),
6606 (long)(l
* fc
->data_factor
));
6607 if (*reg_prefix
== '\0')
6609 fc
->col_type
[reg
] = DW_CFA_offset
;
6610 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6615 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
6616 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
6618 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
6623 if (do_debug_frames_interp
)
6624 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6627 eh_addr_size
= saved_eh_addr_size
;
6640 display_gdb_index (struct dwarf_section
*section
,
6641 void *file ATTRIBUTE_UNUSED
)
6643 unsigned char *start
= section
->start
;
6645 uint32_t cu_list_offset
, tu_list_offset
;
6646 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6647 unsigned int cu_list_elements
, tu_list_elements
;
6648 unsigned int address_table_size
, symbol_table_slots
;
6649 unsigned char *cu_list
, *tu_list
;
6650 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6653 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6655 printf (_("Contents of the %s section:\n"), section
->name
);
6657 if (section
->size
< 6 * sizeof (uint32_t))
6659 warn (_("Truncated header in the %s section.\n"), section
->name
);
6663 version
= byte_get_little_endian (start
, 4);
6664 printf (_("Version %ld\n"), (long) version
);
6666 /* Prior versions are obsolete, and future versions may not be
6667 backwards compatible. */
6668 if (version
< 3 || version
> 8)
6670 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6674 warn (_("The address table data in version 3 may be wrong.\n"));
6676 warn (_("Version 4 does not support case insensitive lookups.\n"));
6678 warn (_("Version 5 does not include inlined functions.\n"));
6680 warn (_("Version 6 does not include symbol attributes.\n"));
6681 /* Version 7 indices generated by Gold have bad type unit references,
6682 PR binutils/15021. But we don't know if the index was generated by
6683 Gold or not, so to avoid worrying users with gdb-generated indices
6684 we say nothing for version 7 here. */
6686 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6687 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6688 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6689 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6690 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6692 if (cu_list_offset
> section
->size
6693 || tu_list_offset
> section
->size
6694 || address_table_offset
> section
->size
6695 || symbol_table_offset
> section
->size
6696 || constant_pool_offset
> section
->size
)
6698 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6702 /* PR 17531: file: 418d0a8a. */
6703 if (tu_list_offset
< cu_list_offset
)
6705 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6706 tu_list_offset
, cu_list_offset
);
6710 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6712 if (address_table_offset
< tu_list_offset
)
6714 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6715 address_table_offset
, tu_list_offset
);
6719 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6721 /* PR 17531: file: 18a47d3d. */
6722 if (symbol_table_offset
< address_table_offset
)
6724 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6725 symbol_table_offset
, address_table_offset
);
6729 address_table_size
= symbol_table_offset
- address_table_offset
;
6731 if (constant_pool_offset
< symbol_table_offset
)
6733 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6734 constant_pool_offset
, symbol_table_offset
);
6738 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6740 cu_list
= start
+ cu_list_offset
;
6741 tu_list
= start
+ tu_list_offset
;
6742 address_table
= start
+ address_table_offset
;
6743 symbol_table
= start
+ symbol_table_offset
;
6744 constant_pool
= start
+ constant_pool_offset
;
6746 if (address_table
+ address_table_size
* (2 + 8 + 4) > section
->start
+ section
->size
)
6748 warn (_("Address table extends beyond end of section.\n"));
6752 printf (_("\nCU table:\n"));
6753 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6755 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6756 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6758 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6759 (unsigned long) cu_offset
,
6760 (unsigned long) (cu_offset
+ cu_length
- 1));
6763 printf (_("\nTU table:\n"));
6764 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6766 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6767 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6768 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6770 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6771 (unsigned long) tu_offset
,
6772 (unsigned long) type_offset
);
6773 print_dwarf_vma (signature
, 8);
6777 printf (_("\nAddress table:\n"));
6778 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
6781 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6782 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6783 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6785 print_dwarf_vma (low
, 8);
6786 print_dwarf_vma (high
, 8);
6787 printf (_("%lu\n"), (unsigned long) cu_index
);
6790 printf (_("\nSymbol table:\n"));
6791 for (i
= 0; i
< symbol_table_slots
; ++i
)
6793 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6794 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6795 uint32_t num_cus
, cu
;
6797 if (name_offset
!= 0
6798 || cu_vector_offset
!= 0)
6801 unsigned char * adr
;
6803 adr
= constant_pool
+ name_offset
;
6804 /* PR 17531: file: 5b7b07ad. */
6805 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
6807 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
6808 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6812 printf ("[%3u] %.*s:", i
,
6813 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
6814 constant_pool
+ name_offset
);
6816 adr
= constant_pool
+ cu_vector_offset
;
6817 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
6819 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
6820 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6821 cu_vector_offset
, i
);
6825 num_cus
= byte_get_little_endian (adr
, 4);
6827 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
6828 if (num_cus
* 4 < num_cus
6829 || adr
>= section
->start
+ section
->size
6830 || adr
< constant_pool
)
6832 printf ("<invalid number of CUs: %d>\n", num_cus
);
6833 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6841 for (j
= 0; j
< num_cus
; ++j
)
6844 gdb_index_symbol_kind kind
;
6846 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6847 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6848 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6849 cu
= GDB_INDEX_CU_VALUE (cu
);
6850 /* Convert to TU number if it's for a type unit. */
6851 if (cu
>= cu_list_elements
/ 2)
6852 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6853 (unsigned long) (cu
- cu_list_elements
/ 2));
6855 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6857 printf (" [%s, %s]",
6858 is_static
? _("static") : _("global"),
6859 get_gdb_index_symbol_kind_name (kind
));
6871 /* Pre-allocate enough space for the CU/TU sets needed. */
6874 prealloc_cu_tu_list (unsigned int nshndx
)
6876 if (shndx_pool
== NULL
)
6878 shndx_pool_size
= nshndx
;
6879 shndx_pool_used
= 0;
6880 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6881 sizeof (unsigned int));
6885 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6886 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6887 sizeof (unsigned int));
6892 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6894 if (shndx_pool_used
>= shndx_pool_size
)
6896 error (_("Internal error: out of space in the shndx pool.\n"));
6899 shndx_pool
[shndx_pool_used
++] = shndx
;
6903 end_cu_tu_entry (void)
6905 if (shndx_pool_used
>= shndx_pool_size
)
6907 error (_("Internal error: out of space in the shndx pool.\n"));
6910 shndx_pool
[shndx_pool_used
++] = 0;
6913 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6916 get_DW_SECT_short_name (unsigned int dw_sect
)
6918 static char buf
[16];
6926 case DW_SECT_ABBREV
:
6932 case DW_SECT_STR_OFFSETS
:
6934 case DW_SECT_MACINFO
:
6942 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6946 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6947 These sections are extensions for Fission.
6948 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6951 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6953 unsigned char *phdr
= section
->start
;
6954 unsigned char *limit
= phdr
+ section
->size
;
6955 unsigned char *phash
;
6956 unsigned char *pindex
;
6957 unsigned char *ppool
;
6958 unsigned int version
;
6959 unsigned int ncols
= 0;
6961 unsigned int nslots
;
6964 dwarf_vma signature_high
;
6965 dwarf_vma signature_low
;
6968 /* PR 17512: file: 002-168123-0.004. */
6971 warn (_("Section %s is empty\n"), section
->name
);
6974 /* PR 17512: file: 002-376-0.004. */
6975 if (section
->size
< 24)
6977 warn (_("Section %s is too small to contain a CU/TU header\n"),
6982 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
6984 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
6985 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
6986 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
6989 pindex
= phash
+ nslots
* 8;
6990 ppool
= pindex
+ nslots
* 4;
6992 /* PR 17531: file: 45d69832. */
6993 if (pindex
< phash
|| ppool
< phdr
|| (pindex
== phash
&& nslots
!= 0))
6995 warn (_("Section %s is too small for %d slots\n"),
6996 section
->name
, nslots
);
7002 printf (_("Contents of the %s section:\n\n"), section
->name
);
7003 printf (_(" Version: %d\n"), version
);
7005 printf (_(" Number of columns: %d\n"), ncols
);
7006 printf (_(" Number of used entries: %d\n"), nused
);
7007 printf (_(" Number of slots: %d\n\n"), nslots
);
7010 if (ppool
> limit
|| ppool
< phdr
)
7012 warn (_("Section %s too small for %d hash table entries\n"),
7013 section
->name
, nslots
);
7020 prealloc_cu_tu_list ((limit
- ppool
) / 4);
7021 for (i
= 0; i
< nslots
; i
++)
7023 unsigned char *shndx_list
;
7026 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
7027 if (signature_high
!= 0 || signature_low
!= 0)
7029 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
7030 shndx_list
= ppool
+ j
* 4;
7031 /* PR 17531: file: 705e010d. */
7032 if (shndx_list
< ppool
)
7034 warn (_("Section index pool located before start of section\n"));
7039 printf (_(" [%3d] Signature: 0x%s Sections: "),
7040 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7041 buf
, sizeof (buf
)));
7044 if (shndx_list
>= limit
)
7046 warn (_("Section %s too small for shndx pool\n"),
7050 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
7054 printf (" %d", shndx
);
7056 add_shndx_to_cu_tu_entry (shndx
);
7068 else if (version
== 2)
7071 unsigned int dw_sect
;
7072 unsigned char *ph
= phash
;
7073 unsigned char *pi
= pindex
;
7074 unsigned char *poffsets
= ppool
+ ncols
* 4;
7075 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
7076 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
7077 bfd_boolean is_tu_index
;
7078 struct cu_tu_set
*this_set
= NULL
;
7080 unsigned char *prow
;
7082 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
7084 /* PR 17531: file: 0dd159bf.
7085 Check for wraparound with an overlarge ncols value. */
7086 if (poffsets
< ppool
|| (unsigned int) ((poffsets
- ppool
) / 4) != ncols
)
7088 warn (_("Overlarge number of columns: %x\n"), ncols
);
7094 warn (_("Section %s too small for offset and size tables\n"),
7101 printf (_(" Offset table\n"));
7102 printf (" slot %-16s ",
7103 is_tu_index
? _("signature") : _("dwo_id"));
7110 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
7116 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
7123 for (j
= 0; j
< ncols
; j
++)
7125 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7126 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
7131 for (i
= 0; i
< nslots
; i
++)
7133 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
7135 SAFE_BYTE_GET (row
, pi
, 4, limit
);
7138 /* PR 17531: file: a05f6ab3. */
7141 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7147 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
7149 prow
= poffsets
+ (row
- 1) * ncols
* 4;
7150 /* PR 17531: file: b8ce60a8. */
7151 if (prow
< poffsets
|| prow
> limit
)
7153 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
7159 printf (_(" [%3d] 0x%s"),
7160 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7161 buf
, sizeof (buf
)));
7162 for (j
= 0; j
< ncols
; j
++)
7164 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
7166 printf (" %8d", val
);
7169 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7171 /* PR 17531: file: 10796eb3. */
7172 if (dw_sect
>= DW_SECT_MAX
)
7173 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7175 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
7191 printf (_(" Size table\n"));
7192 printf (" slot %-16s ",
7193 is_tu_index
? _("signature") : _("dwo_id"));
7196 for (j
= 0; j
< ncols
; j
++)
7198 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
7200 printf (" %8s", get_DW_SECT_short_name (val
));
7206 for (i
= 0; i
< nslots
; i
++)
7208 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
7210 SAFE_BYTE_GET (row
, pi
, 4, limit
);
7213 prow
= psizes
+ (row
- 1) * ncols
* 4;
7216 printf (_(" [%3d] 0x%s"),
7217 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7218 buf
, sizeof (buf
)));
7220 for (j
= 0; j
< ncols
; j
++)
7222 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
7224 printf (" %8d", val
);
7227 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7228 if (dw_sect
>= DW_SECT_MAX
)
7229 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7231 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
7243 else if (do_display
)
7244 printf (_(" Unsupported version (%d)\n"), version
);
7252 /* Load the CU and TU indexes if present. This will build a list of
7253 section sets that we can use to associate a .debug_info.dwo section
7254 with its associated .debug_abbrev.dwo section in a .dwp file. */
7257 load_cu_tu_indexes (void *file
)
7259 /* If we have already loaded (or tried to load) the CU and TU indexes
7260 then do not bother to repeat the task. */
7261 if (cu_tu_indexes_read
)
7264 if (load_debug_section (dwp_cu_index
, file
))
7265 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
7267 if (load_debug_section (dwp_tu_index
, file
))
7268 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
7270 cu_tu_indexes_read
= 1;
7273 /* Find the set of sections that includes section SHNDX. */
7276 find_cu_tu_set (void *file
, unsigned int shndx
)
7280 load_cu_tu_indexes (file
);
7282 /* Find SHNDX in the shndx pool. */
7283 for (i
= 0; i
< shndx_pool_used
; i
++)
7284 if (shndx_pool
[i
] == shndx
)
7287 if (i
>= shndx_pool_used
)
7290 /* Now backup to find the first entry in the set. */
7291 while (i
> 0 && shndx_pool
[i
- 1] != 0)
7294 return shndx_pool
+ i
;
7297 /* Display a .debug_cu_index or .debug_tu_index section. */
7300 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
7302 return process_cu_tu_index (section
, 1);
7306 display_debug_not_supported (struct dwarf_section
*section
,
7307 void *file ATTRIBUTE_UNUSED
)
7309 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7315 /* Like malloc, but takes two parameters like calloc.
7316 Verifies that the first parameter is not too large.
7317 Note: does *not* initialise the allocated memory to zero. */
7319 cmalloc (size_t nmemb
, size_t size
)
7321 /* Check for overflow. */
7322 if (nmemb
>= ~(size_t) 0 / size
)
7325 return xmalloc (nmemb
* size
);
7328 /* Like xmalloc, but takes two parameters like calloc.
7329 Verifies that the first parameter is not too large.
7330 Note: does *not* initialise the allocated memory to zero. */
7332 xcmalloc (size_t nmemb
, size_t size
)
7334 /* Check for overflow. */
7335 if (nmemb
>= ~(size_t) 0 / size
)
7338 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7343 return xmalloc (nmemb
* size
);
7346 /* Like xrealloc, but takes three parameters.
7347 Verifies that the second parameter is not too large.
7348 Note: does *not* initialise any new memory to zero. */
7350 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
7352 /* Check for overflow. */
7353 if (nmemb
>= ~(size_t) 0 / size
)
7356 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7361 return xrealloc (ptr
, nmemb
* size
);
7364 /* Like xcalloc, but verifies that the first parameter is not too large. */
7366 xcalloc2 (size_t nmemb
, size_t size
)
7368 /* Check for overflow. */
7369 if (nmemb
>= ~(size_t) 0 / size
)
7372 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7377 return xcalloc (nmemb
, size
);
7381 free_debug_memory (void)
7387 for (i
= 0; i
< max
; i
++)
7388 free_debug_section ((enum dwarf_section_display_enum
) i
);
7390 if (debug_information
!= NULL
)
7392 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
7394 for (i
= 0; i
< num_debug_info_entries
; i
++)
7396 if (!debug_information
[i
].max_loc_offsets
)
7398 free (debug_information
[i
].loc_offsets
);
7399 free (debug_information
[i
].have_frame_base
);
7401 if (!debug_information
[i
].max_range_lists
)
7402 free (debug_information
[i
].range_lists
);
7405 free (debug_information
);
7406 debug_information
= NULL
;
7407 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
7412 dwarf_select_sections_by_names (const char *names
)
7416 const char * option
;
7420 debug_dump_long_opts
;
7422 static const debug_dump_long_opts opts_table
[] =
7424 /* Please keep this table alpha- sorted. */
7425 { "Ranges", & do_debug_ranges
, 1 },
7426 { "abbrev", & do_debug_abbrevs
, 1 },
7427 { "addr", & do_debug_addr
, 1 },
7428 { "aranges", & do_debug_aranges
, 1 },
7429 { "cu_index", & do_debug_cu_index
, 1 },
7430 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
7431 { "frames", & do_debug_frames
, 1 },
7432 { "frames-interp", & do_debug_frames_interp
, 1 },
7433 /* The special .gdb_index section. */
7434 { "gdb_index", & do_gdb_index
, 1 },
7435 { "info", & do_debug_info
, 1 },
7436 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
7437 { "loc", & do_debug_loc
, 1 },
7438 { "macro", & do_debug_macinfo
, 1 },
7439 { "pubnames", & do_debug_pubnames
, 1 },
7440 { "pubtypes", & do_debug_pubtypes
, 1 },
7441 /* This entry is for compatability
7442 with earlier versions of readelf. */
7443 { "ranges", & do_debug_aranges
, 1 },
7444 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
7445 { "str", & do_debug_str
, 1 },
7446 /* These trace_* sections are used by Itanium VMS. */
7447 { "trace_abbrev", & do_trace_abbrevs
, 1 },
7448 { "trace_aranges", & do_trace_aranges
, 1 },
7449 { "trace_info", & do_trace_info
, 1 },
7458 const debug_dump_long_opts
* entry
;
7460 for (entry
= opts_table
; entry
->option
; entry
++)
7462 size_t len
= strlen (entry
->option
);
7464 if (strncmp (p
, entry
->option
, len
) == 0
7465 && (p
[len
] == ',' || p
[len
] == '\0'))
7467 * entry
->variable
|= entry
->val
;
7469 /* The --debug-dump=frames-interp option also
7470 enables the --debug-dump=frames option. */
7471 if (do_debug_frames_interp
)
7472 do_debug_frames
= 1;
7479 if (entry
->option
== NULL
)
7481 warn (_("Unrecognized debug option '%s'\n"), p
);
7482 p
= strchr (p
, ',');
7493 dwarf_select_sections_by_letters (const char *letters
)
7495 unsigned int lindex
= 0;
7497 while (letters
[lindex
])
7498 switch (letters
[lindex
++])
7505 do_debug_abbrevs
= 1;
7509 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
7513 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
7517 do_debug_pubnames
= 1;
7521 do_debug_pubtypes
= 1;
7525 do_debug_aranges
= 1;
7529 do_debug_ranges
= 1;
7533 do_debug_frames_interp
= 1;
7535 do_debug_frames
= 1;
7539 do_debug_macinfo
= 1;
7551 warn (_("Unrecognized debug option '%s'\n"), letters
);
7557 dwarf_select_sections_all (void)
7560 do_debug_abbrevs
= 1;
7561 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
7562 do_debug_pubnames
= 1;
7563 do_debug_pubtypes
= 1;
7564 do_debug_aranges
= 1;
7565 do_debug_ranges
= 1;
7566 do_debug_frames
= 1;
7567 do_debug_macinfo
= 1;
7572 do_trace_abbrevs
= 1;
7573 do_trace_aranges
= 1;
7575 do_debug_cu_index
= 1;
7578 struct dwarf_section_display debug_displays
[] =
7580 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7581 display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
7582 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7583 display_debug_aranges
, &do_debug_aranges
, TRUE
},
7584 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7585 display_debug_frames
, &do_debug_frames
, TRUE
},
7586 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
, NULL
, 0, NULL
},
7587 display_debug_info
, &do_debug_info
, TRUE
},
7588 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7589 display_debug_lines
, &do_debug_lines
, TRUE
},
7590 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7591 display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
7592 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7593 display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
7594 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7595 display_debug_frames
, &do_debug_frames
, TRUE
},
7596 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7597 display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
7598 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7599 display_debug_macro
, &do_debug_macinfo
, TRUE
},
7600 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7601 display_debug_str
, &do_debug_str
, FALSE
},
7602 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7603 display_debug_loc
, &do_debug_loc
, TRUE
},
7604 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7605 display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
7606 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7607 display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
7608 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7609 display_debug_ranges
, &do_debug_ranges
, TRUE
},
7610 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7611 display_debug_not_supported
, NULL
, FALSE
},
7612 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7613 display_debug_not_supported
, NULL
, FALSE
},
7614 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
, NULL
, 0, NULL
},
7615 display_debug_types
, &do_debug_info
, TRUE
},
7616 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7617 display_debug_not_supported
, NULL
, FALSE
},
7618 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7619 display_gdb_index
, &do_gdb_index
, FALSE
},
7620 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
, NULL
, 0, NULL
},
7621 display_trace_info
, &do_trace_info
, TRUE
},
7622 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7623 display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
7624 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7625 display_debug_aranges
, &do_trace_aranges
, FALSE
},
7626 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
, 0, NULL
},
7627 display_debug_info
, &do_debug_info
, TRUE
},
7628 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7629 display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
7630 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
, 0, NULL
},
7631 display_debug_types
, &do_debug_info
, TRUE
},
7632 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7633 display_debug_lines
, &do_debug_lines
, TRUE
},
7634 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7635 display_debug_loc
, &do_debug_loc
, TRUE
},
7636 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7637 display_debug_macro
, &do_debug_macinfo
, TRUE
},
7638 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7639 display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
7640 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7641 display_debug_str
, &do_debug_str
, TRUE
},
7642 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7643 display_debug_str_offsets
, NULL
, FALSE
},
7644 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7645 display_debug_str_offsets
, NULL
, FALSE
},
7646 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7647 display_debug_addr
, &do_debug_addr
, TRUE
},
7648 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7649 display_cu_index
, &do_debug_cu_index
, FALSE
},
7650 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7651 display_cu_index
, &do_debug_cu_index
, FALSE
},