1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2016 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 unsigned int amount = (AMOUNT); \
321 if (sizeof (VAL) < amount) \
323 error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\
324 amount, (int) sizeof (VAL)); \
325 amount = sizeof (VAL); \
327 if (((PTR) + amount) >= (END)) \
330 amount = (END) - (PTR); \
334 if (amount == 0 || amount > 8) \
337 VAL = byte_get ((PTR), amount); \
341 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
344 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
349 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
352 unsigned int amount = (AMOUNT); \
353 if (((PTR) + amount) >= (END)) \
356 amount = (END) - (PTR); \
361 VAL = byte_get_signed ((PTR), amount); \
367 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
370 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
375 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
378 if (((PTR) + 8) <= (END)) \
380 byte_get_64 ((PTR), (HIGH), (LOW)); \
384 * (LOW) = * (HIGH) = 0; \
389 typedef struct State_Machine_Registers
397 unsigned char op_index
;
398 unsigned char end_sequence
;
399 /* This variable hold the number of the last entry seen
400 in the File Table. */
401 unsigned int last_file_entry
;
404 static SMR state_machine_regs
;
407 reset_state_machine (int is_stmt
)
409 state_machine_regs
.address
= 0;
410 state_machine_regs
.op_index
= 0;
411 state_machine_regs
.file
= 1;
412 state_machine_regs
.line
= 1;
413 state_machine_regs
.column
= 0;
414 state_machine_regs
.is_stmt
= is_stmt
;
415 state_machine_regs
.basic_block
= 0;
416 state_machine_regs
.end_sequence
= 0;
417 state_machine_regs
.last_file_entry
= 0;
420 /* Handled an extend line op.
421 Returns the number of bytes read. */
424 process_extended_line_op (unsigned char * data
,
428 unsigned char op_code
;
429 unsigned int bytes_read
;
432 unsigned char *orig_data
= data
;
435 len
= read_uleb128 (data
, & bytes_read
, end
);
438 if (len
== 0 || data
== end
|| len
> (uintptr_t) (end
- data
))
440 warn (_("Badly formed extended line op encountered!\n"));
447 printf (_(" Extended opcode %d: "), op_code
);
451 case DW_LNE_end_sequence
:
452 printf (_("End of Sequence\n\n"));
453 reset_state_machine (is_stmt
);
456 case DW_LNE_set_address
:
457 /* PR 17512: file: 002-100480-0.004. */
458 if (len
- bytes_read
- 1 > 8)
460 warn (_("Length (%d) of DW_LNE_set_address op is too long\n"),
461 len
- bytes_read
- 1);
465 SAFE_BYTE_GET (adr
, data
, len
- bytes_read
- 1, end
);
466 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
467 state_machine_regs
.address
= adr
;
468 state_machine_regs
.op_index
= 0;
471 case DW_LNE_define_file
:
472 printf (_("define new File Table entry\n"));
473 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
474 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
477 data
+= strnlen ((char *) data
, end
- data
) + 1;
478 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
480 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
482 printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
484 printf ("%s\n\n", name
);
486 if (((unsigned int) (data
- orig_data
) != len
) || data
== end
)
487 warn (_("DW_LNE_define_file: Bad opcode length\n"));
490 case DW_LNE_set_discriminator
:
491 printf (_("set Discriminator to %s\n"),
492 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
496 case DW_LNE_HP_negate_is_UV_update
:
497 printf ("DW_LNE_HP_negate_is_UV_update\n");
499 case DW_LNE_HP_push_context
:
500 printf ("DW_LNE_HP_push_context\n");
502 case DW_LNE_HP_pop_context
:
503 printf ("DW_LNE_HP_pop_context\n");
505 case DW_LNE_HP_set_file_line_column
:
506 printf ("DW_LNE_HP_set_file_line_column\n");
508 case DW_LNE_HP_set_routine_name
:
509 printf ("DW_LNE_HP_set_routine_name\n");
511 case DW_LNE_HP_set_sequence
:
512 printf ("DW_LNE_HP_set_sequence\n");
514 case DW_LNE_HP_negate_post_semantics
:
515 printf ("DW_LNE_HP_negate_post_semantics\n");
517 case DW_LNE_HP_negate_function_exit
:
518 printf ("DW_LNE_HP_negate_function_exit\n");
520 case DW_LNE_HP_negate_front_end_logical
:
521 printf ("DW_LNE_HP_negate_front_end_logical\n");
523 case DW_LNE_HP_define_proc
:
524 printf ("DW_LNE_HP_define_proc\n");
526 case DW_LNE_HP_source_file_correlation
:
528 unsigned char *edata
= data
+ len
- bytes_read
- 1;
530 printf ("DW_LNE_HP_source_file_correlation\n");
536 opc
= read_uleb128 (data
, & bytes_read
, edata
);
541 case DW_LNE_HP_SFC_formfeed
:
542 printf (" DW_LNE_HP_SFC_formfeed\n");
544 case DW_LNE_HP_SFC_set_listing_line
:
545 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
547 read_uleb128 (data
, & bytes_read
, edata
)));
550 case DW_LNE_HP_SFC_associate
:
551 printf (" DW_LNE_HP_SFC_associate ");
554 read_uleb128 (data
, & bytes_read
, edata
)));
558 read_uleb128 (data
, & bytes_read
, edata
)));
562 read_uleb128 (data
, & bytes_read
, edata
)));
566 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
576 unsigned int rlen
= len
- bytes_read
- 1;
578 if (op_code
>= DW_LNE_lo_user
579 /* The test against DW_LNW_hi_user is redundant due to
580 the limited range of the unsigned char data type used
582 /*&& op_code <= DW_LNE_hi_user*/)
583 printf (_("user defined: "));
585 printf (_("UNKNOWN: "));
586 printf (_("length %d ["), rlen
);
588 printf (" %02x", *data
++);
597 static const unsigned char *
598 fetch_indirect_string (dwarf_vma offset
)
600 struct dwarf_section
*section
= &debug_displays
[str
].section
;
602 if (section
->start
== NULL
)
603 return (const unsigned char *) _("<no .debug_str section>");
605 if (offset
> section
->size
)
607 warn (_("DW_FORM_strp offset too big: %s\n"),
608 dwarf_vmatoa ("x", offset
));
609 return (const unsigned char *) _("<offset is too big>");
612 return (const unsigned char *) section
->start
+ offset
;
616 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
617 dwarf_vma offset_size
, int dwo
)
619 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
620 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
621 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
622 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
623 dwarf_vma index_offset
= idx
* offset_size
;
624 dwarf_vma str_offset
;
626 if (index_section
->start
== NULL
)
627 return (dwo
? _("<no .debug_str_offsets.dwo section>")
628 : _("<no .debug_str_offsets section>"));
630 if (this_set
!= NULL
)
631 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
632 if (index_offset
> index_section
->size
)
634 warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),
635 dwarf_vmatoa ("x", index_offset
));
636 return _("<index offset is too big>");
639 if (str_section
->start
== NULL
)
640 return (dwo
? _("<no .debug_str.dwo section>")
641 : _("<no .debug_str section>"));
643 str_offset
= byte_get (index_section
->start
+ index_offset
, offset_size
);
644 str_offset
-= str_section
->address
;
645 if (str_offset
> str_section
->size
)
647 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
648 dwarf_vmatoa ("x", str_offset
));
649 return _("<indirect index offset is too big>");
652 return (const char *) str_section
->start
+ str_offset
;
656 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
658 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
660 if (section
->start
== NULL
)
661 return (_("<no .debug_addr section>"));
663 if (offset
+ bytes
> section
->size
)
665 warn (_("Offset into section %s too big: %s\n"),
666 section
->name
, dwarf_vmatoa ("x", offset
));
667 return "<offset too big>";
670 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
674 /* FIXME: There are better and more efficient ways to handle
675 these structures. For now though, I just want something that
676 is simple to implement. */
677 typedef struct abbrev_attr
679 unsigned long attribute
;
681 struct abbrev_attr
*next
;
685 typedef struct abbrev_entry
690 struct abbrev_attr
*first_attr
;
691 struct abbrev_attr
*last_attr
;
692 struct abbrev_entry
*next
;
696 static abbrev_entry
*first_abbrev
= NULL
;
697 static abbrev_entry
*last_abbrev
= NULL
;
704 for (abbrv
= first_abbrev
; abbrv
;)
706 abbrev_entry
*next_abbrev
= abbrv
->next
;
709 for (attr
= abbrv
->first_attr
; attr
;)
711 abbrev_attr
*next_attr
= attr
->next
;
721 last_abbrev
= first_abbrev
= NULL
;
725 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
729 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
734 entry
->entry
= number
;
736 entry
->children
= children
;
737 entry
->first_attr
= NULL
;
738 entry
->last_attr
= NULL
;
741 if (first_abbrev
== NULL
)
742 first_abbrev
= entry
;
744 last_abbrev
->next
= entry
;
750 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
754 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
759 attr
->attribute
= attribute
;
763 if (last_abbrev
->first_attr
== NULL
)
764 last_abbrev
->first_attr
= attr
;
766 last_abbrev
->last_attr
->next
= attr
;
768 last_abbrev
->last_attr
= attr
;
771 /* Processes the (partial) contents of a .debug_abbrev section.
772 Returns NULL if the end of the section was encountered.
773 Returns the address after the last byte read if the end of
774 an abbreviation set was found. */
776 static unsigned char *
777 process_abbrev_section (unsigned char *start
, unsigned char *end
)
779 if (first_abbrev
!= NULL
)
784 unsigned int bytes_read
;
787 unsigned long attribute
;
790 entry
= read_uleb128 (start
, & bytes_read
, end
);
793 /* A single zero is supposed to end the section according
794 to the standard. If there's more, then signal that to
801 tag
= read_uleb128 (start
, & bytes_read
, end
);
808 add_abbrev (entry
, tag
, children
);
814 attribute
= read_uleb128 (start
, & bytes_read
, end
);
819 form
= read_uleb128 (start
, & bytes_read
, end
);
824 add_abbrev_attr (attribute
, form
);
826 while (attribute
!= 0);
829 /* Report the missing single zero which ends the section. */
830 error (_(".debug_abbrev section not zero terminated\n"));
836 get_TAG_name (unsigned long tag
)
838 const char *name
= get_DW_TAG_name ((unsigned int)tag
);
842 static char buffer
[100];
844 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
852 get_FORM_name (unsigned long form
)
857 return "DW_FORM value: 0";
859 name
= get_DW_FORM_name (form
);
862 static char buffer
[100];
864 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
871 static unsigned char *
872 display_block (unsigned char *data
,
874 const unsigned char * const end
)
878 printf (_(" %s byte block: "), dwarf_vmatoa ("u", length
));
880 return (unsigned char *) end
;
882 maxlen
= (dwarf_vma
) (end
- data
);
883 length
= length
> maxlen
? maxlen
: length
;
886 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
892 decode_location_expression (unsigned char * data
,
893 unsigned int pointer_size
,
894 unsigned int offset_size
,
898 struct dwarf_section
* section
)
901 unsigned int bytes_read
;
903 dwarf_signed_vma svalue
;
904 unsigned char *end
= data
+ length
;
905 int need_frame_base
= 0;
914 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
915 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
918 printf ("DW_OP_deref");
921 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
922 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
925 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
926 printf ("DW_OP_const1s: %ld", (long) svalue
);
929 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
930 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
933 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
934 printf ("DW_OP_const2s: %ld", (long) svalue
);
937 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
938 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
941 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
942 printf ("DW_OP_const4s: %ld", (long) svalue
);
945 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
946 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
947 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
948 printf ("%lu", (unsigned long) uvalue
);
951 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
952 printf ("DW_OP_const8s: %ld ", (long) svalue
);
953 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
954 printf ("%ld", (long) svalue
);
957 printf ("DW_OP_constu: %s",
958 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
962 printf ("DW_OP_consts: %s",
963 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
967 printf ("DW_OP_dup");
970 printf ("DW_OP_drop");
973 printf ("DW_OP_over");
976 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
977 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
980 printf ("DW_OP_swap");
983 printf ("DW_OP_rot");
986 printf ("DW_OP_xderef");
989 printf ("DW_OP_abs");
992 printf ("DW_OP_and");
995 printf ("DW_OP_div");
998 printf ("DW_OP_minus");
1001 printf ("DW_OP_mod");
1004 printf ("DW_OP_mul");
1007 printf ("DW_OP_neg");
1010 printf ("DW_OP_not");
1013 printf ("DW_OP_or");
1016 printf ("DW_OP_plus");
1018 case DW_OP_plus_uconst
:
1019 printf ("DW_OP_plus_uconst: %s",
1020 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1024 printf ("DW_OP_shl");
1027 printf ("DW_OP_shr");
1030 printf ("DW_OP_shra");
1033 printf ("DW_OP_xor");
1036 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1037 printf ("DW_OP_bra: %ld", (long) svalue
);
1040 printf ("DW_OP_eq");
1043 printf ("DW_OP_ge");
1046 printf ("DW_OP_gt");
1049 printf ("DW_OP_le");
1052 printf ("DW_OP_lt");
1055 printf ("DW_OP_ne");
1058 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1059 printf ("DW_OP_skip: %ld", (long) svalue
);
1094 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1129 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1130 regname (op
- DW_OP_reg0
, 1));
1165 printf ("DW_OP_breg%d (%s): %s",
1167 regname (op
- DW_OP_breg0
, 1),
1168 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1173 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1175 printf ("DW_OP_regx: %s (%s)",
1176 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1179 need_frame_base
= 1;
1180 printf ("DW_OP_fbreg: %s",
1181 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1185 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1187 printf ("DW_OP_bregx: %s (%s) %s",
1188 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1189 dwarf_vmatoa ("d", read_sleb128 (data
, &bytes_read
, end
)));
1193 printf ("DW_OP_piece: %s",
1194 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1197 case DW_OP_deref_size
:
1198 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1199 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1201 case DW_OP_xderef_size
:
1202 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1203 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1206 printf ("DW_OP_nop");
1209 /* DWARF 3 extensions. */
1210 case DW_OP_push_object_address
:
1211 printf ("DW_OP_push_object_address");
1214 /* XXX: Strictly speaking for 64-bit DWARF3 files
1215 this ought to be an 8-byte wide computation. */
1216 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1217 printf ("DW_OP_call2: <0x%s>",
1218 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1221 /* XXX: Strictly speaking for 64-bit DWARF3 files
1222 this ought to be an 8-byte wide computation. */
1223 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1224 printf ("DW_OP_call4: <0x%s>",
1225 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1227 case DW_OP_call_ref
:
1228 /* XXX: Strictly speaking for 64-bit DWARF3 files
1229 this ought to be an 8-byte wide computation. */
1230 if (dwarf_version
== -1)
1232 printf (_("(DW_OP_call_ref in frame info)"));
1233 /* No way to tell where the next op is, so just bail. */
1234 return need_frame_base
;
1236 if (dwarf_version
== 2)
1238 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1242 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1244 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1246 case DW_OP_form_tls_address
:
1247 printf ("DW_OP_form_tls_address");
1249 case DW_OP_call_frame_cfa
:
1250 printf ("DW_OP_call_frame_cfa");
1252 case DW_OP_bit_piece
:
1253 printf ("DW_OP_bit_piece: ");
1254 printf (_("size: %s "),
1255 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1257 printf (_("offset: %s "),
1258 dwarf_vmatoa ("u", read_uleb128 (data
, &bytes_read
, end
)));
1262 /* DWARF 4 extensions. */
1263 case DW_OP_stack_value
:
1264 printf ("DW_OP_stack_value");
1267 case DW_OP_implicit_value
:
1268 printf ("DW_OP_implicit_value");
1269 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1271 data
= display_block (data
, uvalue
, end
);
1274 /* GNU extensions. */
1275 case DW_OP_GNU_push_tls_address
:
1276 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1278 case DW_OP_GNU_uninit
:
1279 printf ("DW_OP_GNU_uninit");
1280 /* FIXME: Is there data associated with this OP ? */
1282 case DW_OP_GNU_encoded_addr
:
1289 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1291 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1292 print_dwarf_vma (addr
, pointer_size
);
1295 case DW_OP_GNU_implicit_pointer
:
1296 /* XXX: Strictly speaking for 64-bit DWARF3 files
1297 this ought to be an 8-byte wide computation. */
1298 if (dwarf_version
== -1)
1300 printf (_("(DW_OP_GNU_implicit_pointer in frame info)"));
1301 /* No way to tell where the next op is, so just bail. */
1302 return need_frame_base
;
1304 if (dwarf_version
== 2)
1306 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1310 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1312 printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s",
1313 dwarf_vmatoa ("x", uvalue
),
1314 dwarf_vmatoa ("d", read_sleb128 (data
,
1315 &bytes_read
, end
)));
1318 case DW_OP_GNU_entry_value
:
1319 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1321 /* PR 17531: file: 0cc9cd00. */
1322 if (uvalue
> (dwarf_vma
) (end
- data
))
1323 uvalue
= end
- data
;
1324 printf ("DW_OP_GNU_entry_value: (");
1325 if (decode_location_expression (data
, pointer_size
, offset_size
,
1326 dwarf_version
, uvalue
,
1327 cu_offset
, section
))
1328 need_frame_base
= 1;
1334 case DW_OP_GNU_const_type
:
1335 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1337 printf ("DW_OP_GNU_const_type: <0x%s> ",
1338 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1339 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1340 data
= display_block (data
, uvalue
, end
);
1342 case DW_OP_GNU_regval_type
:
1343 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1345 printf ("DW_OP_GNU_regval_type: %s (%s)",
1346 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1347 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1349 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1351 case DW_OP_GNU_deref_type
:
1352 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1353 printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue
);
1354 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1356 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1358 case DW_OP_GNU_convert
:
1359 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1361 printf ("DW_OP_GNU_convert <0x%s>",
1362 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1364 case DW_OP_GNU_reinterpret
:
1365 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1367 printf ("DW_OP_GNU_reinterpret <0x%s>",
1368 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1370 case DW_OP_GNU_parameter_ref
:
1371 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1372 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1373 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1375 case DW_OP_GNU_addr_index
:
1376 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1378 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1380 case DW_OP_GNU_const_index
:
1381 uvalue
= read_uleb128 (data
, &bytes_read
, end
);
1383 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1386 /* HP extensions. */
1387 case DW_OP_HP_is_value
:
1388 printf ("DW_OP_HP_is_value");
1389 /* FIXME: Is there data associated with this OP ? */
1391 case DW_OP_HP_fltconst4
:
1392 printf ("DW_OP_HP_fltconst4");
1393 /* FIXME: Is there data associated with this OP ? */
1395 case DW_OP_HP_fltconst8
:
1396 printf ("DW_OP_HP_fltconst8");
1397 /* FIXME: Is there data associated with this OP ? */
1399 case DW_OP_HP_mod_range
:
1400 printf ("DW_OP_HP_mod_range");
1401 /* FIXME: Is there data associated with this OP ? */
1403 case DW_OP_HP_unmod_range
:
1404 printf ("DW_OP_HP_unmod_range");
1405 /* FIXME: Is there data associated with this OP ? */
1408 printf ("DW_OP_HP_tls");
1409 /* FIXME: Is there data associated with this OP ? */
1412 /* PGI (STMicroelectronics) extensions. */
1413 case DW_OP_PGI_omp_thread_num
:
1414 /* Pushes the thread number for the current thread as it would be
1415 returned by the standard OpenMP library function:
1416 omp_get_thread_num(). The "current thread" is the thread for
1417 which the expression is being evaluated. */
1418 printf ("DW_OP_PGI_omp_thread_num");
1422 if (op
>= DW_OP_lo_user
1423 && op
<= DW_OP_hi_user
)
1424 printf (_("(User defined location op)"));
1426 printf (_("(Unknown location op)"));
1427 /* No way to tell where the next op is, so just bail. */
1428 return need_frame_base
;
1431 /* Separate the ops. */
1436 return need_frame_base
;
1439 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1440 This is used for DWARF package files. */
1442 static struct cu_tu_set
*
1443 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1445 struct cu_tu_set
*p
;
1447 unsigned int dw_sect
;
1453 dw_sect
= DW_SECT_TYPES
;
1459 dw_sect
= DW_SECT_INFO
;
1463 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1471 /* Add INC to HIGH_BITS:LOW_BITS. */
1473 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1475 dwarf_vma tmp
= * low_bits
;
1479 /* FIXME: There is probably a better way of handling this:
1481 We need to cope with dwarf_vma being a 32-bit or 64-bit
1482 type. Plus regardless of its size LOW_BITS is meant to
1483 only hold 32-bits, so if there is overflow or wrap around
1484 we must propagate into HIGH_BITS. */
1485 if (tmp
< * low_bits
)
1489 else if (sizeof (tmp
) > 8
1499 static unsigned char *
1500 read_and_display_attr_value (unsigned long attribute
,
1502 unsigned char * data
,
1503 unsigned char * end
,
1504 dwarf_vma cu_offset
,
1505 dwarf_vma pointer_size
,
1506 dwarf_vma offset_size
,
1508 debug_info
* debug_info_p
,
1510 struct dwarf_section
* section
,
1511 struct cu_tu_set
* this_set
)
1513 dwarf_vma uvalue
= 0;
1514 unsigned char *block_start
= NULL
;
1515 unsigned char * orig_data
= data
;
1516 unsigned int bytes_read
;
1518 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
1520 warn (_("Corrupt attribute\n"));
1529 case DW_FORM_ref_addr
:
1530 if (dwarf_version
== 2)
1531 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1532 else if (dwarf_version
== 3 || dwarf_version
== 4)
1533 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1535 error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
1540 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1544 case DW_FORM_sec_offset
:
1545 case DW_FORM_GNU_ref_alt
:
1546 case DW_FORM_GNU_strp_alt
:
1547 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1550 case DW_FORM_flag_present
:
1557 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1562 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1567 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1571 uvalue
= read_sleb128 (data
, & bytes_read
, end
);
1575 case DW_FORM_GNU_str_index
:
1576 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1580 case DW_FORM_ref_udata
:
1582 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1586 case DW_FORM_indirect
:
1587 form
= read_uleb128 (data
, & bytes_read
, end
);
1590 printf (" %s", get_FORM_name (form
));
1591 return read_and_display_attr_value (attribute
, form
, data
, end
,
1592 cu_offset
, pointer_size
,
1593 offset_size
, dwarf_version
,
1594 debug_info_p
, do_loc
,
1596 case DW_FORM_GNU_addr_index
:
1597 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1604 case DW_FORM_ref_addr
:
1606 printf (" <0x%s>", dwarf_vmatoa ("x",uvalue
));
1609 case DW_FORM_GNU_ref_alt
:
1611 printf (" <alt 0x%s>", dwarf_vmatoa ("x",uvalue
));
1617 case DW_FORM_ref_udata
:
1619 printf (" <0x%s>", dwarf_vmatoa ("x", uvalue
+ cu_offset
));
1624 case DW_FORM_sec_offset
:
1626 printf (" 0x%s", dwarf_vmatoa ("x", uvalue
));
1629 case DW_FORM_flag_present
:
1636 printf (" %s", dwarf_vmatoa ("d", uvalue
));
1643 dwarf_vma high_bits
;
1647 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1649 if (form
== DW_FORM_ref8
)
1650 add64 (& high_bits
, & utmp
, cu_offset
);
1652 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
1655 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1656 && num_debug_info_entries
== 0)
1658 if (sizeof (uvalue
) == 8)
1659 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
1661 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
1667 case DW_FORM_string
:
1669 printf (" %.*s", (int) (end
- data
), data
);
1670 data
+= strnlen ((char *) data
, end
- data
) + 1;
1674 case DW_FORM_exprloc
:
1675 uvalue
= read_uleb128 (data
, & bytes_read
, end
);
1676 block_start
= data
+ bytes_read
;
1677 if (block_start
>= end
)
1679 warn (_("Block ends prematurely\n"));
1683 /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with
1684 gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute
1685 block_start + uvalue here. */
1686 data
= block_start
+ uvalue
;
1687 /* PR 17512: file: 008-103549-0.001:0.1. */
1688 if (block_start
+ uvalue
> end
|| data
< block_start
)
1690 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1691 uvalue
= end
- block_start
;
1694 data
= block_start
+ uvalue
;
1696 data
= display_block (block_start
, uvalue
, end
);
1699 case DW_FORM_block1
:
1700 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
1701 block_start
= data
+ 1;
1702 if (block_start
>= end
)
1704 warn (_("Block ends prematurely\n"));
1708 data
= block_start
+ uvalue
;
1709 if (block_start
+ uvalue
> end
|| data
< block_start
)
1711 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1712 uvalue
= end
- block_start
;
1715 data
= block_start
+ uvalue
;
1717 data
= display_block (block_start
, uvalue
, end
);
1720 case DW_FORM_block2
:
1721 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
1722 block_start
= data
+ 2;
1723 if (block_start
>= end
)
1725 warn (_("Block ends prematurely\n"));
1729 data
= block_start
+ uvalue
;
1730 if (block_start
+ uvalue
> end
|| data
< block_start
)
1732 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1733 uvalue
= end
- block_start
;
1736 data
= block_start
+ uvalue
;
1738 data
= display_block (block_start
, uvalue
, end
);
1741 case DW_FORM_block4
:
1742 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
1743 block_start
= data
+ 4;
1744 /* PR 17512: file: 3371-3907-0.004. */
1745 if (block_start
>= end
)
1747 warn (_("Block ends prematurely\n"));
1751 data
= block_start
+ uvalue
;
1752 if (block_start
+ uvalue
> end
1753 /* PR 17531: file: 5b5f0592. */
1754 || data
< block_start
)
1756 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1757 uvalue
= end
- block_start
;
1760 data
= block_start
+ uvalue
;
1762 data
= display_block (block_start
, uvalue
, end
);
1767 printf (_(" (indirect string, offset: 0x%s): %s"),
1768 dwarf_vmatoa ("x", uvalue
),
1769 fetch_indirect_string (uvalue
));
1772 case DW_FORM_GNU_str_index
:
1775 const char *suffix
= strrchr (section
->name
, '.');
1776 int dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? 1 : 0;
1778 printf (_(" (indexed string: 0x%s): %s"),
1779 dwarf_vmatoa ("x", uvalue
),
1780 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
1784 case DW_FORM_GNU_strp_alt
:
1786 printf (_(" (alt indirect string, offset: 0x%s)"),
1787 dwarf_vmatoa ("x", uvalue
));
1790 case DW_FORM_indirect
:
1791 /* Handled above. */
1794 case DW_FORM_ref_sig8
:
1797 dwarf_vma high_bits
;
1800 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
1801 printf (" signature: 0x%s",
1802 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
1807 case DW_FORM_GNU_addr_index
:
1809 printf (_(" (addr_index: 0x%s): %s"),
1810 dwarf_vmatoa ("x", uvalue
),
1811 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
1815 warn (_("Unrecognized form: %lu\n"), form
);
1819 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
1820 && num_debug_info_entries
== 0
1821 && debug_info_p
!= NULL
)
1825 case DW_AT_frame_base
:
1826 have_frame_base
= 1;
1827 case DW_AT_location
:
1828 case DW_AT_string_length
:
1829 case DW_AT_return_addr
:
1830 case DW_AT_data_member_location
:
1831 case DW_AT_vtable_elem_location
:
1833 case DW_AT_static_link
:
1834 case DW_AT_use_location
:
1835 case DW_AT_GNU_call_site_value
:
1836 case DW_AT_GNU_call_site_data_value
:
1837 case DW_AT_GNU_call_site_target
:
1838 case DW_AT_GNU_call_site_target_clobbered
:
1839 if ((dwarf_version
< 4
1840 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1841 || form
== DW_FORM_sec_offset
)
1843 /* Process location list. */
1844 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
1845 unsigned int num
= debug_info_p
->num_loc_offsets
;
1847 if (lmax
== 0 || num
>= lmax
)
1850 debug_info_p
->loc_offsets
= (dwarf_vma
*)
1851 xcrealloc (debug_info_p
->loc_offsets
,
1852 lmax
, sizeof (*debug_info_p
->loc_offsets
));
1853 debug_info_p
->have_frame_base
= (int *)
1854 xcrealloc (debug_info_p
->have_frame_base
,
1855 lmax
, sizeof (*debug_info_p
->have_frame_base
));
1856 debug_info_p
->max_loc_offsets
= lmax
;
1858 if (this_set
!= NULL
)
1859 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
1860 debug_info_p
->loc_offsets
[num
] = uvalue
;
1861 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
1862 debug_info_p
->num_loc_offsets
++;
1867 if (need_base_address
)
1868 debug_info_p
->base_address
= uvalue
;
1871 case DW_AT_GNU_addr_base
:
1872 debug_info_p
->addr_base
= uvalue
;
1875 case DW_AT_GNU_ranges_base
:
1876 debug_info_p
->ranges_base
= uvalue
;
1880 if ((dwarf_version
< 4
1881 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
1882 || form
== DW_FORM_sec_offset
)
1884 /* Process range list. */
1885 unsigned int lmax
= debug_info_p
->max_range_lists
;
1886 unsigned int num
= debug_info_p
->num_range_lists
;
1888 if (lmax
== 0 || num
>= lmax
)
1891 debug_info_p
->range_lists
= (dwarf_vma
*)
1892 xcrealloc (debug_info_p
->range_lists
,
1893 lmax
, sizeof (*debug_info_p
->range_lists
));
1894 debug_info_p
->max_range_lists
= lmax
;
1896 debug_info_p
->range_lists
[num
] = uvalue
;
1897 debug_info_p
->num_range_lists
++;
1906 if (do_loc
|| attribute
== 0)
1909 /* For some attributes we can display further information. */
1916 case DW_INL_not_inlined
:
1917 printf (_("(not inlined)"));
1919 case DW_INL_inlined
:
1920 printf (_("(inlined)"));
1922 case DW_INL_declared_not_inlined
:
1923 printf (_("(declared as inline but ignored)"));
1925 case DW_INL_declared_inlined
:
1926 printf (_("(declared as inline and inlined)"));
1929 printf (_(" (Unknown inline attribute value: %s)"),
1930 dwarf_vmatoa ("x", uvalue
));
1935 case DW_AT_language
:
1939 /* Ordered by the numeric value of these constants. */
1940 case DW_LANG_C89
: printf ("(ANSI C)"); break;
1941 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
1942 case DW_LANG_Ada83
: printf ("(Ada)"); break;
1943 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
1944 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
1945 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
1946 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
1947 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
1948 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
1949 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
1950 /* DWARF 2.1 values. */
1951 case DW_LANG_Java
: printf ("(Java)"); break;
1952 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
1953 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
1954 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
1955 /* DWARF 3 values. */
1956 case DW_LANG_PLI
: printf ("(PLI)"); break;
1957 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
1958 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
1959 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
1960 case DW_LANG_D
: printf ("(D)"); break;
1961 /* DWARF 4 values. */
1962 case DW_LANG_Python
: printf ("(Python)"); break;
1963 /* DWARF 5 values. */
1964 case DW_LANG_Go
: printf ("(Go)"); break;
1965 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
1966 case DW_LANG_C11
: printf ("(C11)"); break;
1967 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
1968 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
1969 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
1970 /* MIPS extension. */
1971 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
1972 /* UPC extension. */
1973 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
1975 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
1976 printf (_("(implementation defined: %s)"),
1977 dwarf_vmatoa ("x", uvalue
));
1979 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
1984 case DW_AT_encoding
:
1988 case DW_ATE_void
: printf ("(void)"); break;
1989 case DW_ATE_address
: printf ("(machine address)"); break;
1990 case DW_ATE_boolean
: printf ("(boolean)"); break;
1991 case DW_ATE_complex_float
: printf ("(complex float)"); break;
1992 case DW_ATE_float
: printf ("(float)"); break;
1993 case DW_ATE_signed
: printf ("(signed)"); break;
1994 case DW_ATE_signed_char
: printf ("(signed char)"); break;
1995 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
1996 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
1997 /* DWARF 2.1 values: */
1998 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
1999 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
2000 /* DWARF 3 values: */
2001 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
2002 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
2003 case DW_ATE_edited
: printf ("(edited)"); break;
2004 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
2005 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
2006 /* HP extensions: */
2007 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
2008 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
2009 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
2010 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
2011 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
2012 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
2013 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
2014 /* DWARF 4 values: */
2015 case DW_ATE_UTF
: printf ("(unicode string)"); break;
2018 if (uvalue
>= DW_ATE_lo_user
2019 && uvalue
<= DW_ATE_hi_user
)
2020 printf (_("(user defined type)"));
2022 printf (_("(unknown type)"));
2027 case DW_AT_accessibility
:
2031 case DW_ACCESS_public
: printf ("(public)"); break;
2032 case DW_ACCESS_protected
: printf ("(protected)"); break;
2033 case DW_ACCESS_private
: printf ("(private)"); break;
2035 printf (_("(unknown accessibility)"));
2040 case DW_AT_visibility
:
2044 case DW_VIS_local
: printf ("(local)"); break;
2045 case DW_VIS_exported
: printf ("(exported)"); break;
2046 case DW_VIS_qualified
: printf ("(qualified)"); break;
2047 default: printf (_("(unknown visibility)")); break;
2051 case DW_AT_virtuality
:
2055 case DW_VIRTUALITY_none
: printf ("(none)"); break;
2056 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
2057 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
2058 default: printf (_("(unknown virtuality)")); break;
2062 case DW_AT_identifier_case
:
2066 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
2067 case DW_ID_up_case
: printf ("(up_case)"); break;
2068 case DW_ID_down_case
: printf ("(down_case)"); break;
2069 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
2070 default: printf (_("(unknown case)")); break;
2074 case DW_AT_calling_convention
:
2078 case DW_CC_normal
: printf ("(normal)"); break;
2079 case DW_CC_program
: printf ("(program)"); break;
2080 case DW_CC_nocall
: printf ("(nocall)"); break;
2082 if (uvalue
>= DW_CC_lo_user
2083 && uvalue
<= DW_CC_hi_user
)
2084 printf (_("(user defined)"));
2086 printf (_("(unknown convention)"));
2090 case DW_AT_ordering
:
2094 case -1: printf (_("(undefined)")); break;
2095 case 0: printf ("(row major)"); break;
2096 case 1: printf ("(column major)"); break;
2100 case DW_AT_frame_base
:
2101 have_frame_base
= 1;
2102 case DW_AT_location
:
2103 case DW_AT_string_length
:
2104 case DW_AT_return_addr
:
2105 case DW_AT_data_member_location
:
2106 case DW_AT_vtable_elem_location
:
2108 case DW_AT_static_link
:
2109 case DW_AT_use_location
:
2110 case DW_AT_GNU_call_site_value
:
2111 case DW_AT_GNU_call_site_data_value
:
2112 case DW_AT_GNU_call_site_target
:
2113 case DW_AT_GNU_call_site_target_clobbered
:
2114 if ((dwarf_version
< 4
2115 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2116 || form
== DW_FORM_sec_offset
)
2117 printf (_(" (location list)"));
2119 case DW_AT_allocated
:
2120 case DW_AT_associated
:
2121 case DW_AT_data_location
:
2123 case DW_AT_upper_bound
:
2124 case DW_AT_lower_bound
:
2127 int need_frame_base
;
2130 need_frame_base
= decode_location_expression (block_start
,
2135 cu_offset
, section
);
2137 if (need_frame_base
&& !have_frame_base
)
2138 printf (_(" [without DW_AT_frame_base]"));
2144 if (form
== DW_FORM_ref_sig8
2145 || form
== DW_FORM_GNU_ref_alt
)
2148 if (form
== DW_FORM_ref1
2149 || form
== DW_FORM_ref2
2150 || form
== DW_FORM_ref4
2151 || form
== DW_FORM_ref_udata
)
2152 uvalue
+= cu_offset
;
2154 if (uvalue
>= section
->size
)
2155 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
2156 dwarf_vmatoa ("x", uvalue
),
2157 (unsigned long) (orig_data
- section
->start
));
2160 unsigned long abbrev_number
;
2161 abbrev_entry
* entry
;
2163 abbrev_number
= read_uleb128 (section
->start
+ uvalue
, NULL
, end
);
2165 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
2166 /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
2167 use different abbrev table, and we don't track .debug_info chunks
2169 if (form
!= DW_FORM_ref_addr
)
2171 for (entry
= first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2172 if (entry
->entry
== abbrev_number
)
2175 printf (" (%s)", get_TAG_name (entry
->tag
));
2190 get_AT_name (unsigned long attribute
)
2195 return "DW_AT value: 0";
2197 /* One value is shared by the MIPS and HP extensions: */
2198 if (attribute
== DW_AT_MIPS_fde
)
2199 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
2201 name
= get_DW_AT_name (attribute
);
2205 static char buffer
[100];
2207 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
2215 static unsigned char *
2216 read_and_display_attr (unsigned long attribute
,
2218 unsigned char * data
,
2219 unsigned char * end
,
2220 dwarf_vma cu_offset
,
2221 dwarf_vma pointer_size
,
2222 dwarf_vma offset_size
,
2224 debug_info
* debug_info_p
,
2226 struct dwarf_section
* section
,
2227 struct cu_tu_set
* this_set
)
2230 printf (" %-18s:", get_AT_name (attribute
));
2231 data
= read_and_display_attr_value (attribute
, form
, data
, end
,
2232 cu_offset
, pointer_size
, offset_size
,
2233 dwarf_version
, debug_info_p
,
2234 do_loc
, section
, this_set
);
2240 /* Process the contents of a .debug_info section. If do_loc is non-zero
2241 then we are scanning for location lists and we do not want to display
2242 anything to the user. If do_types is non-zero, we are processing
2243 a .debug_types section instead of a .debug_info section. */
2246 process_debug_info (struct dwarf_section
*section
,
2248 enum dwarf_section_display_enum abbrev_sec
,
2252 unsigned char *start
= section
->start
;
2253 unsigned char *end
= start
+ section
->size
;
2254 unsigned char *section_begin
;
2256 unsigned int num_units
= 0;
2258 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2259 && num_debug_info_entries
== 0
2264 /* First scan the section to get the number of comp units. */
2265 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
2268 /* Read the first 4 bytes. For a 32-bit DWARF section, this
2269 will be the length. For a 64-bit DWARF section, it'll be
2270 the escape code 0xffffffff followed by an 8 byte length. */
2271 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
2273 if (length
== 0xffffffff)
2275 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
2276 section_begin
+= length
+ 12;
2278 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
2280 warn (_("Reserved length value (0x%s) found in section %s\n"),
2281 dwarf_vmatoa ("x", length
), section
->name
);
2285 section_begin
+= length
+ 4;
2287 /* Negative values are illegal, they may even cause infinite
2288 looping. This can happen if we can't accurately apply
2289 relocations to an object file, or if the file is corrupt. */
2290 if ((signed long) length
<= 0 || section_begin
< start
)
2292 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
2293 dwarf_vmatoa ("x", length
), section
->name
);
2300 error (_("No comp units in %s section ?\n"), section
->name
);
2304 /* Then allocate an array to hold the information. */
2305 debug_information
= (debug_info
*) cmalloc (num_units
,
2306 sizeof (* debug_information
));
2307 if (debug_information
== NULL
)
2309 error (_("Not enough memory for a debug info array of %u entries\n"),
2311 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
2314 /* PR 17531: file: 92ca3797.
2315 We cannot rely upon the debug_information array being initialised
2316 before it is used. A corrupt file could easily contain references
2317 to a unit for which information has not been made available. So
2318 we ensure that the array is zeroed here. */
2319 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
2321 alloc_num_debug_info_entries
= num_units
;
2326 if (dwarf_start_die
== 0)
2327 printf (_("Contents of the %s section:\n\n"), section
->name
);
2329 load_debug_section (str
, file
);
2330 load_debug_section (str_dwo
, file
);
2331 load_debug_section (str_index
, file
);
2332 load_debug_section (str_index_dwo
, file
);
2333 load_debug_section (debug_addr
, file
);
2336 load_debug_section (abbrev_sec
, file
);
2337 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
2339 warn (_("Unable to locate %s section!\n"),
2340 debug_displays
[abbrev_sec
].section
.name
);
2344 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
2346 DWARF2_Internal_CompUnit compunit
;
2347 unsigned char *hdrptr
;
2348 unsigned char *tags
;
2349 int level
, last_level
, saved_level
;
2350 dwarf_vma cu_offset
;
2351 unsigned int offset_size
;
2352 int initial_length_size
;
2353 dwarf_vma signature_high
= 0;
2354 dwarf_vma signature_low
= 0;
2355 dwarf_vma type_offset
= 0;
2356 struct cu_tu_set
*this_set
;
2357 dwarf_vma abbrev_base
;
2362 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
2364 if (compunit
.cu_length
== 0xffffffff)
2366 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
2368 initial_length_size
= 12;
2373 initial_length_size
= 4;
2376 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
2378 cu_offset
= start
- section_begin
;
2380 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
2382 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
2384 if (this_set
== NULL
)
2387 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
2391 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
2392 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
2395 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
2396 /* PR 17512: file: 001-108546-0.001:0.1. */
2397 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
2399 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
2400 compunit
.cu_pointer_size
, offset_size
);
2401 compunit
.cu_pointer_size
= offset_size
;
2406 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
2408 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
2411 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2412 && num_debug_info_entries
== 0
2415 debug_information
[unit
].cu_offset
= cu_offset
;
2416 debug_information
[unit
].pointer_size
2417 = compunit
.cu_pointer_size
;
2418 debug_information
[unit
].offset_size
= offset_size
;
2419 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
2420 debug_information
[unit
].base_address
= 0;
2421 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
2422 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
2423 debug_information
[unit
].loc_offsets
= NULL
;
2424 debug_information
[unit
].have_frame_base
= NULL
;
2425 debug_information
[unit
].max_loc_offsets
= 0;
2426 debug_information
[unit
].num_loc_offsets
= 0;
2427 debug_information
[unit
].range_lists
= NULL
;
2428 debug_information
[unit
].max_range_lists
= 0;
2429 debug_information
[unit
].num_range_lists
= 0;
2432 if (!do_loc
&& dwarf_start_die
== 0)
2434 printf (_(" Compilation Unit @ offset 0x%s:\n"),
2435 dwarf_vmatoa ("x", cu_offset
));
2436 printf (_(" Length: 0x%s (%s)\n"),
2437 dwarf_vmatoa ("x", compunit
.cu_length
),
2438 offset_size
== 8 ? "64-bit" : "32-bit");
2439 printf (_(" Version: %d\n"), compunit
.cu_version
);
2440 printf (_(" Abbrev Offset: 0x%s\n"),
2441 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
2442 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
2447 printf (_(" Signature: 0x%s\n"),
2448 dwarf_vmatoa64 (signature_high
, signature_low
,
2449 buf
, sizeof (buf
)));
2450 printf (_(" Type Offset: 0x%s\n"),
2451 dwarf_vmatoa ("x", type_offset
));
2453 if (this_set
!= NULL
)
2455 dwarf_vma
*offsets
= this_set
->section_offsets
;
2456 size_t *sizes
= this_set
->section_sizes
;
2458 printf (_(" Section contributions:\n"));
2459 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
2460 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
2461 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
2462 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
2463 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
2464 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
2465 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
2466 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
2467 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
2468 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
2469 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
2470 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
2474 if (cu_offset
+ compunit
.cu_length
+ initial_length_size
2477 warn (_("Debug info is corrupted, length of CU at %s"
2478 " extends beyond end of section (length = %s)\n"),
2479 dwarf_vmatoa ("x", cu_offset
),
2480 dwarf_vmatoa ("x", compunit
.cu_length
));
2485 start
+= compunit
.cu_length
+ initial_length_size
;
2489 warn (_("Debug info is corrupt. CU at %s extends beyond end of section"),
2490 dwarf_vmatoa ("x", cu_offset
));
2494 if (compunit
.cu_version
!= 2
2495 && compunit
.cu_version
!= 3
2496 && compunit
.cu_version
!= 4)
2498 warn (_("CU at offset %s contains corrupt or "
2499 "unsupported version number: %d.\n"),
2500 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
2506 /* Process the abbrevs used by this compilation unit. */
2507 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
2508 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
2509 (unsigned long) compunit
.cu_abbrev_offset
,
2510 (unsigned long) abbrev_size
);
2511 /* PR 17531: file:4bcd9ce9. */
2512 else if ((abbrev_base
+ abbrev_size
)
2513 > debug_displays
[abbrev_sec
].section
.size
)
2514 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
2515 (unsigned long) abbrev_base
+ abbrev_size
,
2516 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
2518 process_abbrev_section
2519 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2520 + abbrev_base
+ compunit
.cu_abbrev_offset
),
2521 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
2522 + abbrev_base
+ abbrev_size
));
2527 while (tags
< start
)
2529 unsigned int bytes_read
;
2530 unsigned long abbrev_number
;
2531 unsigned long die_offset
;
2532 abbrev_entry
*entry
;
2534 int do_printing
= 1;
2536 die_offset
= tags
- section_begin
;
2538 abbrev_number
= read_uleb128 (tags
, & bytes_read
, start
);
2541 /* A null DIE marks the end of a list of siblings or it may also be
2542 a section padding. */
2543 if (abbrev_number
== 0)
2545 /* Check if it can be a section padding for the last CU. */
2546 if (level
== 0 && start
== end
)
2550 for (chk
= tags
; chk
< start
; chk
++)
2557 if (!do_loc
&& die_offset
>= dwarf_start_die
2558 && (dwarf_cutoff_level
== -1
2559 || level
< dwarf_cutoff_level
))
2560 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
2566 static unsigned num_bogus_warns
= 0;
2568 if (num_bogus_warns
< 3)
2570 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
2571 die_offset
, section
->name
);
2573 if (num_bogus_warns
== 3)
2574 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
2577 if (dwarf_start_die
!= 0 && level
< saved_level
)
2584 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
2588 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
2589 saved_level
= level
;
2590 do_printing
= (dwarf_cutoff_level
== -1
2591 || level
< dwarf_cutoff_level
);
2593 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
2594 level
, die_offset
, abbrev_number
);
2595 else if (dwarf_cutoff_level
== -1
2596 || last_level
< dwarf_cutoff_level
)
2597 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
2602 /* Scan through the abbreviation list until we reach the
2604 for (entry
= first_abbrev
;
2605 entry
&& entry
->entry
!= abbrev_number
;
2606 entry
= entry
->next
)
2611 if (!do_loc
&& do_printing
)
2616 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
2617 die_offset
, abbrev_number
);
2621 if (!do_loc
&& do_printing
)
2622 printf (" (%s)\n", get_TAG_name (entry
->tag
));
2627 need_base_address
= 0;
2629 case DW_TAG_compile_unit
:
2630 need_base_address
= 1;
2632 case DW_TAG_entry_point
:
2633 case DW_TAG_subprogram
:
2634 need_base_address
= 0;
2635 /* Assuming that there is no DW_AT_frame_base. */
2636 have_frame_base
= 0;
2640 for (attr
= entry
->first_attr
;
2641 attr
&& attr
->attribute
;
2646 if (! do_loc
&& do_printing
)
2647 /* Show the offset from where the tag was extracted. */
2648 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
2650 if (debug_information
&& unit
< alloc_num_debug_info_entries
)
2651 arg
= debug_information
+ unit
;
2655 tags
= read_and_display_attr (attr
->attribute
,
2660 compunit
.cu_pointer_size
,
2662 compunit
.cu_version
,
2664 do_loc
|| ! do_printing
,
2669 if (entry
->children
)
2674 /* Set num_debug_info_entries here so that it can be used to check if
2675 we need to process .debug_loc and .debug_ranges sections. */
2676 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2677 && num_debug_info_entries
== 0
2680 if (num_units
> alloc_num_debug_info_entries
)
2681 num_debug_info_entries
= alloc_num_debug_info_entries
;
2683 num_debug_info_entries
= num_units
;
2692 /* Locate and scan the .debug_info section in the file and record the pointer
2693 sizes and offsets for the compilation units in it. Usually an executable
2694 will have just one pointer size, but this is not guaranteed, and so we try
2695 not to make any assumptions. Returns zero upon failure, or the number of
2696 compilation units upon success. */
2699 load_debug_info (void * file
)
2701 /* Reset the last pointer size so that we can issue correct error
2702 messages if we are displaying the contents of more than one section. */
2703 last_pointer_size
= 0;
2704 warned_about_missing_comp_units
= FALSE
;
2706 /* If we have already tried and failed to load the .debug_info
2707 section then do not bother to repeat the task. */
2708 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
2711 /* If we already have the information there is nothing else to do. */
2712 if (num_debug_info_entries
> 0)
2713 return num_debug_info_entries
;
2715 /* If this is a DWARF package file, load the CU and TU indexes. */
2716 load_cu_tu_indexes (file
);
2718 if (load_debug_section (info
, file
)
2719 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, 1, 0))
2720 return num_debug_info_entries
;
2722 if (load_debug_section (info_dwo
, file
)
2723 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
2725 return num_debug_info_entries
;
2727 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
2731 /* Read a DWARF .debug_line section header starting at DATA.
2732 Upon success returns an updated DATA pointer and the LINFO
2733 structure and the END_OF_SEQUENCE pointer will be filled in.
2734 Otherwise returns NULL. */
2736 static unsigned char *
2737 read_debug_line_header (struct dwarf_section
* section
,
2738 unsigned char * data
,
2739 unsigned char * end
,
2740 DWARF2_Internal_LineInfo
* linfo
,
2741 unsigned char ** end_of_sequence
)
2743 unsigned char *hdrptr
;
2744 unsigned int offset_size
;
2745 unsigned int initial_length_size
;
2747 /* Extract information from the Line Number Program Header.
2748 (section 6.2.4 in the Dwarf3 doc). */
2751 /* Get and check the length of the block. */
2752 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
2754 if (linfo
->li_length
== 0xffffffff)
2756 /* This section is 64-bit DWARF 3. */
2757 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
2759 initial_length_size
= 12;
2764 initial_length_size
= 4;
2767 if (linfo
->li_length
+ initial_length_size
> section
->size
)
2769 /* If the length field has a relocation against it, then we should
2770 not complain if it is inaccurate (and probably negative). This
2771 happens in object files when the .debug_line section is actually
2772 comprised of several different .debug_line.* sections, (some of
2773 which may be removed by linker garbage collection), and a relocation
2774 is used to compute the correct length once that is done. */
2775 if (reloc_at (section
, (hdrptr
- section
->start
) - offset_size
))
2777 linfo
->li_length
= (end
- data
) - initial_length_size
;
2781 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
2782 (long) linfo
->li_length
);
2787 /* Get and check the version number. */
2788 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
2790 if (linfo
->li_version
!= 2
2791 && linfo
->li_version
!= 3
2792 && linfo
->li_version
!= 4)
2794 warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n"));
2798 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
, offset_size
, end
);
2799 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
2801 if (linfo
->li_version
>= 4)
2803 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
2805 if (linfo
->li_max_ops_per_insn
== 0)
2807 warn (_("Invalid maximum operations per insn.\n"));
2812 linfo
->li_max_ops_per_insn
= 1;
2814 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
2815 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
2816 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
2817 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
2819 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
2820 /* PR 17512: file:002-117414-0.004. */
2821 if (* end_of_sequence
> end
)
2823 warn (_("Line length %s extends beyond end of section\n"),
2824 dwarf_vmatoa ("u", linfo
->li_length
));
2825 * end_of_sequence
= end
;
2833 display_debug_lines_raw (struct dwarf_section
*section
,
2834 unsigned char *data
,
2837 unsigned char *start
= section
->start
;
2839 printf (_("Raw dump of debug contents of section %s:\n\n"),
2844 static DWARF2_Internal_LineInfo saved_linfo
;
2845 DWARF2_Internal_LineInfo linfo
;
2846 unsigned char *standard_opcodes
;
2847 unsigned char *end_of_sequence
;
2848 unsigned int last_dir_entry
= 0;
2851 if (const_strneq (section
->name
, ".debug_line.")
2852 /* Note: the following does not apply to .debug_line.dwo sections.
2853 These are full debug_line sections. */
2854 && strcmp (section
->name
, ".debug_line.dwo") != 0)
2856 /* Sections named .debug_line.<foo> are fragments of a .debug_line
2857 section containing just the Line Number Statements. They are
2858 created by the assembler and intended to be used alongside gcc's
2859 -ffunction-sections command line option. When the linker's
2860 garbage collection decides to discard a .text.<foo> section it
2861 can then also discard the line number information in .debug_line.<foo>.
2863 Since the section is a fragment it does not have the details
2864 needed to fill out a LineInfo structure, so instead we use the
2865 details from the last full debug_line section that we processed. */
2866 end_of_sequence
= end
;
2867 standard_opcodes
= NULL
;
2868 linfo
= saved_linfo
;
2869 /* PR 17531: file: 0522b371. */
2870 if (linfo
.li_line_range
== 0)
2872 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
2875 reset_state_machine (linfo
.li_default_is_stmt
);
2879 unsigned char * hdrptr
;
2881 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
2882 & end_of_sequence
)) == NULL
)
2885 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
2886 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
2887 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
2888 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
2889 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
2890 if (linfo
.li_version
>= 4)
2891 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
2892 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
2893 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
2894 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
2895 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
2897 /* PR 17512: file: 1665-6428-0.004. */
2898 if (linfo
.li_line_range
== 0)
2900 warn (_("Line range of 0 is invalid, using 1 instead\n"));
2901 linfo
.li_line_range
= 1;
2904 reset_state_machine (linfo
.li_default_is_stmt
);
2906 /* Display the contents of the Opcodes table. */
2907 standard_opcodes
= hdrptr
;
2909 /* PR 17512: file: 002-417945-0.004. */
2910 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
2912 warn (_("Line Base extends beyond end of section\n"));
2916 printf (_("\n Opcodes:\n"));
2918 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
2919 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
2921 /* Display the contents of the Directory table. */
2922 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
2925 printf (_("\n The Directory Table is empty.\n"));
2928 printf (_("\n The Directory Table (offset 0x%lx):\n"),
2929 (long)(data
- start
));
2931 while (data
< end
&& *data
!= 0)
2933 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
2935 data
+= strnlen ((char *) data
, end
- data
) + 1;
2938 /* PR 17512: file: 002-132094-0.004. */
2939 if (data
>= end
- 1)
2943 /* Skip the NUL at the end of the table. */
2946 /* Display the contents of the File Name table. */
2948 printf (_("\n The File Name Table is empty.\n"));
2951 printf (_("\n The File Name Table (offset 0x%lx):\n"),
2952 (long)(data
- start
));
2953 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
2955 while (data
< end
&& *data
!= 0)
2957 unsigned char *name
;
2958 unsigned int bytes_read
;
2960 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
2962 data
+= strnlen ((char *) data
, end
- data
) + 1;
2965 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2968 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2971 dwarf_vmatoa ("u", read_uleb128 (data
, & bytes_read
, end
)));
2973 printf ("%.*s\n", (int)(end
- name
), name
);
2977 warn (_("Corrupt file name table entry\n"));
2983 /* Skip the NUL at the end of the table. */
2986 saved_linfo
= linfo
;
2989 /* Now display the statements. */
2990 if (data
>= end_of_sequence
)
2991 printf (_(" No Line Number Statements.\n"));
2994 printf (_(" Line Number Statements:\n"));
2996 while (data
< end_of_sequence
)
2998 unsigned char op_code
;
2999 dwarf_signed_vma adv
;
3001 unsigned int bytes_read
;
3003 printf (" [0x%08lx]", (long)(data
- start
));
3007 if (op_code
>= linfo
.li_opcode_base
)
3009 op_code
-= linfo
.li_opcode_base
;
3010 uladv
= (op_code
/ linfo
.li_line_range
);
3011 if (linfo
.li_max_ops_per_insn
== 1)
3013 uladv
*= linfo
.li_min_insn_length
;
3014 state_machine_regs
.address
+= uladv
;
3015 printf (_(" Special opcode %d: "
3016 "advance Address by %s to 0x%s"),
3017 op_code
, dwarf_vmatoa ("u", uladv
),
3018 dwarf_vmatoa ("x", state_machine_regs
.address
));
3022 state_machine_regs
.address
3023 += ((state_machine_regs
.op_index
+ uladv
)
3024 / linfo
.li_max_ops_per_insn
)
3025 * linfo
.li_min_insn_length
;
3026 state_machine_regs
.op_index
3027 = (state_machine_regs
.op_index
+ uladv
)
3028 % linfo
.li_max_ops_per_insn
;
3029 printf (_(" Special opcode %d: "
3030 "advance Address by %s to 0x%s[%d]"),
3031 op_code
, dwarf_vmatoa ("u", uladv
),
3032 dwarf_vmatoa ("x", state_machine_regs
.address
),
3033 state_machine_regs
.op_index
);
3035 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3036 state_machine_regs
.line
+= adv
;
3037 printf (_(" and Line by %s to %d\n"),
3038 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
3040 else switch (op_code
)
3042 case DW_LNS_extended_op
:
3043 data
+= process_extended_line_op (data
, linfo
.li_default_is_stmt
, end
);
3047 printf (_(" Copy\n"));
3050 case DW_LNS_advance_pc
:
3051 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3053 if (linfo
.li_max_ops_per_insn
== 1)
3055 uladv
*= linfo
.li_min_insn_length
;
3056 state_machine_regs
.address
+= uladv
;
3057 printf (_(" Advance PC by %s to 0x%s\n"),
3058 dwarf_vmatoa ("u", uladv
),
3059 dwarf_vmatoa ("x", state_machine_regs
.address
));
3063 state_machine_regs
.address
3064 += ((state_machine_regs
.op_index
+ uladv
)
3065 / linfo
.li_max_ops_per_insn
)
3066 * linfo
.li_min_insn_length
;
3067 state_machine_regs
.op_index
3068 = (state_machine_regs
.op_index
+ uladv
)
3069 % linfo
.li_max_ops_per_insn
;
3070 printf (_(" Advance PC by %s to 0x%s[%d]\n"),
3071 dwarf_vmatoa ("u", uladv
),
3072 dwarf_vmatoa ("x", state_machine_regs
.address
),
3073 state_machine_regs
.op_index
);
3077 case DW_LNS_advance_line
:
3078 adv
= read_sleb128 (data
, & bytes_read
, end
);
3080 state_machine_regs
.line
+= adv
;
3081 printf (_(" Advance Line by %s to %d\n"),
3082 dwarf_vmatoa ("d", adv
),
3083 state_machine_regs
.line
);
3086 case DW_LNS_set_file
:
3087 adv
= read_uleb128 (data
, & bytes_read
, end
);
3089 printf (_(" Set File Name to entry %s in the File Name Table\n"),
3090 dwarf_vmatoa ("d", adv
));
3091 state_machine_regs
.file
= adv
;
3094 case DW_LNS_set_column
:
3095 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3097 printf (_(" Set column to %s\n"),
3098 dwarf_vmatoa ("u", uladv
));
3099 state_machine_regs
.column
= uladv
;
3102 case DW_LNS_negate_stmt
:
3103 adv
= state_machine_regs
.is_stmt
;
3105 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
3106 state_machine_regs
.is_stmt
= adv
;
3109 case DW_LNS_set_basic_block
:
3110 printf (_(" Set basic block\n"));
3111 state_machine_regs
.basic_block
= 1;
3114 case DW_LNS_const_add_pc
:
3115 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3116 if (linfo
.li_max_ops_per_insn
)
3118 uladv
*= linfo
.li_min_insn_length
;
3119 state_machine_regs
.address
+= uladv
;
3120 printf (_(" Advance PC by constant %s to 0x%s\n"),
3121 dwarf_vmatoa ("u", uladv
),
3122 dwarf_vmatoa ("x", state_machine_regs
.address
));
3126 state_machine_regs
.address
3127 += ((state_machine_regs
.op_index
+ uladv
)
3128 / linfo
.li_max_ops_per_insn
)
3129 * linfo
.li_min_insn_length
;
3130 state_machine_regs
.op_index
3131 = (state_machine_regs
.op_index
+ uladv
)
3132 % linfo
.li_max_ops_per_insn
;
3133 printf (_(" Advance PC by constant %s to 0x%s[%d]\n"),
3134 dwarf_vmatoa ("u", uladv
),
3135 dwarf_vmatoa ("x", state_machine_regs
.address
),
3136 state_machine_regs
.op_index
);
3140 case DW_LNS_fixed_advance_pc
:
3141 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3142 state_machine_regs
.address
+= uladv
;
3143 state_machine_regs
.op_index
= 0;
3144 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
3145 dwarf_vmatoa ("u", uladv
),
3146 dwarf_vmatoa ("x", state_machine_regs
.address
));
3149 case DW_LNS_set_prologue_end
:
3150 printf (_(" Set prologue_end to true\n"));
3153 case DW_LNS_set_epilogue_begin
:
3154 printf (_(" Set epilogue_begin to true\n"));
3157 case DW_LNS_set_isa
:
3158 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3160 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
3164 printf (_(" Unknown opcode %d with operands: "), op_code
);
3166 if (standard_opcodes
!= NULL
)
3167 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3169 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3171 i
== 1 ? "" : ", ");
3187 unsigned char *name
;
3188 unsigned int directory_index
;
3189 unsigned int modification_date
;
3190 unsigned int length
;
3193 /* Output a decoded representation of the .debug_line section. */
3196 display_debug_lines_decoded (struct dwarf_section
*section
,
3197 unsigned char *data
,
3200 static DWARF2_Internal_LineInfo saved_linfo
;
3202 printf (_("Decoded dump of debug contents of section %s:\n\n"),
3207 /* This loop amounts to one iteration per compilation unit. */
3208 DWARF2_Internal_LineInfo linfo
;
3209 unsigned char *standard_opcodes
;
3210 unsigned char *end_of_sequence
;
3212 File_Entry
*file_table
= NULL
;
3213 unsigned int n_files
= 0;
3214 unsigned char **directory_table
= NULL
;
3215 unsigned int n_directories
= 0;
3217 if (const_strneq (section
->name
, ".debug_line.")
3218 /* Note: the following does not apply to .debug_line.dwo sections.
3219 These are full debug_line sections. */
3220 && strcmp (section
->name
, ".debug_line.dwo") != 0)
3222 /* See comment in display_debug_lines_raw(). */
3223 end_of_sequence
= end
;
3224 standard_opcodes
= NULL
;
3225 linfo
= saved_linfo
;
3226 /* PR 17531: file: 0522b371. */
3227 if (linfo
.li_line_range
== 0)
3229 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
3232 reset_state_machine (linfo
.li_default_is_stmt
);
3236 unsigned char *hdrptr
;
3238 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
3239 & end_of_sequence
)) == NULL
)
3242 /* PR 17531: file: 0522b371. */
3243 if (linfo
.li_line_range
== 0)
3245 warn (_("Line range of 0 is invalid, using 1 instead\n"));
3246 linfo
.li_line_range
= 1;
3248 reset_state_machine (linfo
.li_default_is_stmt
);
3250 /* Save a pointer to the contents of the Opcodes table. */
3251 standard_opcodes
= hdrptr
;
3253 /* Traverse the Directory table just to count entries. */
3254 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
3257 unsigned char *ptr_directory_table
= data
;
3261 data
+= strnlen ((char *) data
, end
- data
) + 1;
3265 /* Go through the directory table again to save the directories. */
3266 directory_table
= (unsigned char **)
3267 xmalloc (n_directories
* sizeof (unsigned char *));
3270 while (*ptr_directory_table
!= 0)
3272 directory_table
[i
] = ptr_directory_table
;
3273 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
3274 ptr_directory_table
- end
) + 1;
3278 /* Skip the NUL at the end of the table. */
3281 /* Traverse the File Name table just to count the entries. */
3284 unsigned char *ptr_file_name_table
= data
;
3288 unsigned int bytes_read
;
3290 /* Skip Name, directory index, last modification time and length
3292 data
+= strnlen ((char *) data
, end
- data
) + 1;
3293 read_uleb128 (data
, & bytes_read
, end
);
3295 read_uleb128 (data
, & bytes_read
, end
);
3297 read_uleb128 (data
, & bytes_read
, end
);
3303 /* Go through the file table again to save the strings. */
3304 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
3307 while (*ptr_file_name_table
!= 0)
3309 unsigned int bytes_read
;
3311 file_table
[i
].name
= ptr_file_name_table
;
3312 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
3313 end
- ptr_file_name_table
) + 1;
3315 /* We are not interested in directory, time or size. */
3316 file_table
[i
].directory_index
= read_uleb128 (ptr_file_name_table
,
3318 ptr_file_name_table
+= bytes_read
;
3319 file_table
[i
].modification_date
= read_uleb128 (ptr_file_name_table
,
3321 ptr_file_name_table
+= bytes_read
;
3322 file_table
[i
].length
= read_uleb128 (ptr_file_name_table
, & bytes_read
, end
);
3323 ptr_file_name_table
+= bytes_read
;
3328 /* Print the Compilation Unit's name and a header. */
3329 if (directory_table
== NULL
)
3331 printf (_("CU: %s:\n"), file_table
[0].name
);
3332 printf (_("File name Line number Starting address\n"));
3336 unsigned int ix
= file_table
[0].directory_index
;
3337 const char *directory
= ix
? (char *)directory_table
[ix
- 1] : ".";
3339 if (do_wide
|| strlen (directory
) < 76)
3340 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
3342 printf ("%s:\n", file_table
[0].name
);
3344 printf (_("File name Line number Starting address\n"));
3348 /* Skip the NUL at the end of the table. */
3351 saved_linfo
= linfo
;
3354 /* This loop iterates through the Dwarf Line Number Program. */
3355 while (data
< end_of_sequence
)
3357 unsigned char op_code
;
3359 unsigned long int uladv
;
3360 unsigned int bytes_read
;
3361 int is_special_opcode
= 0;
3365 if (op_code
>= linfo
.li_opcode_base
)
3367 op_code
-= linfo
.li_opcode_base
;
3368 uladv
= (op_code
/ linfo
.li_line_range
);
3369 if (linfo
.li_max_ops_per_insn
== 1)
3371 uladv
*= linfo
.li_min_insn_length
;
3372 state_machine_regs
.address
+= uladv
;
3376 state_machine_regs
.address
3377 += ((state_machine_regs
.op_index
+ uladv
)
3378 / linfo
.li_max_ops_per_insn
)
3379 * linfo
.li_min_insn_length
;
3380 state_machine_regs
.op_index
3381 = (state_machine_regs
.op_index
+ uladv
)
3382 % linfo
.li_max_ops_per_insn
;
3385 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
3386 state_machine_regs
.line
+= adv
;
3387 is_special_opcode
= 1;
3389 else switch (op_code
)
3391 case DW_LNS_extended_op
:
3393 unsigned int ext_op_code_len
;
3394 unsigned char ext_op_code
;
3395 unsigned char *op_code_data
= data
;
3397 ext_op_code_len
= read_uleb128 (op_code_data
, &bytes_read
,
3399 op_code_data
+= bytes_read
;
3401 if (ext_op_code_len
== 0)
3403 warn (_("Badly formed extended line op encountered!\n"));
3406 ext_op_code_len
+= bytes_read
;
3407 ext_op_code
= *op_code_data
++;
3409 switch (ext_op_code
)
3411 case DW_LNE_end_sequence
:
3412 reset_state_machine (linfo
.li_default_is_stmt
);
3414 case DW_LNE_set_address
:
3415 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
3417 ext_op_code_len
- bytes_read
- 1,
3419 state_machine_regs
.op_index
= 0;
3421 case DW_LNE_define_file
:
3423 file_table
= (File_Entry
*) xrealloc
3424 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
3426 ++state_machine_regs
.last_file_entry
;
3427 /* Source file name. */
3428 file_table
[n_files
].name
= op_code_data
;
3429 op_code_data
+= strlen ((char *) op_code_data
) + 1;
3430 /* Directory index. */
3431 file_table
[n_files
].directory_index
=
3432 read_uleb128 (op_code_data
, & bytes_read
,
3434 op_code_data
+= bytes_read
;
3435 /* Last modification time. */
3436 file_table
[n_files
].modification_date
=
3437 read_uleb128 (op_code_data
, & bytes_read
,
3439 op_code_data
+= bytes_read
;
3441 file_table
[n_files
].length
=
3442 read_uleb128 (op_code_data
, & bytes_read
,
3448 case DW_LNE_set_discriminator
:
3449 case DW_LNE_HP_set_sequence
:
3450 /* Simply ignored. */
3454 printf (_("UNKNOWN (%u): length %d\n"),
3455 ext_op_code
, ext_op_code_len
- bytes_read
);
3458 data
+= ext_op_code_len
;
3464 case DW_LNS_advance_pc
:
3465 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3467 if (linfo
.li_max_ops_per_insn
== 1)
3469 uladv
*= linfo
.li_min_insn_length
;
3470 state_machine_regs
.address
+= uladv
;
3474 state_machine_regs
.address
3475 += ((state_machine_regs
.op_index
+ uladv
)
3476 / linfo
.li_max_ops_per_insn
)
3477 * linfo
.li_min_insn_length
;
3478 state_machine_regs
.op_index
3479 = (state_machine_regs
.op_index
+ uladv
)
3480 % linfo
.li_max_ops_per_insn
;
3484 case DW_LNS_advance_line
:
3485 adv
= read_sleb128 (data
, & bytes_read
, end
);
3487 state_machine_regs
.line
+= adv
;
3490 case DW_LNS_set_file
:
3491 adv
= read_uleb128 (data
, & bytes_read
, end
);
3493 state_machine_regs
.file
= adv
;
3495 if (file_table
== NULL
)
3496 printf (_("\n [Use file table entry %d]\n"), state_machine_regs
.file
- 1);
3497 else if (file_table
[state_machine_regs
.file
- 1].directory_index
== 0)
3498 /* If directory index is 0, that means current directory. */
3499 printf ("\n./%s:[++]\n",
3500 file_table
[state_machine_regs
.file
- 1].name
);
3501 else if (directory_table
== NULL
)
3502 printf (_("\n [Use directory table entry %d]\n"),
3503 file_table
[state_machine_regs
.file
- 1].directory_index
- 1);
3505 /* The directory index starts counting at 1. */
3506 printf ("\n%s/%s:\n",
3507 directory_table
[file_table
[state_machine_regs
.file
- 1].directory_index
- 1],
3508 file_table
[state_machine_regs
.file
- 1].name
);
3511 case DW_LNS_set_column
:
3512 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3514 state_machine_regs
.column
= uladv
;
3517 case DW_LNS_negate_stmt
:
3518 adv
= state_machine_regs
.is_stmt
;
3520 state_machine_regs
.is_stmt
= adv
;
3523 case DW_LNS_set_basic_block
:
3524 state_machine_regs
.basic_block
= 1;
3527 case DW_LNS_const_add_pc
:
3528 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
3529 if (linfo
.li_max_ops_per_insn
== 1)
3531 uladv
*= linfo
.li_min_insn_length
;
3532 state_machine_regs
.address
+= uladv
;
3536 state_machine_regs
.address
3537 += ((state_machine_regs
.op_index
+ uladv
)
3538 / linfo
.li_max_ops_per_insn
)
3539 * linfo
.li_min_insn_length
;
3540 state_machine_regs
.op_index
3541 = (state_machine_regs
.op_index
+ uladv
)
3542 % linfo
.li_max_ops_per_insn
;
3546 case DW_LNS_fixed_advance_pc
:
3547 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
3548 state_machine_regs
.address
+= uladv
;
3549 state_machine_regs
.op_index
= 0;
3552 case DW_LNS_set_prologue_end
:
3555 case DW_LNS_set_epilogue_begin
:
3558 case DW_LNS_set_isa
:
3559 uladv
= read_uleb128 (data
, & bytes_read
, end
);
3561 printf (_(" Set ISA to %lu\n"), uladv
);
3565 printf (_(" Unknown opcode %d with operands: "), op_code
);
3567 if (standard_opcodes
!= NULL
)
3568 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
3570 printf ("0x%s%s", dwarf_vmatoa ("x", read_uleb128 (data
,
3572 i
== 1 ? "" : ", ");
3579 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
3580 to the DWARF address/line matrix. */
3581 if ((is_special_opcode
) || (op_code
== DW_LNE_end_sequence
)
3582 || (op_code
== DW_LNS_copy
))
3584 const unsigned int MAX_FILENAME_LENGTH
= 35;
3586 char *newFileName
= NULL
;
3587 size_t fileNameLength
;
3590 fileName
= (char *) file_table
[state_machine_regs
.file
- 1].name
;
3592 fileName
= "<unknown>";
3594 fileNameLength
= strlen (fileName
);
3596 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
3598 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
3599 /* Truncate file name */
3600 strncpy (newFileName
,
3601 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
3602 MAX_FILENAME_LENGTH
+ 1);
3606 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
3607 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
3610 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
3612 if (linfo
.li_max_ops_per_insn
== 1)
3613 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x\n",
3614 newFileName
, state_machine_regs
.line
,
3615 state_machine_regs
.address
);
3617 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3618 newFileName
, state_machine_regs
.line
,
3619 state_machine_regs
.address
,
3620 state_machine_regs
.op_index
);
3624 if (linfo
.li_max_ops_per_insn
== 1)
3625 printf ("%s %11d %#18" DWARF_VMA_FMT
"x\n",
3626 newFileName
, state_machine_regs
.line
,
3627 state_machine_regs
.address
);
3629 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]\n",
3630 newFileName
, state_machine_regs
.line
,
3631 state_machine_regs
.address
,
3632 state_machine_regs
.op_index
);
3635 if (op_code
== DW_LNE_end_sequence
)
3649 if (directory_table
)
3651 free (directory_table
);
3652 directory_table
= NULL
;
3663 display_debug_lines (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
3665 unsigned char *data
= section
->start
;
3666 unsigned char *end
= data
+ section
->size
;
3668 int retValDecoded
= 1;
3670 if (do_debug_lines
== 0)
3671 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
3673 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
3674 retValRaw
= display_debug_lines_raw (section
, data
, end
);
3676 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
3677 retValDecoded
= display_debug_lines_decoded (section
, data
, end
);
3679 if (!retValRaw
|| !retValDecoded
)
3686 find_debug_info_for_offset (unsigned long offset
)
3690 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
3693 for (i
= 0; i
< num_debug_info_entries
; i
++)
3694 if (debug_information
[i
].cu_offset
== offset
)
3695 return debug_information
+ i
;
3701 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
3703 /* See gdb/gdb-index.h. */
3704 static const char * const kinds
[] =
3716 return _ (kinds
[kind
]);
3720 display_debug_pubnames_worker (struct dwarf_section
*section
,
3721 void *file ATTRIBUTE_UNUSED
,
3724 DWARF2_Internal_PubNames names
;
3725 unsigned char *start
= section
->start
;
3726 unsigned char *end
= start
+ section
->size
;
3728 /* It does not matter if this load fails,
3729 we test for that later on. */
3730 load_debug_info (file
);
3732 printf (_("Contents of the %s section:\n\n"), section
->name
);
3736 unsigned char *data
;
3739 unsigned int offset_size
, initial_length_size
;
3743 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 4, end
);
3744 if (names
.pn_length
== 0xffffffff)
3746 SAFE_BYTE_GET_AND_INC (names
.pn_length
, data
, 8, end
);
3748 initial_length_size
= 12;
3753 initial_length_size
= 4;
3756 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
3757 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
3759 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
3760 && num_debug_info_entries
> 0
3761 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
3762 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
3763 (unsigned long) names
.pn_offset
, section
->name
);
3765 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
3767 adr
= start
+ names
.pn_length
+ initial_length_size
;
3768 /* PR 17531: file: 7615b6b2. */
3769 if ((dwarf_signed_vma
) names
.pn_length
< 0
3770 /* PR 17531: file: a5dbeaa7. */
3773 warn (_("Negative length for public name: 0x%lx\n"), (long) names
.pn_length
);
3779 printf (_(" Length: %ld\n"),
3780 (long) names
.pn_length
);
3781 printf (_(" Version: %d\n"),
3783 printf (_(" Offset into .debug_info section: 0x%lx\n"),
3784 (unsigned long) names
.pn_offset
);
3785 printf (_(" Size of area in .debug_info section: %ld\n"),
3786 (long) names
.pn_size
);
3788 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
3790 static int warned
= 0;
3794 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
3802 printf (_("\n Offset Kind Name\n"));
3804 printf (_("\n Offset\tName\n"));
3808 bfd_size_type maxprint
;
3810 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
3814 data
+= offset_size
;
3817 maxprint
= (end
- data
) - 1;
3821 unsigned int kind_data
;
3822 gdb_index_symbol_kind kind
;
3823 const char *kind_name
;
3826 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
3829 /* GCC computes the kind as the upper byte in the CU index
3830 word, and then right shifts it by the CU index size.
3831 Left shift KIND to where the gdb-index.h accessor macros
3833 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
3834 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
3835 kind_name
= get_gdb_index_symbol_kind_name (kind
);
3836 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
3837 printf (" %-6lx %s,%-10s %.*s\n",
3838 (unsigned long) offset
, is_static
? _("s") : _("g"),
3839 kind_name
, (int) maxprint
, data
);
3842 printf (" %-6lx\t%.*s\n",
3843 (unsigned long) offset
, (int) maxprint
, data
);
3845 data
+= strnlen ((char *) data
, maxprint
) + 1;
3850 while (offset
!= 0);
3858 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
3860 return display_debug_pubnames_worker (section
, file
, 0);
3864 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
3866 return display_debug_pubnames_worker (section
, file
, 1);
3870 display_debug_macinfo (struct dwarf_section
*section
,
3871 void *file ATTRIBUTE_UNUSED
)
3873 unsigned char *start
= section
->start
;
3874 unsigned char *end
= start
+ section
->size
;
3875 unsigned char *curr
= start
;
3876 unsigned int bytes_read
;
3877 enum dwarf_macinfo_record_type op
;
3879 printf (_("Contents of the %s section:\n\n"), section
->name
);
3883 unsigned int lineno
;
3884 const unsigned char *string
;
3886 op
= (enum dwarf_macinfo_record_type
) *curr
;
3891 case DW_MACINFO_start_file
:
3893 unsigned int filenum
;
3895 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3897 filenum
= read_uleb128 (curr
, & bytes_read
, end
);
3900 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
3905 case DW_MACINFO_end_file
:
3906 printf (_(" DW_MACINFO_end_file\n"));
3909 case DW_MACINFO_define
:
3910 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3913 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3914 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
3918 case DW_MACINFO_undef
:
3919 lineno
= read_uleb128 (curr
, & bytes_read
, end
);
3922 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3923 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
3927 case DW_MACINFO_vendor_ext
:
3929 unsigned int constant
;
3931 constant
= read_uleb128 (curr
, & bytes_read
, end
);
3934 curr
+= strnlen ((char *) string
, end
- string
) + 1;
3935 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
3945 /* Given LINE_OFFSET into the .debug_line section, attempt to return
3946 filename and dirname corresponding to file name table entry with index
3947 FILEIDX. Return NULL on failure. */
3949 static unsigned char *
3950 get_line_filename_and_dirname (dwarf_vma line_offset
,
3952 unsigned char **dir_name
)
3954 struct dwarf_section
*section
= &debug_displays
[line
].section
;
3955 unsigned char *hdrptr
, *dirtable
, *file_name
;
3956 unsigned int offset_size
, initial_length_size
;
3957 unsigned int version
, opcode_base
, bytes_read
;
3958 dwarf_vma length
, diridx
;
3959 const unsigned char * end
;
3962 if (section
->start
== NULL
3963 || line_offset
>= section
->size
3967 hdrptr
= section
->start
+ line_offset
;
3968 end
= section
->start
+ section
->size
;
3970 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
3971 if (length
== 0xffffffff)
3973 /* This section is 64-bit DWARF 3. */
3974 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
3976 initial_length_size
= 12;
3981 initial_length_size
= 4;
3983 if (length
+ initial_length_size
> section
->size
)
3986 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
3987 if (version
!= 2 && version
!= 3 && version
!= 4)
3989 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
3991 hdrptr
++; /* Skip max_ops_per_insn. */
3992 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
3994 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
3995 if (opcode_base
== 0)
3998 hdrptr
+= opcode_base
- 1;
4000 /* Skip over dirname table. */
4001 while (*hdrptr
!= '\0')
4002 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4003 hdrptr
++; /* Skip the NUL at the end of the table. */
4004 /* Now skip over preceding filename table entries. */
4005 for (; *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
4007 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4008 read_uleb128 (hdrptr
, &bytes_read
, end
);
4009 hdrptr
+= bytes_read
;
4010 read_uleb128 (hdrptr
, &bytes_read
, end
);
4011 hdrptr
+= bytes_read
;
4012 read_uleb128 (hdrptr
, &bytes_read
, end
);
4013 hdrptr
+= bytes_read
;
4015 if (hdrptr
== end
|| *hdrptr
== '\0')
4018 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
4019 diridx
= read_uleb128 (hdrptr
, &bytes_read
, end
);
4022 for (; *dirtable
!= '\0' && diridx
> 1; diridx
--)
4023 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
4024 if (*dirtable
== '\0')
4026 *dir_name
= dirtable
;
4031 display_debug_macro (struct dwarf_section
*section
,
4034 unsigned char *start
= section
->start
;
4035 unsigned char *end
= start
+ section
->size
;
4036 unsigned char *curr
= start
;
4037 unsigned char *extended_op_buf
[256];
4038 unsigned int bytes_read
;
4040 load_debug_section (str
, file
);
4041 load_debug_section (line
, file
);
4043 printf (_("Contents of the %s section:\n\n"), section
->name
);
4047 unsigned int lineno
, version
, flags
;
4048 unsigned int offset_size
= 4;
4049 const unsigned char *string
;
4050 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
4051 unsigned char **extended_ops
= NULL
;
4053 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
4056 error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"),
4061 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
4064 printf (_(" Offset: 0x%lx\n"),
4065 (unsigned long) sec_offset
);
4066 printf (_(" Version: %d\n"), version
);
4067 printf (_(" Offset size: %d\n"), offset_size
);
4070 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
4071 printf (_(" Offset into .debug_line: 0x%lx\n"),
4072 (unsigned long) line_offset
);
4076 unsigned int i
, count
, op
;
4079 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
4081 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
4082 extended_ops
= extended_op_buf
;
4085 printf (_(" Extension opcode arguments:\n"));
4086 for (i
= 0; i
< count
; i
++)
4088 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4089 extended_ops
[op
] = curr
;
4090 nargs
= read_uleb128 (curr
, &bytes_read
, end
);
4093 printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op
);
4096 printf (_(" DW_MACRO_GNU_%02x arguments: "), op
);
4097 for (n
= 0; n
< nargs
; n
++)
4101 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
4102 printf ("%s%s", get_FORM_name (form
),
4103 n
== nargs
- 1 ? "\n" : ", ");
4113 case DW_FORM_block1
:
4114 case DW_FORM_block2
:
4115 case DW_FORM_block4
:
4117 case DW_FORM_string
:
4119 case DW_FORM_sec_offset
:
4122 error (_("Invalid extension opcode form %s\n"),
4123 get_FORM_name (form
));
4139 error (_(".debug_macro section not zero terminated\n"));
4143 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
4149 case DW_MACRO_GNU_start_file
:
4151 unsigned int filenum
;
4152 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
4154 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4156 filenum
= read_uleb128 (curr
, &bytes_read
, end
);
4159 if ((flags
& 2) == 0)
4160 error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n"));
4163 = get_line_filename_and_dirname (line_offset
, filenum
,
4165 if (file_name
== NULL
)
4166 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"),
4169 printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
4171 dir_name
!= NULL
? (const char *) dir_name
: "",
4172 dir_name
!= NULL
? "/" : "", file_name
);
4176 case DW_MACRO_GNU_end_file
:
4177 printf (_(" DW_MACRO_GNU_end_file\n"));
4180 case DW_MACRO_GNU_define
:
4181 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4184 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4185 printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"),
4189 case DW_MACRO_GNU_undef
:
4190 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4193 curr
+= strnlen ((char *) string
, end
- string
) + 1;
4194 printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"),
4198 case DW_MACRO_GNU_define_indirect
:
4199 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4201 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4202 string
= fetch_indirect_string (offset
);
4203 printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"),
4207 case DW_MACRO_GNU_undef_indirect
:
4208 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4210 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4211 string
= fetch_indirect_string (offset
);
4212 printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"),
4216 case DW_MACRO_GNU_transparent_include
:
4217 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4218 printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"),
4219 (unsigned long) offset
);
4222 case DW_MACRO_GNU_define_indirect_alt
:
4223 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4225 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4226 printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4227 lineno
, (unsigned long) offset
);
4230 case DW_MACRO_GNU_undef_indirect_alt
:
4231 lineno
= read_uleb128 (curr
, &bytes_read
, end
);
4233 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4234 printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"),
4235 lineno
, (unsigned long) offset
);
4238 case DW_MACRO_GNU_transparent_include_alt
:
4239 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
4240 printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"),
4241 (unsigned long) offset
);
4245 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
4247 error (_(" Unknown macro opcode %02x seen\n"), op
);
4252 /* Skip over unhandled opcodes. */
4254 unsigned char *desc
= extended_ops
[op
];
4255 nargs
= read_uleb128 (desc
, &bytes_read
, end
);
4259 printf (_(" DW_MACRO_GNU_%02x\n"), op
);
4262 printf (_(" DW_MACRO_GNU_%02x -"), op
);
4263 for (n
= 0; n
< nargs
; n
++)
4267 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
4269 = read_and_display_attr_value (0, val
,
4270 curr
, end
, 0, 0, offset_size
,
4271 version
, NULL
, 0, NULL
,
4289 display_debug_abbrev (struct dwarf_section
*section
,
4290 void *file ATTRIBUTE_UNUSED
)
4292 abbrev_entry
*entry
;
4293 unsigned char *start
= section
->start
;
4294 unsigned char *end
= start
+ section
->size
;
4296 printf (_("Contents of the %s section:\n\n"), section
->name
);
4300 unsigned char *last
;
4305 start
= process_abbrev_section (start
, end
);
4307 if (first_abbrev
== NULL
)
4310 printf (_(" Number TAG (0x%lx)\n"), (long) (last
- section
->start
));
4312 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4316 printf (" %ld %s [%s]\n",
4318 get_TAG_name (entry
->tag
),
4319 entry
->children
? _("has children") : _("no children"));
4321 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4322 printf (" %-18s %s\n",
4323 get_AT_name (attr
->attribute
),
4324 get_FORM_name (attr
->form
));
4334 /* Return true when ADDR is the maximum address, when addresses are
4335 POINTER_SIZE bytes long. */
4338 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
4340 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
4341 return ((addr
& mask
) == mask
);
4344 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
4347 display_loc_list (struct dwarf_section
*section
,
4348 unsigned char **start_ptr
,
4349 unsigned int debug_info_entry
,
4350 unsigned long offset
,
4351 unsigned long base_address
,
4354 unsigned char *start
= *start_ptr
;
4355 unsigned char *section_end
= section
->start
+ section
->size
;
4356 unsigned long cu_offset
;
4357 unsigned int pointer_size
;
4358 unsigned int offset_size
;
4363 unsigned short length
;
4364 int need_frame_base
;
4366 if (debug_info_entry
>= num_debug_info_entries
)
4368 warn (_("No debug information available for loc lists of entry: %u\n"),
4373 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4374 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4375 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4376 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4378 if (pointer_size
< 2 || pointer_size
> 8)
4380 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4381 pointer_size
, debug_info_entry
);
4387 unsigned long off
= offset
+ (start
- *start_ptr
);
4389 if (start
+ 2 * pointer_size
> section_end
)
4391 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4396 printf (" %8.8lx ", off
);
4398 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
4399 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
4401 if (begin
== 0 && end
== 0)
4403 /* PR 18374: In a object file we can have a location list that
4404 starts with a begin and end of 0 because there are relocations
4405 that need to be applied to the addresses. Actually applying
4406 the relocations now does not help as they will probably resolve
4407 to 0, since the object file has not been fully linked. Real
4408 end of list markers will not have any relocations against them. */
4409 if (! reloc_at (section
, off
)
4410 && ! reloc_at (section
, off
+ pointer_size
))
4412 printf (_("<End of list>\n"));
4417 /* Check base address specifiers. */
4418 if (is_max_address (begin
, pointer_size
)
4419 && !is_max_address (end
, pointer_size
))
4422 print_dwarf_vma (begin
, pointer_size
);
4423 print_dwarf_vma (end
, pointer_size
);
4424 printf (_("(base address)\n"));
4428 if (start
+ 2 > section_end
)
4430 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4435 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4437 if (start
+ length
> section_end
)
4439 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4444 print_dwarf_vma (begin
+ base_address
, pointer_size
);
4445 print_dwarf_vma (end
+ base_address
, pointer_size
);
4448 need_frame_base
= decode_location_expression (start
,
4453 cu_offset
, section
);
4456 if (need_frame_base
&& !has_frame_base
)
4457 printf (_(" [without DW_AT_frame_base]"));
4460 fputs (_(" (start == end)"), stdout
);
4461 else if (begin
> end
)
4462 fputs (_(" (start > end)"), stdout
);
4472 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
4473 right-adjusted in a field of length LEN, and followed by a space. */
4476 print_addr_index (unsigned int idx
, unsigned int len
)
4478 static char buf
[15];
4479 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
4480 printf ("%*s ", len
, buf
);
4483 /* Display a location list from a .dwo section. It uses address indexes rather
4484 than embedded addresses. This code closely follows display_loc_list, but the
4485 two are sufficiently different that combining things is very ugly. */
4488 display_loc_list_dwo (struct dwarf_section
*section
,
4489 unsigned char **start_ptr
,
4490 unsigned int debug_info_entry
,
4491 unsigned long offset
,
4494 unsigned char *start
= *start_ptr
;
4495 unsigned char *section_end
= section
->start
+ section
->size
;
4496 unsigned long cu_offset
;
4497 unsigned int pointer_size
;
4498 unsigned int offset_size
;
4501 unsigned short length
;
4502 int need_frame_base
;
4504 unsigned int bytes_read
;
4506 if (debug_info_entry
>= num_debug_info_entries
)
4508 warn (_("No debug information for loc lists of entry: %u\n"),
4513 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
4514 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
4515 offset_size
= debug_information
[debug_info_entry
].offset_size
;
4516 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
4518 if (pointer_size
< 2 || pointer_size
> 8)
4520 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
4521 pointer_size
, debug_info_entry
);
4527 printf (" %8.8lx ", offset
+ (start
- *start_ptr
));
4529 if (start
>= section_end
)
4531 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4536 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
4539 case 0: /* A terminating entry. */
4541 printf (_("<End of list>\n"));
4543 case 1: /* A base-address entry. */
4544 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4545 start
+= bytes_read
;
4546 print_addr_index (idx
, 8);
4548 printf (_("(base address selection entry)\n"));
4550 case 2: /* A start/end entry. */
4551 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4552 start
+= bytes_read
;
4553 print_addr_index (idx
, 8);
4554 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4555 start
+= bytes_read
;
4556 print_addr_index (idx
, 8);
4558 case 3: /* A start/length entry. */
4559 idx
= read_uleb128 (start
, &bytes_read
, section_end
);
4560 start
+= bytes_read
;
4561 print_addr_index (idx
, 8);
4562 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4563 printf ("%08x ", idx
);
4565 case 4: /* An offset pair entry. */
4566 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4567 printf ("%08x ", idx
);
4568 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
4569 printf ("%08x ", idx
);
4572 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
4577 if (start
+ 2 > section_end
)
4579 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4584 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
4585 if (start
+ length
> section_end
)
4587 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
4593 need_frame_base
= decode_location_expression (start
,
4598 cu_offset
, section
);
4601 if (need_frame_base
&& !has_frame_base
)
4602 printf (_(" [without DW_AT_frame_base]"));
4612 /* Sort array of indexes in ascending order of loc_offsets[idx]. */
4614 static dwarf_vma
*loc_offsets
;
4617 loc_offsets_compar (const void *ap
, const void *bp
)
4619 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
4620 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
4622 return (a
> b
) - (b
> a
);
4626 display_debug_loc (struct dwarf_section
*section
, void *file
)
4628 unsigned char *start
= section
->start
;
4629 unsigned long bytes
;
4630 unsigned char *section_begin
= start
;
4631 unsigned int num_loc_list
= 0;
4632 unsigned long last_offset
= 0;
4633 unsigned int first
= 0;
4636 int seen_first_offset
= 0;
4637 int locs_sorted
= 1;
4638 unsigned char *next
;
4639 unsigned int *array
= NULL
;
4640 const char *suffix
= strrchr (section
->name
, '.');
4643 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
4646 bytes
= section
->size
;
4650 printf (_("\nThe %s section is empty.\n"), section
->name
);
4654 if (load_debug_info (file
) == 0)
4656 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
4661 /* Check the order of location list in .debug_info section. If
4662 offsets of location lists are in the ascending order, we can
4663 use `debug_information' directly. */
4664 for (i
= 0; i
< num_debug_info_entries
; i
++)
4668 num
= debug_information
[i
].num_loc_offsets
;
4669 if (num
> num_loc_list
)
4672 /* Check if we can use `debug_information' directly. */
4673 if (locs_sorted
&& num
!= 0)
4675 if (!seen_first_offset
)
4677 /* This is the first location list. */
4678 last_offset
= debug_information
[i
].loc_offsets
[0];
4680 seen_first_offset
= 1;
4686 for (; j
< num
; j
++)
4689 debug_information
[i
].loc_offsets
[j
])
4694 last_offset
= debug_information
[i
].loc_offsets
[j
];
4699 if (!seen_first_offset
)
4700 error (_("No location lists in .debug_info section!\n"));
4702 if (debug_information
[first
].num_loc_offsets
> 0
4703 && debug_information
[first
].loc_offsets
[0] != 0)
4704 warn (_("Location lists in %s section start at 0x%s\n"),
4706 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
4709 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
4710 printf (_("Contents of the %s section:\n\n"), section
->name
);
4711 if (reloc_at (section
, 0))
4712 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
4713 printf (_(" Offset Begin End Expression\n"));
4715 seen_first_offset
= 0;
4716 for (i
= first
; i
< num_debug_info_entries
; i
++)
4718 unsigned long offset
;
4719 unsigned long base_address
;
4725 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4727 loc_offsets
= debug_information
[i
].loc_offsets
;
4728 qsort (array
, debug_information
[i
].num_loc_offsets
,
4729 sizeof (*array
), loc_offsets_compar
);
4732 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
4734 j
= locs_sorted
? k
: array
[k
];
4736 && debug_information
[i
].loc_offsets
[locs_sorted
4737 ? k
- 1 : array
[k
- 1]]
4738 == debug_information
[i
].loc_offsets
[j
])
4740 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
4741 offset
= debug_information
[i
].loc_offsets
[j
];
4742 next
= section_begin
+ offset
;
4743 base_address
= debug_information
[i
].base_address
;
4745 if (!seen_first_offset
)
4746 seen_first_offset
= 1;
4750 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
4751 (unsigned long) (start
- section_begin
),
4752 (unsigned long) offset
);
4753 else if (start
> next
)
4754 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
4755 (unsigned long) (start
- section_begin
),
4756 (unsigned long) offset
);
4760 if (offset
>= bytes
)
4762 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
4768 display_loc_list_dwo (section
, &start
, i
, offset
, has_frame_base
);
4770 display_loc_list (section
, &start
, i
, offset
, base_address
,
4775 if (start
< section
->start
+ section
->size
)
4776 warn (_("There are %ld unused bytes at the end of section %s\n"),
4777 (long) (section
->start
+ section
->size
- start
), section
->name
);
4784 display_debug_str (struct dwarf_section
*section
,
4785 void *file ATTRIBUTE_UNUSED
)
4787 unsigned char *start
= section
->start
;
4788 unsigned long bytes
= section
->size
;
4789 dwarf_vma addr
= section
->address
;
4793 printf (_("\nThe %s section is empty.\n"), section
->name
);
4797 printf (_("Contents of the %s section:\n\n"), section
->name
);
4805 lbytes
= (bytes
> 16 ? 16 : bytes
);
4807 printf (" 0x%8.8lx ", (unsigned long) addr
);
4809 for (j
= 0; j
< 16; j
++)
4812 printf ("%2.2x", start
[j
]);
4820 for (j
= 0; j
< lbytes
; j
++)
4823 if (k
>= ' ' && k
< 0x80)
4842 display_debug_info (struct dwarf_section
*section
, void *file
)
4844 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4848 display_debug_types (struct dwarf_section
*section
, void *file
)
4850 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 1);
4854 display_trace_info (struct dwarf_section
*section
, void *file
)
4856 return process_debug_info (section
, file
, section
->abbrev_sec
, 0, 0);
4860 display_debug_aranges (struct dwarf_section
*section
,
4861 void *file ATTRIBUTE_UNUSED
)
4863 unsigned char *start
= section
->start
;
4864 unsigned char *end
= start
+ section
->size
;
4866 printf (_("Contents of the %s section:\n\n"), section
->name
);
4868 /* It does not matter if this load fails,
4869 we test for that later on. */
4870 load_debug_info (file
);
4874 unsigned char *hdrptr
;
4875 DWARF2_Internal_ARange arange
;
4876 unsigned char *addr_ranges
;
4879 unsigned char address_size
;
4881 unsigned int offset_size
;
4882 unsigned int initial_length_size
;
4886 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
4887 if (arange
.ar_length
== 0xffffffff)
4889 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
4891 initial_length_size
= 12;
4896 initial_length_size
= 4;
4899 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
4900 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
4902 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
4903 && num_debug_info_entries
> 0
4904 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
4905 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
4906 (unsigned long) arange
.ar_info_offset
, section
->name
);
4908 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
4909 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
4911 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
4913 /* PR 19872: A version number of 0 probably means that there is
4914 padding at the end of the .debug_aranges section. Gold puts
4915 it there when performing an incremental link, for example.
4916 So do not generate a warning in this case. */
4917 if (arange
.ar_version
)
4918 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
4922 printf (_(" Length: %ld\n"),
4923 (long) arange
.ar_length
);
4924 printf (_(" Version: %d\n"), arange
.ar_version
);
4925 printf (_(" Offset into .debug_info: 0x%lx\n"),
4926 (unsigned long) arange
.ar_info_offset
);
4927 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
4928 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
4930 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
4932 /* PR 17512: file: 001-108546-0.001:0.1. */
4933 if (address_size
== 0 || address_size
> 8)
4935 error (_("Invalid address size in %s section!\n"),
4940 /* The DWARF spec does not require that the address size be a power
4941 of two, but we do. This will have to change if we ever encounter
4942 an uneven architecture. */
4943 if ((address_size
& (address_size
- 1)) != 0)
4945 warn (_("Pointer size + Segment size is not a power of two.\n"));
4949 if (address_size
> 4)
4950 printf (_("\n Address Length\n"));
4952 printf (_("\n Address Length\n"));
4954 addr_ranges
= hdrptr
;
4956 /* Must pad to an alignment boundary that is twice the address size. */
4957 excess
= (hdrptr
- start
) % (2 * address_size
);
4959 addr_ranges
+= (2 * address_size
) - excess
;
4961 hdrptr
= start
+ arange
.ar_length
+ initial_length_size
;
4962 if (hdrptr
< start
|| hdrptr
> end
)
4964 error (_("Excessive header length: %lx\n"), (long) arange
.ar_length
);
4969 while (addr_ranges
+ 2 * address_size
<= start
)
4971 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
4972 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
4975 print_dwarf_vma (address
, address_size
);
4976 print_dwarf_vma (length
, address_size
);
4986 /* Comparison function for qsort. */
4988 comp_addr_base (const void * v0
, const void * v1
)
4990 debug_info
* info0
= (debug_info
*) v0
;
4991 debug_info
* info1
= (debug_info
*) v1
;
4992 return info0
->addr_base
- info1
->addr_base
;
4995 /* Display the debug_addr section. */
4997 display_debug_addr (struct dwarf_section
*section
,
5000 debug_info
**debug_addr_info
;
5001 unsigned char *entry
;
5006 if (section
->size
== 0)
5008 printf (_("\nThe %s section is empty.\n"), section
->name
);
5012 if (load_debug_info (file
) == 0)
5014 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5019 printf (_("Contents of the %s section:\n\n"), section
->name
);
5021 /* PR 17531: file: cf38d01b.
5022 We use xcalloc because a corrupt file may not have initialised all of the
5023 fields in the debug_info structure, which means that the sort below might
5024 try to move uninitialised data. */
5025 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
5026 sizeof (debug_info
*));
5029 for (i
= 0; i
< num_debug_info_entries
; i
++)
5030 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
5032 /* PR 17531: file: cf38d01b. */
5033 if (debug_information
[i
].addr_base
>= section
->size
)
5034 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
5035 (unsigned long) debug_information
[i
].addr_base
, i
);
5037 debug_addr_info
[count
++] = debug_information
+ i
;
5040 /* Add a sentinel to make iteration convenient. */
5041 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
5042 debug_addr_info
[count
]->addr_base
= section
->size
;
5043 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
5045 for (i
= 0; i
< count
; i
++)
5048 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
5050 printf (_(" For compilation unit at offset 0x%s:\n"),
5051 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
5053 printf (_("\tIndex\tAddress\n"));
5054 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
5055 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
5059 dwarf_vma base
= byte_get (entry
, address_size
);
5060 printf (_("\t%d:\t"), idx
);
5061 print_dwarf_vma (base
, address_size
);
5063 entry
+= address_size
;
5069 free (debug_addr_info
);
5073 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
5075 display_debug_str_offsets (struct dwarf_section
*section
,
5076 void *file ATTRIBUTE_UNUSED
)
5078 if (section
->size
== 0)
5080 printf (_("\nThe %s section is empty.\n"), section
->name
);
5083 /* TODO: Dump the contents. This is made somewhat difficult by not knowing
5084 what the offset size is for this section. */
5088 /* Each debug_information[x].range_lists[y] gets this representation for
5089 sorting purposes. */
5093 /* The debug_information[x].range_lists[y] value. */
5094 unsigned long ranges_offset
;
5096 /* Original debug_information to find parameters of the data. */
5097 debug_info
*debug_info_p
;
5100 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
5103 range_entry_compar (const void *ap
, const void *bp
)
5105 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
5106 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
5107 const unsigned long a
= a_re
->ranges_offset
;
5108 const unsigned long b
= b_re
->ranges_offset
;
5110 return (a
> b
) - (b
> a
);
5114 display_debug_ranges (struct dwarf_section
*section
,
5115 void *file ATTRIBUTE_UNUSED
)
5117 unsigned char *start
= section
->start
;
5118 unsigned char *last_start
= start
;
5119 unsigned long bytes
= section
->size
;
5120 unsigned char *section_begin
= start
;
5121 unsigned char *finish
= start
+ bytes
;
5122 unsigned int num_range_list
, i
;
5123 struct range_entry
*range_entries
, *range_entry_fill
;
5127 printf (_("\nThe %s section is empty.\n"), section
->name
);
5131 if (load_debug_info (file
) == 0)
5133 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
5139 for (i
= 0; i
< num_debug_info_entries
; i
++)
5140 num_range_list
+= debug_information
[i
].num_range_lists
;
5142 if (num_range_list
== 0)
5144 /* This can happen when the file was compiled with -gsplit-debug
5145 which removes references to range lists from the primary .o file. */
5146 printf (_("No range lists in .debug_info section.\n"));
5150 range_entries
= (struct range_entry
*)
5151 xmalloc (sizeof (*range_entries
) * num_range_list
);
5152 range_entry_fill
= range_entries
;
5154 for (i
= 0; i
< num_debug_info_entries
; i
++)
5156 debug_info
*debug_info_p
= &debug_information
[i
];
5159 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
5161 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
5162 range_entry_fill
->debug_info_p
= debug_info_p
;
5167 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
5168 range_entry_compar
);
5170 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
5171 warn (_("Range lists in %s section start at 0x%lx\n"),
5172 section
->name
, range_entries
[0].ranges_offset
);
5174 printf (_("Contents of the %s section:\n\n"), section
->name
);
5175 printf (_(" Offset Begin End\n"));
5177 for (i
= 0; i
< num_range_list
; i
++)
5179 struct range_entry
*range_entry
= &range_entries
[i
];
5180 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
5181 unsigned int pointer_size
;
5182 unsigned long offset
;
5183 unsigned char *next
;
5184 unsigned long base_address
;
5186 pointer_size
= debug_info_p
->pointer_size
;
5187 offset
= range_entry
->ranges_offset
;
5188 next
= section_begin
+ offset
;
5189 base_address
= debug_info_p
->base_address
;
5191 /* PR 17512: file: 001-101485-0.001:0.1. */
5192 if (pointer_size
< 2 || pointer_size
> 8)
5194 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
5195 pointer_size
, offset
);
5199 if (dwarf_check
!= 0 && i
> 0)
5202 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
5203 (unsigned long) (start
- section_begin
),
5204 (unsigned long) (next
- section_begin
), section
->name
);
5205 else if (start
> next
)
5207 if (next
== last_start
)
5209 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
5210 (unsigned long) (start
- section_begin
),
5211 (unsigned long) (next
- section_begin
), section
->name
);
5217 while (start
< finish
)
5222 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
5223 if (start
>= finish
)
5225 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
5227 printf (" %8.8lx ", offset
);
5229 if (begin
== 0 && end
== 0)
5231 printf (_("<End of list>\n"));
5235 /* Check base address specifiers. */
5236 if (is_max_address (begin
, pointer_size
)
5237 && !is_max_address (end
, pointer_size
))
5240 print_dwarf_vma (begin
, pointer_size
);
5241 print_dwarf_vma (end
, pointer_size
);
5242 printf ("(base address)\n");
5246 print_dwarf_vma (begin
+ base_address
, pointer_size
);
5247 print_dwarf_vma (end
+ base_address
, pointer_size
);
5250 fputs (_("(start == end)"), stdout
);
5251 else if (begin
> end
)
5252 fputs (_("(start > end)"), stdout
);
5259 free (range_entries
);
5264 typedef struct Frame_Chunk
5266 struct Frame_Chunk
*next
;
5267 unsigned char *chunk_start
;
5269 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
5270 short int *col_type
;
5273 unsigned int code_factor
;
5278 dwarf_vma cfa_offset
;
5280 unsigned char fde_encoding
;
5281 unsigned char cfa_exp
;
5282 unsigned char ptr_size
;
5283 unsigned char segment_size
;
5287 static const char *const *dwarf_regnames
;
5288 static unsigned int dwarf_regnames_count
;
5290 /* A marker for a col_type that means this column was never referenced
5291 in the frame info. */
5292 #define DW_CFA_unreferenced (-1)
5294 /* Return 0 if no more space is needed, 1 if more space is needed,
5295 -1 for invalid reg. */
5298 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
5300 unsigned int prev
= fc
->ncols
;
5302 if (reg
< (unsigned int) fc
->ncols
)
5305 if (dwarf_regnames_count
5306 && reg
> dwarf_regnames_count
)
5309 fc
->ncols
= reg
+ 1;
5310 /* PR 17512: file: 10450-2643-0.004.
5311 If reg == -1 then this can happen... */
5315 /* PR 17512: file: 2844a11d. */
5316 if (fc
->ncols
> 1024)
5318 error (_("Unfeasibly large register number: %u\n"), reg
);
5320 /* FIXME: 1024 is an arbitrary limit. Increase it if
5321 we ever encounter a valid binary that exceeds it. */
5325 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
5326 sizeof (short int));
5327 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
5328 /* PR 17512: file:002-10025-0.005. */
5329 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
5331 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
5337 while (prev
< fc
->ncols
)
5339 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
5340 fc
->col_offset
[prev
] = 0;
5346 static const char *const dwarf_regnames_i386
[] =
5348 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5349 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5350 "eip", "eflags", NULL
, /* 8 - 10 */
5351 "st0", "st1", "st2", "st3", /* 11 - 14 */
5352 "st4", "st5", "st6", "st7", /* 15 - 18 */
5353 NULL
, NULL
, /* 19 - 20 */
5354 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
5355 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
5356 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
5357 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
5358 "fcw", "fsw", "mxcsr", /* 37 - 39 */
5359 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5360 "tr", "ldtr", /* 48 - 49 */
5361 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5362 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5363 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5364 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5365 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5366 NULL
, NULL
, NULL
, /* 90 - 92 */
5367 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
5370 static const char *const dwarf_regnames_iamcu
[] =
5372 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
5373 "esp", "ebp", "esi", "edi", /* 4 - 7 */
5374 "eip", "eflags", NULL
, /* 8 - 10 */
5375 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
5376 NULL
, NULL
, /* 19 - 20 */
5377 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
5378 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
5379 NULL
, NULL
, NULL
, /* 37 - 39 */
5380 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
5381 "tr", "ldtr", /* 48 - 49 */
5382 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
5383 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
5384 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
5385 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
5386 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
5387 NULL
, NULL
, NULL
, /* 90 - 92 */
5388 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
5392 init_dwarf_regnames_i386 (void)
5394 dwarf_regnames
= dwarf_regnames_i386
;
5395 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
5399 init_dwarf_regnames_iamcu (void)
5401 dwarf_regnames
= dwarf_regnames_iamcu
;
5402 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
5405 static const char *const dwarf_regnames_x86_64
[] =
5407 "rax", "rdx", "rcx", "rbx",
5408 "rsi", "rdi", "rbp", "rsp",
5409 "r8", "r9", "r10", "r11",
5410 "r12", "r13", "r14", "r15",
5412 "xmm0", "xmm1", "xmm2", "xmm3",
5413 "xmm4", "xmm5", "xmm6", "xmm7",
5414 "xmm8", "xmm9", "xmm10", "xmm11",
5415 "xmm12", "xmm13", "xmm14", "xmm15",
5416 "st0", "st1", "st2", "st3",
5417 "st4", "st5", "st6", "st7",
5418 "mm0", "mm1", "mm2", "mm3",
5419 "mm4", "mm5", "mm6", "mm7",
5421 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
5422 "fs.base", "gs.base", NULL
, NULL
,
5424 "mxcsr", "fcw", "fsw",
5425 "xmm16", "xmm17", "xmm18", "xmm19",
5426 "xmm20", "xmm21", "xmm22", "xmm23",
5427 "xmm24", "xmm25", "xmm26", "xmm27",
5428 "xmm28", "xmm29", "xmm30", "xmm31",
5429 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
5430 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
5431 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
5432 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
5433 NULL
, NULL
, NULL
, /* 115 - 117 */
5434 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
5438 init_dwarf_regnames_x86_64 (void)
5440 dwarf_regnames
= dwarf_regnames_x86_64
;
5441 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
5444 static const char *const dwarf_regnames_aarch64
[] =
5446 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
5447 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
5448 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
5449 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
5450 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5451 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5452 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5453 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
5454 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
5455 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
5456 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
5457 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
5461 init_dwarf_regnames_aarch64 (void)
5463 dwarf_regnames
= dwarf_regnames_aarch64
;
5464 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
5468 init_dwarf_regnames (unsigned int e_machine
)
5473 init_dwarf_regnames_i386 ();
5477 init_dwarf_regnames_iamcu ();
5483 init_dwarf_regnames_x86_64 ();
5487 init_dwarf_regnames_aarch64 ();
5496 regname (unsigned int regno
, int row
)
5498 static char reg
[64];
5500 && regno
< dwarf_regnames_count
5501 && dwarf_regnames
[regno
] != NULL
)
5504 return dwarf_regnames
[regno
];
5505 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
,
5506 dwarf_regnames
[regno
]);
5509 snprintf (reg
, sizeof (reg
), "r%d", regno
);
5514 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
5519 if (*max_regs
< fc
->ncols
)
5520 *max_regs
= fc
->ncols
;
5522 if (*need_col_headers
)
5524 static const char *sloc
= " LOC";
5526 *need_col_headers
= 0;
5528 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
5530 for (r
= 0; r
< *max_regs
; r
++)
5531 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5536 printf ("%-5s ", regname (r
, 1));
5542 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
5544 strcpy (tmp
, "exp");
5546 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
5547 printf ("%-8s ", tmp
);
5549 for (r
= 0; r
< fc
->ncols
; r
++)
5551 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
5553 switch (fc
->col_type
[r
])
5555 case DW_CFA_undefined
:
5558 case DW_CFA_same_value
:
5562 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
5564 case DW_CFA_val_offset
:
5565 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
5567 case DW_CFA_register
:
5568 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
5570 case DW_CFA_expression
:
5571 strcpy (tmp
, "exp");
5573 case DW_CFA_val_expression
:
5574 strcpy (tmp
, "vexp");
5577 strcpy (tmp
, "n/a");
5580 printf ("%-5s ", tmp
);
5586 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
5587 #define LEB() read_uleb128 (start, & length_return, end); start += length_return
5588 #define SLEB() read_sleb128 (start, & length_return, end); start += length_return
5590 static unsigned char *
5591 read_cie (unsigned char *start
, unsigned char *end
,
5592 Frame_Chunk
**p_cie
, int *p_version
,
5593 unsigned long *p_aug_len
, unsigned char **p_aug
)
5597 unsigned int length_return
;
5598 unsigned char *augmentation_data
= NULL
;
5599 unsigned long augmentation_data_len
= 0;
5602 /* PR 17512: file: 001-228113-0.004. */
5606 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
5607 memset (fc
, 0, sizeof (Frame_Chunk
));
5609 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5610 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5614 fc
->augmentation
= (char *) start
;
5615 /* PR 17512: file: 001-228113-0.004.
5616 Skip past augmentation name, but avoid running off the end of the data. */
5618 if (* start
++ == '\0')
5622 warn (_("No terminator for augmentation name\n"));
5626 if (strcmp (fc
->augmentation
, "eh") == 0)
5627 start
+= eh_addr_size
;
5631 GET (fc
->ptr_size
, 1);
5632 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
5634 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
5638 GET (fc
->segment_size
, 1);
5639 /* PR 17512: file: e99d2804. */
5640 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
5642 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
5646 eh_addr_size
= fc
->ptr_size
;
5650 fc
->ptr_size
= eh_addr_size
;
5651 fc
->segment_size
= 0;
5653 fc
->code_factor
= LEB ();
5654 fc
->data_factor
= SLEB ();
5664 if (fc
->augmentation
[0] == 'z')
5666 augmentation_data_len
= LEB ();
5667 augmentation_data
= start
;
5668 start
+= augmentation_data_len
;
5669 /* PR 17512: file: 11042-2589-0.004. */
5672 warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len
);
5677 if (augmentation_data_len
)
5681 unsigned char *qend
;
5683 p
= (unsigned char *) fc
->augmentation
+ 1;
5684 q
= augmentation_data
;
5685 qend
= q
+ augmentation_data_len
;
5687 /* PR 17531: file: 015adfaa. */
5690 warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len
);
5691 augmentation_data_len
= 0;
5694 while (p
< end
&& q
< augmentation_data
+ augmentation_data_len
)
5699 q
+= 1 + size_of_encoded_value (*q
);
5701 fc
->fde_encoding
= *q
++;
5708 /* Note - it is OK if this loop terminates with q < qend.
5709 Padding may have been inserted to align the end of the CIE. */
5714 *p_version
= version
;
5717 *p_aug_len
= augmentation_data_len
;
5718 *p_aug
= augmentation_data
;
5724 display_debug_frames (struct dwarf_section
*section
,
5725 void *file ATTRIBUTE_UNUSED
)
5727 unsigned char *start
= section
->start
;
5728 unsigned char *end
= start
+ section
->size
;
5729 unsigned char *section_start
= start
;
5730 Frame_Chunk
*chunks
= 0, *forward_refs
= 0;
5731 Frame_Chunk
*remembered_state
= 0;
5733 int is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
5734 unsigned int length_return
;
5735 unsigned int max_regs
= 0;
5736 const char *bad_reg
= _("bad register: ");
5737 unsigned int saved_eh_addr_size
= eh_addr_size
;
5739 printf (_("Contents of the %s section:\n"), section
->name
);
5743 unsigned char *saved_start
;
5744 unsigned char *block_end
;
5749 int need_col_headers
= 1;
5750 unsigned char *augmentation_data
= NULL
;
5751 unsigned long augmentation_data_len
= 0;
5752 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
5753 unsigned int offset_size
;
5754 unsigned int initial_length_size
;
5756 saved_start
= start
;
5758 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
5762 printf ("\n%08lx ZERO terminator\n\n",
5763 (unsigned long)(saved_start
- section_start
));
5764 /* Skip any zero terminators that directly follow.
5765 A corrupt section size could have loaded a whole
5766 slew of zero filled memory bytes. eg
5767 PR 17512: file: 070-19381-0.004. */
5768 while (start
< end
&& * start
== 0)
5773 if (length
== 0xffffffff)
5775 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
5777 initial_length_size
= 12;
5782 initial_length_size
= 4;
5785 block_end
= saved_start
+ length
+ initial_length_size
;
5786 if (block_end
> end
|| block_end
< start
)
5788 warn ("Invalid length 0x%s in FDE at %#08lx\n",
5789 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
5790 (unsigned long) (saved_start
- section_start
));
5794 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
5796 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
5797 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
5802 start
= read_cie (start
, end
, &cie
, &version
,
5803 &augmentation_data_len
, &augmentation_data
);
5804 /* PR 17512: file: 027-135133-0.005. */
5811 fc
->chunk_start
= saved_start
;
5812 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5815 if (frame_need_space (fc
, mreg
) < 0)
5817 if (fc
->fde_encoding
)
5818 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5820 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
5821 print_dwarf_vma (length
, fc
->ptr_size
);
5822 print_dwarf_vma (cie_id
, offset_size
);
5824 if (do_debug_frames_interp
)
5826 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
5827 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
5832 printf (" Version: %d\n", version
);
5833 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
5836 printf (" Pointer Size: %u\n", fc
->ptr_size
);
5837 printf (" Segment Size: %u\n", fc
->segment_size
);
5839 printf (" Code alignment factor: %u\n", fc
->code_factor
);
5840 printf (" Data alignment factor: %d\n", fc
->data_factor
);
5841 printf (" Return address column: %d\n", fc
->ra
);
5843 if (augmentation_data_len
)
5847 printf (" Augmentation data: ");
5848 for (i
= 0; i
< augmentation_data_len
; ++i
)
5849 /* FIXME: If do_wide is FALSE, then we should
5850 add carriage returns at 80 columns... */
5851 printf (" %02x", augmentation_data
[i
]);
5859 unsigned char *look_for
;
5860 static Frame_Chunk fde_fc
;
5861 unsigned long segment_selector
;
5865 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
5866 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
5869 look_for
= section_start
+ cie_id
;
5871 if (look_for
<= saved_start
)
5873 for (cie
= chunks
; cie
; cie
= cie
->next
)
5874 if (cie
->chunk_start
== look_for
)
5879 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
5880 if (cie
->chunk_start
== look_for
)
5884 unsigned int off_size
;
5885 unsigned char *cie_scan
;
5887 cie_scan
= look_for
;
5889 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
5890 if (length
== 0xffffffff)
5892 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
5899 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
5902 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
5903 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
5908 read_cie (cie_scan
, end
, &cie
, &version
,
5909 &augmentation_data_len
, &augmentation_data
);
5910 /* PR 17512: file: 3450-2098-0.004. */
5913 warn (_("Failed to read CIE information\n"));
5916 cie
->next
= forward_refs
;
5918 cie
->chunk_start
= look_for
;
5919 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
5922 if (frame_need_space (cie
, mreg
) < 0)
5924 warn (_("Invalid max register\n"));
5927 if (cie
->fde_encoding
)
5929 = size_of_encoded_value (cie
->fde_encoding
);
5936 memset (fc
, 0, sizeof (Frame_Chunk
));
5940 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
5941 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
5942 (unsigned long) (saved_start
- section_start
));
5944 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
5945 fc
->col_offset
= (int *) xmalloc (sizeof (int));
5946 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
5948 warn (_("Invalid max register\n"));
5952 fc
->augmentation
= "";
5953 fc
->fde_encoding
= 0;
5954 fc
->ptr_size
= eh_addr_size
;
5955 fc
->segment_size
= 0;
5959 fc
->ncols
= cie
->ncols
;
5960 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
5961 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
5962 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
5963 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
5964 fc
->augmentation
= cie
->augmentation
;
5965 fc
->ptr_size
= cie
->ptr_size
;
5966 eh_addr_size
= cie
->ptr_size
;
5967 fc
->segment_size
= cie
->segment_size
;
5968 fc
->code_factor
= cie
->code_factor
;
5969 fc
->data_factor
= cie
->data_factor
;
5970 fc
->cfa_reg
= cie
->cfa_reg
;
5971 fc
->cfa_offset
= cie
->cfa_offset
;
5973 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
5975 warn (_("Invalid max register\n"));
5978 fc
->fde_encoding
= cie
->fde_encoding
;
5981 if (fc
->fde_encoding
)
5982 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
5984 segment_selector
= 0;
5985 if (fc
->segment_size
)
5987 if (fc
->segment_size
> sizeof (segment_selector
))
5989 /* PR 17512: file: 9e196b3e. */
5990 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
5991 fc
->segment_size
= 4;
5993 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
5996 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
5998 /* FIXME: It appears that sometimes the final pc_range value is
5999 encoded in less than encoded_ptr_size bytes. See the x86_64
6000 run of the "objcopy on compressed debug sections" test for an
6002 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
6004 if (cie
->augmentation
[0] == 'z')
6006 augmentation_data_len
= LEB ();
6007 augmentation_data
= start
;
6008 start
+= augmentation_data_len
;
6009 /* PR 17512: file: 722-8446-0.004. */
6010 if (start
>= end
|| ((signed long) augmentation_data_len
) < 0)
6012 warn (_("Corrupt augmentation data length: %lx\n"),
6013 augmentation_data_len
);
6015 augmentation_data
= NULL
;
6016 augmentation_data_len
= 0;
6020 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
6021 (unsigned long)(saved_start
- section_start
),
6022 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
6023 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
6024 (unsigned long)(cie
->chunk_start
- section_start
));
6026 if (fc
->segment_size
)
6027 printf ("%04lx:", segment_selector
);
6030 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
6031 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
6033 if (! do_debug_frames_interp
&& augmentation_data_len
)
6037 printf (" Augmentation data: ");
6038 for (i
= 0; i
< augmentation_data_len
; ++i
)
6039 printf (" %02x", augmentation_data
[i
]);
6045 /* At this point, fc is the current chunk, cie (if any) is set, and
6046 we're about to interpret instructions for the chunk. */
6047 /* ??? At present we need to do this always, since this sizes the
6048 fc->col_type and fc->col_offset arrays, which we write into always.
6049 We should probably split the interpreted and non-interpreted bits
6050 into two different routines, since there's so much that doesn't
6051 really overlap between them. */
6052 if (1 || do_debug_frames_interp
)
6054 /* Start by making a pass over the chunk, allocating storage
6055 and taking note of what registers are used. */
6056 unsigned char *tmp
= start
;
6058 while (start
< block_end
)
6060 unsigned int reg
, op
, opa
;
6062 unsigned char * new_start
;
6069 /* Warning: if you add any more cases to this switch, be
6070 sure to add them to the corresponding switch below. */
6073 case DW_CFA_advance_loc
:
6077 if (frame_need_space (fc
, opa
) >= 0)
6078 fc
->col_type
[opa
] = DW_CFA_undefined
;
6080 case DW_CFA_restore
:
6081 if (frame_need_space (fc
, opa
) >= 0)
6082 fc
->col_type
[opa
] = DW_CFA_undefined
;
6084 case DW_CFA_set_loc
:
6085 start
+= encoded_ptr_size
;
6087 case DW_CFA_advance_loc1
:
6090 case DW_CFA_advance_loc2
:
6093 case DW_CFA_advance_loc4
:
6096 case DW_CFA_offset_extended
:
6097 case DW_CFA_val_offset
:
6098 reg
= LEB (); LEB ();
6099 if (frame_need_space (fc
, reg
) >= 0)
6100 fc
->col_type
[reg
] = DW_CFA_undefined
;
6102 case DW_CFA_restore_extended
:
6104 if (frame_need_space (fc
, reg
) >= 0)
6105 fc
->col_type
[reg
] = DW_CFA_undefined
;
6107 case DW_CFA_undefined
:
6109 if (frame_need_space (fc
, reg
) >= 0)
6110 fc
->col_type
[reg
] = DW_CFA_undefined
;
6112 case DW_CFA_same_value
:
6114 if (frame_need_space (fc
, reg
) >= 0)
6115 fc
->col_type
[reg
] = DW_CFA_undefined
;
6117 case DW_CFA_register
:
6118 reg
= LEB (); LEB ();
6119 if (frame_need_space (fc
, reg
) >= 0)
6120 fc
->col_type
[reg
] = DW_CFA_undefined
;
6122 case DW_CFA_def_cfa
:
6125 case DW_CFA_def_cfa_register
:
6128 case DW_CFA_def_cfa_offset
:
6131 case DW_CFA_def_cfa_expression
:
6133 new_start
= start
+ temp
;
6134 if (new_start
< start
)
6136 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
6142 case DW_CFA_expression
:
6143 case DW_CFA_val_expression
:
6146 new_start
= start
+ temp
;
6147 if (new_start
< start
)
6149 /* PR 17512: file:306-192417-0.005. */
6150 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
6155 if (frame_need_space (fc
, reg
) >= 0)
6156 fc
->col_type
[reg
] = DW_CFA_undefined
;
6158 case DW_CFA_offset_extended_sf
:
6159 case DW_CFA_val_offset_sf
:
6160 reg
= LEB (); SLEB ();
6161 if (frame_need_space (fc
, reg
) >= 0)
6162 fc
->col_type
[reg
] = DW_CFA_undefined
;
6164 case DW_CFA_def_cfa_sf
:
6167 case DW_CFA_def_cfa_offset_sf
:
6170 case DW_CFA_MIPS_advance_loc8
:
6173 case DW_CFA_GNU_args_size
:
6176 case DW_CFA_GNU_negative_offset_extended
:
6177 reg
= LEB (); LEB ();
6178 if (frame_need_space (fc
, reg
) >= 0)
6179 fc
->col_type
[reg
] = DW_CFA_undefined
;
6188 /* Now we know what registers are used, make a second pass over
6189 the chunk, this time actually printing out the info. */
6191 while (start
< block_end
)
6193 unsigned char * tmp
;
6195 unsigned long ul
, reg
, roffs
;
6199 const char *reg_prefix
= "";
6206 /* Warning: if you add any more cases to this switch, be
6207 sure to add them to the corresponding switch above. */
6210 case DW_CFA_advance_loc
:
6211 if (do_debug_frames_interp
)
6212 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6214 printf (" DW_CFA_advance_loc: %d to %s\n",
6215 opa
* fc
->code_factor
,
6216 dwarf_vmatoa_1 (NULL
,
6217 fc
->pc_begin
+ opa
* fc
->code_factor
,
6219 fc
->pc_begin
+= opa
* fc
->code_factor
;
6224 if (opa
>= (unsigned int) fc
->ncols
)
6225 reg_prefix
= bad_reg
;
6226 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6227 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
6228 reg_prefix
, regname (opa
, 0),
6229 roffs
* fc
->data_factor
);
6230 if (*reg_prefix
== '\0')
6232 fc
->col_type
[opa
] = DW_CFA_offset
;
6233 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
6237 case DW_CFA_restore
:
6238 if (opa
>= (unsigned int) cie
->ncols
6239 || opa
>= (unsigned int) fc
->ncols
)
6240 reg_prefix
= bad_reg
;
6241 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6242 printf (" DW_CFA_restore: %s%s\n",
6243 reg_prefix
, regname (opa
, 0));
6244 if (*reg_prefix
== '\0')
6246 fc
->col_type
[opa
] = cie
->col_type
[opa
];
6247 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
6248 if (do_debug_frames_interp
6249 && fc
->col_type
[opa
] == DW_CFA_unreferenced
)
6250 fc
->col_type
[opa
] = DW_CFA_undefined
;
6254 case DW_CFA_set_loc
:
6255 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
6256 if (do_debug_frames_interp
)
6257 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6259 printf (" DW_CFA_set_loc: %s\n",
6260 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
6264 case DW_CFA_advance_loc1
:
6265 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
6266 if (do_debug_frames_interp
)
6267 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6269 printf (" DW_CFA_advance_loc1: %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_loc2
:
6278 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
6279 if (do_debug_frames_interp
)
6280 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6282 printf (" DW_CFA_advance_loc2: %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_advance_loc4
:
6291 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
6292 if (do_debug_frames_interp
)
6293 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6295 printf (" DW_CFA_advance_loc4: %ld to %s\n",
6296 (unsigned long) (ofs
* fc
->code_factor
),
6297 dwarf_vmatoa_1 (NULL
,
6298 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6300 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6303 case DW_CFA_offset_extended
:
6306 if (reg
>= (unsigned int) fc
->ncols
)
6307 reg_prefix
= bad_reg
;
6308 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6309 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
6310 reg_prefix
, regname (reg
, 0),
6311 roffs
* fc
->data_factor
);
6312 if (*reg_prefix
== '\0')
6314 fc
->col_type
[reg
] = DW_CFA_offset
;
6315 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6319 case DW_CFA_val_offset
:
6322 if (reg
>= (unsigned int) fc
->ncols
)
6323 reg_prefix
= bad_reg
;
6324 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6325 printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n",
6326 reg_prefix
, regname (reg
, 0),
6327 roffs
* fc
->data_factor
);
6328 if (*reg_prefix
== '\0')
6330 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6331 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6335 case DW_CFA_restore_extended
:
6337 if (reg
>= (unsigned int) cie
->ncols
6338 || reg
>= (unsigned int) fc
->ncols
)
6339 reg_prefix
= bad_reg
;
6340 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6341 printf (" DW_CFA_restore_extended: %s%s\n",
6342 reg_prefix
, regname (reg
, 0));
6343 if (*reg_prefix
== '\0')
6345 fc
->col_type
[reg
] = cie
->col_type
[reg
];
6346 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
6350 case DW_CFA_undefined
:
6352 if (reg
>= (unsigned int) fc
->ncols
)
6353 reg_prefix
= bad_reg
;
6354 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6355 printf (" DW_CFA_undefined: %s%s\n",
6356 reg_prefix
, regname (reg
, 0));
6357 if (*reg_prefix
== '\0')
6359 fc
->col_type
[reg
] = DW_CFA_undefined
;
6360 fc
->col_offset
[reg
] = 0;
6364 case DW_CFA_same_value
:
6366 if (reg
>= (unsigned int) fc
->ncols
)
6367 reg_prefix
= bad_reg
;
6368 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6369 printf (" DW_CFA_same_value: %s%s\n",
6370 reg_prefix
, regname (reg
, 0));
6371 if (*reg_prefix
== '\0')
6373 fc
->col_type
[reg
] = DW_CFA_same_value
;
6374 fc
->col_offset
[reg
] = 0;
6378 case DW_CFA_register
:
6381 if (reg
>= (unsigned int) fc
->ncols
)
6382 reg_prefix
= bad_reg
;
6383 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6385 printf (" DW_CFA_register: %s%s in ",
6386 reg_prefix
, regname (reg
, 0));
6387 puts (regname (roffs
, 0));
6389 if (*reg_prefix
== '\0')
6391 fc
->col_type
[reg
] = DW_CFA_register
;
6392 fc
->col_offset
[reg
] = roffs
;
6396 case DW_CFA_remember_state
:
6397 if (! do_debug_frames_interp
)
6398 printf (" DW_CFA_remember_state\n");
6399 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6400 rs
->cfa_offset
= fc
->cfa_offset
;
6401 rs
->cfa_reg
= fc
->cfa_reg
;
6403 rs
->cfa_exp
= fc
->cfa_exp
;
6404 rs
->ncols
= fc
->ncols
;
6405 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
6406 sizeof (* rs
->col_type
));
6407 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
6408 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
6409 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
6410 rs
->next
= remembered_state
;
6411 remembered_state
= rs
;
6414 case DW_CFA_restore_state
:
6415 if (! do_debug_frames_interp
)
6416 printf (" DW_CFA_restore_state\n");
6417 rs
= remembered_state
;
6420 remembered_state
= rs
->next
;
6421 fc
->cfa_offset
= rs
->cfa_offset
;
6422 fc
->cfa_reg
= rs
->cfa_reg
;
6424 fc
->cfa_exp
= rs
->cfa_exp
;
6425 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
6427 warn (_("Invalid column number in saved frame state\n"));
6431 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
6432 memcpy (fc
->col_offset
, rs
->col_offset
,
6433 rs
->ncols
* sizeof (* rs
->col_offset
));
6434 free (rs
->col_type
);
6435 free (rs
->col_offset
);
6438 else if (do_debug_frames_interp
)
6439 printf ("Mismatched DW_CFA_restore_state\n");
6442 case DW_CFA_def_cfa
:
6443 fc
->cfa_reg
= LEB ();
6444 fc
->cfa_offset
= LEB ();
6446 if (! do_debug_frames_interp
)
6447 printf (" DW_CFA_def_cfa: %s ofs %d\n",
6448 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
6451 case DW_CFA_def_cfa_register
:
6452 fc
->cfa_reg
= LEB ();
6454 if (! do_debug_frames_interp
)
6455 printf (" DW_CFA_def_cfa_register: %s\n",
6456 regname (fc
->cfa_reg
, 0));
6459 case DW_CFA_def_cfa_offset
:
6460 fc
->cfa_offset
= LEB ();
6461 if (! do_debug_frames_interp
)
6462 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
6466 if (! do_debug_frames_interp
)
6467 printf (" DW_CFA_nop\n");
6470 case DW_CFA_def_cfa_expression
:
6472 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
6474 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
6477 if (! do_debug_frames_interp
)
6479 printf (" DW_CFA_def_cfa_expression (");
6480 decode_location_expression (start
, eh_addr_size
, 0, -1,
6488 case DW_CFA_expression
:
6491 if (reg
>= (unsigned int) fc
->ncols
)
6492 reg_prefix
= bad_reg
;
6493 /* PR 17512: file: 069-133014-0.006. */
6494 /* PR 17512: file: 98c02eb4. */
6496 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
6498 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
6501 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6503 printf (" DW_CFA_expression: %s%s (",
6504 reg_prefix
, regname (reg
, 0));
6505 decode_location_expression (start
, eh_addr_size
, 0, -1,
6509 if (*reg_prefix
== '\0')
6510 fc
->col_type
[reg
] = DW_CFA_expression
;
6514 case DW_CFA_val_expression
:
6517 if (reg
>= (unsigned int) fc
->ncols
)
6518 reg_prefix
= bad_reg
;
6520 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
6522 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
6525 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6527 printf (" DW_CFA_val_expression: %s%s (",
6528 reg_prefix
, regname (reg
, 0));
6529 decode_location_expression (start
, eh_addr_size
, 0, -1,
6533 if (*reg_prefix
== '\0')
6534 fc
->col_type
[reg
] = DW_CFA_val_expression
;
6538 case DW_CFA_offset_extended_sf
:
6541 if (frame_need_space (fc
, reg
) < 0)
6542 reg_prefix
= bad_reg
;
6543 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6544 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
6545 reg_prefix
, regname (reg
, 0),
6546 (long)(l
* fc
->data_factor
));
6547 if (*reg_prefix
== '\0')
6549 fc
->col_type
[reg
] = DW_CFA_offset
;
6550 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6554 case DW_CFA_val_offset_sf
:
6557 if (frame_need_space (fc
, reg
) < 0)
6558 reg_prefix
= bad_reg
;
6559 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6560 printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n",
6561 reg_prefix
, regname (reg
, 0),
6562 (long)(l
* fc
->data_factor
));
6563 if (*reg_prefix
== '\0')
6565 fc
->col_type
[reg
] = DW_CFA_val_offset
;
6566 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6570 case DW_CFA_def_cfa_sf
:
6571 fc
->cfa_reg
= LEB ();
6572 fc
->cfa_offset
= SLEB ();
6573 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
6575 if (! do_debug_frames_interp
)
6576 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
6577 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
6580 case DW_CFA_def_cfa_offset_sf
:
6581 fc
->cfa_offset
= SLEB ();
6582 fc
->cfa_offset
*= fc
->data_factor
;
6583 if (! do_debug_frames_interp
)
6584 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
6587 case DW_CFA_MIPS_advance_loc8
:
6588 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
6589 if (do_debug_frames_interp
)
6590 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6592 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
6593 (unsigned long) (ofs
* fc
->code_factor
),
6594 dwarf_vmatoa_1 (NULL
,
6595 fc
->pc_begin
+ ofs
* fc
->code_factor
,
6597 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6600 case DW_CFA_GNU_window_save
:
6601 if (! do_debug_frames_interp
)
6602 printf (" DW_CFA_GNU_window_save\n");
6605 case DW_CFA_GNU_args_size
:
6607 if (! do_debug_frames_interp
)
6608 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
6611 case DW_CFA_GNU_negative_offset_extended
:
6614 if (frame_need_space (fc
, reg
) < 0)
6615 reg_prefix
= bad_reg
;
6616 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
6617 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
6618 reg_prefix
, regname (reg
, 0),
6619 (long)(l
* fc
->data_factor
));
6620 if (*reg_prefix
== '\0')
6622 fc
->col_type
[reg
] = DW_CFA_offset
;
6623 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6628 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
6629 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
6631 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
6636 if (do_debug_frames_interp
)
6637 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6640 eh_addr_size
= saved_eh_addr_size
;
6653 display_gdb_index (struct dwarf_section
*section
,
6654 void *file ATTRIBUTE_UNUSED
)
6656 unsigned char *start
= section
->start
;
6658 uint32_t cu_list_offset
, tu_list_offset
;
6659 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
6660 unsigned int cu_list_elements
, tu_list_elements
;
6661 unsigned int address_table_size
, symbol_table_slots
;
6662 unsigned char *cu_list
, *tu_list
;
6663 unsigned char *address_table
, *symbol_table
, *constant_pool
;
6666 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
6668 printf (_("Contents of the %s section:\n"), section
->name
);
6670 if (section
->size
< 6 * sizeof (uint32_t))
6672 warn (_("Truncated header in the %s section.\n"), section
->name
);
6676 version
= byte_get_little_endian (start
, 4);
6677 printf (_("Version %ld\n"), (long) version
);
6679 /* Prior versions are obsolete, and future versions may not be
6680 backwards compatible. */
6681 if (version
< 3 || version
> 8)
6683 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
6687 warn (_("The address table data in version 3 may be wrong.\n"));
6689 warn (_("Version 4 does not support case insensitive lookups.\n"));
6691 warn (_("Version 5 does not include inlined functions.\n"));
6693 warn (_("Version 6 does not include symbol attributes.\n"));
6694 /* Version 7 indices generated by Gold have bad type unit references,
6695 PR binutils/15021. But we don't know if the index was generated by
6696 Gold or not, so to avoid worrying users with gdb-generated indices
6697 we say nothing for version 7 here. */
6699 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
6700 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
6701 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
6702 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
6703 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
6705 if (cu_list_offset
> section
->size
6706 || tu_list_offset
> section
->size
6707 || address_table_offset
> section
->size
6708 || symbol_table_offset
> section
->size
6709 || constant_pool_offset
> section
->size
)
6711 warn (_("Corrupt header in the %s section.\n"), section
->name
);
6715 /* PR 17531: file: 418d0a8a. */
6716 if (tu_list_offset
< cu_list_offset
)
6718 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
6719 tu_list_offset
, cu_list_offset
);
6723 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
6725 if (address_table_offset
< tu_list_offset
)
6727 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
6728 address_table_offset
, tu_list_offset
);
6732 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
6734 /* PR 17531: file: 18a47d3d. */
6735 if (symbol_table_offset
< address_table_offset
)
6737 warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"),
6738 symbol_table_offset
, address_table_offset
);
6742 address_table_size
= symbol_table_offset
- address_table_offset
;
6744 if (constant_pool_offset
< symbol_table_offset
)
6746 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
6747 constant_pool_offset
, symbol_table_offset
);
6751 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
6753 cu_list
= start
+ cu_list_offset
;
6754 tu_list
= start
+ tu_list_offset
;
6755 address_table
= start
+ address_table_offset
;
6756 symbol_table
= start
+ symbol_table_offset
;
6757 constant_pool
= start
+ constant_pool_offset
;
6759 if (address_table
+ address_table_size
* (2 + 8 + 4) > section
->start
+ section
->size
)
6761 warn (_("Address table extends beyond end of section.\n"));
6765 printf (_("\nCU table:\n"));
6766 for (i
= 0; i
< cu_list_elements
; i
+= 2)
6768 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
6769 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
6771 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
6772 (unsigned long) cu_offset
,
6773 (unsigned long) (cu_offset
+ cu_length
- 1));
6776 printf (_("\nTU table:\n"));
6777 for (i
= 0; i
< tu_list_elements
; i
+= 3)
6779 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
6780 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
6781 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
6783 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
6784 (unsigned long) tu_offset
,
6785 (unsigned long) type_offset
);
6786 print_dwarf_vma (signature
, 8);
6790 printf (_("\nAddress table:\n"));
6791 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
6794 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
6795 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
6796 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
6798 print_dwarf_vma (low
, 8);
6799 print_dwarf_vma (high
, 8);
6800 printf (_("%lu\n"), (unsigned long) cu_index
);
6803 printf (_("\nSymbol table:\n"));
6804 for (i
= 0; i
< symbol_table_slots
; ++i
)
6806 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
6807 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
6808 uint32_t num_cus
, cu
;
6810 if (name_offset
!= 0
6811 || cu_vector_offset
!= 0)
6814 unsigned char * adr
;
6816 adr
= constant_pool
+ name_offset
;
6817 /* PR 17531: file: 5b7b07ad. */
6818 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
6820 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
6821 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
6825 printf ("[%3u] %.*s:", i
,
6826 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
6827 constant_pool
+ name_offset
);
6829 adr
= constant_pool
+ cu_vector_offset
;
6830 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
6832 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
6833 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
6834 cu_vector_offset
, i
);
6838 num_cus
= byte_get_little_endian (adr
, 4);
6840 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
6841 if (num_cus
* 4 < num_cus
6842 || adr
>= section
->start
+ section
->size
6843 || adr
< constant_pool
)
6845 printf ("<invalid number of CUs: %d>\n", num_cus
);
6846 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
6854 for (j
= 0; j
< num_cus
; ++j
)
6857 gdb_index_symbol_kind kind
;
6859 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
6860 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
6861 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
6862 cu
= GDB_INDEX_CU_VALUE (cu
);
6863 /* Convert to TU number if it's for a type unit. */
6864 if (cu
>= cu_list_elements
/ 2)
6865 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
6866 (unsigned long) (cu
- cu_list_elements
/ 2));
6868 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
6870 printf (" [%s, %s]",
6871 is_static
? _("static") : _("global"),
6872 get_gdb_index_symbol_kind_name (kind
));
6884 /* Pre-allocate enough space for the CU/TU sets needed. */
6887 prealloc_cu_tu_list (unsigned int nshndx
)
6889 if (shndx_pool
== NULL
)
6891 shndx_pool_size
= nshndx
;
6892 shndx_pool_used
= 0;
6893 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
6894 sizeof (unsigned int));
6898 shndx_pool_size
= shndx_pool_used
+ nshndx
;
6899 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
6900 sizeof (unsigned int));
6905 add_shndx_to_cu_tu_entry (unsigned int shndx
)
6907 if (shndx_pool_used
>= shndx_pool_size
)
6909 error (_("Internal error: out of space in the shndx pool.\n"));
6912 shndx_pool
[shndx_pool_used
++] = shndx
;
6916 end_cu_tu_entry (void)
6918 if (shndx_pool_used
>= shndx_pool_size
)
6920 error (_("Internal error: out of space in the shndx pool.\n"));
6923 shndx_pool
[shndx_pool_used
++] = 0;
6926 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
6929 get_DW_SECT_short_name (unsigned int dw_sect
)
6931 static char buf
[16];
6939 case DW_SECT_ABBREV
:
6945 case DW_SECT_STR_OFFSETS
:
6947 case DW_SECT_MACINFO
:
6955 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
6959 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
6960 These sections are extensions for Fission.
6961 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
6964 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
6966 unsigned char *phdr
= section
->start
;
6967 unsigned char *limit
= phdr
+ section
->size
;
6968 unsigned char *phash
;
6969 unsigned char *pindex
;
6970 unsigned char *ppool
;
6971 unsigned int version
;
6972 unsigned int ncols
= 0;
6974 unsigned int nslots
;
6977 dwarf_vma signature_high
;
6978 dwarf_vma signature_low
;
6981 /* PR 17512: file: 002-168123-0.004. */
6984 warn (_("Section %s is empty\n"), section
->name
);
6987 /* PR 17512: file: 002-376-0.004. */
6988 if (section
->size
< 24)
6990 warn (_("Section %s is too small to contain a CU/TU header\n"),
6995 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
6997 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
6998 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
6999 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
7002 pindex
= phash
+ nslots
* 8;
7003 ppool
= pindex
+ nslots
* 4;
7005 /* PR 17531: file: 45d69832. */
7006 if (pindex
< phash
|| ppool
< phdr
|| (pindex
== phash
&& nslots
!= 0))
7008 warn (_("Section %s is too small for %d slots\n"),
7009 section
->name
, nslots
);
7015 printf (_("Contents of the %s section:\n\n"), section
->name
);
7016 printf (_(" Version: %d\n"), version
);
7018 printf (_(" Number of columns: %d\n"), ncols
);
7019 printf (_(" Number of used entries: %d\n"), nused
);
7020 printf (_(" Number of slots: %d\n\n"), nslots
);
7023 if (ppool
> limit
|| ppool
< phdr
)
7025 warn (_("Section %s too small for %d hash table entries\n"),
7026 section
->name
, nslots
);
7033 prealloc_cu_tu_list ((limit
- ppool
) / 4);
7034 for (i
= 0; i
< nslots
; i
++)
7036 unsigned char *shndx_list
;
7039 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
7040 if (signature_high
!= 0 || signature_low
!= 0)
7042 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
7043 shndx_list
= ppool
+ j
* 4;
7044 /* PR 17531: file: 705e010d. */
7045 if (shndx_list
< ppool
)
7047 warn (_("Section index pool located before start of section\n"));
7052 printf (_(" [%3d] Signature: 0x%s Sections: "),
7053 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7054 buf
, sizeof (buf
)));
7057 if (shndx_list
>= limit
)
7059 warn (_("Section %s too small for shndx pool\n"),
7063 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
7067 printf (" %d", shndx
);
7069 add_shndx_to_cu_tu_entry (shndx
);
7081 else if (version
== 2)
7084 unsigned int dw_sect
;
7085 unsigned char *ph
= phash
;
7086 unsigned char *pi
= pindex
;
7087 unsigned char *poffsets
= ppool
+ ncols
* 4;
7088 unsigned char *psizes
= poffsets
+ nused
* ncols
* 4;
7089 unsigned char *pend
= psizes
+ nused
* ncols
* 4;
7090 bfd_boolean is_tu_index
;
7091 struct cu_tu_set
*this_set
= NULL
;
7093 unsigned char *prow
;
7095 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
7097 /* PR 17531: file: 0dd159bf.
7098 Check for wraparound with an overlarge ncols value. */
7099 if (poffsets
< ppool
|| (unsigned int) ((poffsets
- ppool
) / 4) != ncols
)
7101 warn (_("Overlarge number of columns: %x\n"), ncols
);
7107 warn (_("Section %s too small for offset and size tables\n"),
7114 printf (_(" Offset table\n"));
7115 printf (" slot %-16s ",
7116 is_tu_index
? _("signature") : _("dwo_id"));
7123 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
7129 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
7136 for (j
= 0; j
< ncols
; j
++)
7138 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7139 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
7144 for (i
= 0; i
< nslots
; i
++)
7146 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
7148 SAFE_BYTE_GET (row
, pi
, 4, limit
);
7151 /* PR 17531: file: a05f6ab3. */
7154 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
7160 memcpy (&this_set
[row
- 1].signature
, ph
, sizeof (uint64_t));
7162 prow
= poffsets
+ (row
- 1) * ncols
* 4;
7163 /* PR 17531: file: b8ce60a8. */
7164 if (prow
< poffsets
|| prow
> limit
)
7166 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
7172 printf (_(" [%3d] 0x%s"),
7173 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7174 buf
, sizeof (buf
)));
7175 for (j
= 0; j
< ncols
; j
++)
7177 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
7179 printf (" %8d", val
);
7182 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7184 /* PR 17531: file: 10796eb3. */
7185 if (dw_sect
>= DW_SECT_MAX
)
7186 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7188 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
7204 printf (_(" Size table\n"));
7205 printf (" slot %-16s ",
7206 is_tu_index
? _("signature") : _("dwo_id"));
7209 for (j
= 0; j
< ncols
; j
++)
7211 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
7213 printf (" %8s", get_DW_SECT_short_name (val
));
7219 for (i
= 0; i
< nslots
; i
++)
7221 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
7223 SAFE_BYTE_GET (row
, pi
, 4, limit
);
7226 prow
= psizes
+ (row
- 1) * ncols
* 4;
7229 printf (_(" [%3d] 0x%s"),
7230 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
7231 buf
, sizeof (buf
)));
7233 for (j
= 0; j
< ncols
; j
++)
7235 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
7237 printf (" %8d", val
);
7240 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
7241 if (dw_sect
>= DW_SECT_MAX
)
7242 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
7244 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
7256 else if (do_display
)
7257 printf (_(" Unsupported version (%d)\n"), version
);
7265 /* Load the CU and TU indexes if present. This will build a list of
7266 section sets that we can use to associate a .debug_info.dwo section
7267 with its associated .debug_abbrev.dwo section in a .dwp file. */
7270 load_cu_tu_indexes (void *file
)
7272 /* If we have already loaded (or tried to load) the CU and TU indexes
7273 then do not bother to repeat the task. */
7274 if (cu_tu_indexes_read
)
7277 if (load_debug_section (dwp_cu_index
, file
))
7278 process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0);
7280 if (load_debug_section (dwp_tu_index
, file
))
7281 process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0);
7283 cu_tu_indexes_read
= 1;
7286 /* Find the set of sections that includes section SHNDX. */
7289 find_cu_tu_set (void *file
, unsigned int shndx
)
7293 load_cu_tu_indexes (file
);
7295 /* Find SHNDX in the shndx pool. */
7296 for (i
= 0; i
< shndx_pool_used
; i
++)
7297 if (shndx_pool
[i
] == shndx
)
7300 if (i
>= shndx_pool_used
)
7303 /* Now backup to find the first entry in the set. */
7304 while (i
> 0 && shndx_pool
[i
- 1] != 0)
7307 return shndx_pool
+ i
;
7310 /* Display a .debug_cu_index or .debug_tu_index section. */
7313 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
7315 return process_cu_tu_index (section
, 1);
7319 display_debug_not_supported (struct dwarf_section
*section
,
7320 void *file ATTRIBUTE_UNUSED
)
7322 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7328 /* Like malloc, 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 cmalloc (size_t nmemb
, size_t size
)
7334 /* Check for overflow. */
7335 if (nmemb
>= ~(size_t) 0 / size
)
7338 return xmalloc (nmemb
* size
);
7341 /* Like xmalloc, but takes two parameters like calloc.
7342 Verifies that the first parameter is not too large.
7343 Note: does *not* initialise the allocated memory to zero. */
7345 xcmalloc (size_t nmemb
, size_t size
)
7347 /* Check for overflow. */
7348 if (nmemb
>= ~(size_t) 0 / size
)
7351 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
7356 return xmalloc (nmemb
* size
);
7359 /* Like xrealloc, but takes three parameters.
7360 Verifies that the second parameter is not too large.
7361 Note: does *not* initialise any new memory to zero. */
7363 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
7365 /* Check for overflow. */
7366 if (nmemb
>= ~(size_t) 0 / size
)
7369 _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
7374 return xrealloc (ptr
, nmemb
* size
);
7377 /* Like xcalloc, but verifies that the first parameter is not too large. */
7379 xcalloc2 (size_t nmemb
, size_t size
)
7381 /* Check for overflow. */
7382 if (nmemb
>= ~(size_t) 0 / size
)
7385 _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
7390 return xcalloc (nmemb
, size
);
7394 free_debug_memory (void)
7400 for (i
= 0; i
< max
; i
++)
7401 free_debug_section ((enum dwarf_section_display_enum
) i
);
7403 if (debug_information
!= NULL
)
7405 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
)
7407 for (i
= 0; i
< num_debug_info_entries
; i
++)
7409 if (!debug_information
[i
].max_loc_offsets
)
7411 free (debug_information
[i
].loc_offsets
);
7412 free (debug_information
[i
].have_frame_base
);
7414 if (!debug_information
[i
].max_range_lists
)
7415 free (debug_information
[i
].range_lists
);
7418 free (debug_information
);
7419 debug_information
= NULL
;
7420 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
7425 dwarf_select_sections_by_names (const char *names
)
7429 const char * option
;
7433 debug_dump_long_opts
;
7435 static const debug_dump_long_opts opts_table
[] =
7437 /* Please keep this table alpha- sorted. */
7438 { "Ranges", & do_debug_ranges
, 1 },
7439 { "abbrev", & do_debug_abbrevs
, 1 },
7440 { "addr", & do_debug_addr
, 1 },
7441 { "aranges", & do_debug_aranges
, 1 },
7442 { "cu_index", & do_debug_cu_index
, 1 },
7443 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
7444 { "frames", & do_debug_frames
, 1 },
7445 { "frames-interp", & do_debug_frames_interp
, 1 },
7446 /* The special .gdb_index section. */
7447 { "gdb_index", & do_gdb_index
, 1 },
7448 { "info", & do_debug_info
, 1 },
7449 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
7450 { "loc", & do_debug_loc
, 1 },
7451 { "macro", & do_debug_macinfo
, 1 },
7452 { "pubnames", & do_debug_pubnames
, 1 },
7453 { "pubtypes", & do_debug_pubtypes
, 1 },
7454 /* This entry is for compatability
7455 with earlier versions of readelf. */
7456 { "ranges", & do_debug_aranges
, 1 },
7457 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
7458 { "str", & do_debug_str
, 1 },
7459 /* These trace_* sections are used by Itanium VMS. */
7460 { "trace_abbrev", & do_trace_abbrevs
, 1 },
7461 { "trace_aranges", & do_trace_aranges
, 1 },
7462 { "trace_info", & do_trace_info
, 1 },
7471 const debug_dump_long_opts
* entry
;
7473 for (entry
= opts_table
; entry
->option
; entry
++)
7475 size_t len
= strlen (entry
->option
);
7477 if (strncmp (p
, entry
->option
, len
) == 0
7478 && (p
[len
] == ',' || p
[len
] == '\0'))
7480 * entry
->variable
|= entry
->val
;
7482 /* The --debug-dump=frames-interp option also
7483 enables the --debug-dump=frames option. */
7484 if (do_debug_frames_interp
)
7485 do_debug_frames
= 1;
7492 if (entry
->option
== NULL
)
7494 warn (_("Unrecognized debug option '%s'\n"), p
);
7495 p
= strchr (p
, ',');
7506 dwarf_select_sections_by_letters (const char *letters
)
7508 unsigned int lindex
= 0;
7510 while (letters
[lindex
])
7511 switch (letters
[lindex
++])
7518 do_debug_abbrevs
= 1;
7522 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
7526 do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
;
7530 do_debug_pubnames
= 1;
7534 do_debug_pubtypes
= 1;
7538 do_debug_aranges
= 1;
7542 do_debug_ranges
= 1;
7546 do_debug_frames_interp
= 1;
7548 do_debug_frames
= 1;
7552 do_debug_macinfo
= 1;
7564 warn (_("Unrecognized debug option '%s'\n"), letters
);
7570 dwarf_select_sections_all (void)
7573 do_debug_abbrevs
= 1;
7574 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
7575 do_debug_pubnames
= 1;
7576 do_debug_pubtypes
= 1;
7577 do_debug_aranges
= 1;
7578 do_debug_ranges
= 1;
7579 do_debug_frames
= 1;
7580 do_debug_macinfo
= 1;
7585 do_trace_abbrevs
= 1;
7586 do_trace_aranges
= 1;
7588 do_debug_cu_index
= 1;
7591 struct dwarf_section_display debug_displays
[] =
7593 { { ".debug_abbrev", ".zdebug_abbrev", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7594 display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
7595 { { ".debug_aranges", ".zdebug_aranges", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7596 display_debug_aranges
, &do_debug_aranges
, TRUE
},
7597 { { ".debug_frame", ".zdebug_frame", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7598 display_debug_frames
, &do_debug_frames
, TRUE
},
7599 { { ".debug_info", ".zdebug_info", NULL
, NULL
, 0, 0, abbrev
, NULL
, 0, NULL
},
7600 display_debug_info
, &do_debug_info
, TRUE
},
7601 { { ".debug_line", ".zdebug_line", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7602 display_debug_lines
, &do_debug_lines
, TRUE
},
7603 { { ".debug_pubnames", ".zdebug_pubnames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7604 display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
7605 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7606 display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
7607 { { ".eh_frame", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7608 display_debug_frames
, &do_debug_frames
, TRUE
},
7609 { { ".debug_macinfo", ".zdebug_macinfo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7610 display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
7611 { { ".debug_macro", ".zdebug_macro", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7612 display_debug_macro
, &do_debug_macinfo
, TRUE
},
7613 { { ".debug_str", ".zdebug_str", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7614 display_debug_str
, &do_debug_str
, FALSE
},
7615 { { ".debug_loc", ".zdebug_loc", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7616 display_debug_loc
, &do_debug_loc
, TRUE
},
7617 { { ".debug_pubtypes", ".zdebug_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7618 display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
7619 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7620 display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
7621 { { ".debug_ranges", ".zdebug_ranges", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7622 display_debug_ranges
, &do_debug_ranges
, TRUE
},
7623 { { ".debug_static_func", ".zdebug_static_func", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7624 display_debug_not_supported
, NULL
, FALSE
},
7625 { { ".debug_static_vars", ".zdebug_static_vars", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7626 display_debug_not_supported
, NULL
, FALSE
},
7627 { { ".debug_types", ".zdebug_types", NULL
, NULL
, 0, 0, abbrev
, NULL
, 0, NULL
},
7628 display_debug_types
, &do_debug_info
, TRUE
},
7629 { { ".debug_weaknames", ".zdebug_weaknames", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7630 display_debug_not_supported
, NULL
, FALSE
},
7631 { { ".gdb_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7632 display_gdb_index
, &do_gdb_index
, FALSE
},
7633 { { ".trace_info", "", NULL
, NULL
, 0, 0, trace_abbrev
, NULL
, 0, NULL
},
7634 display_trace_info
, &do_trace_info
, TRUE
},
7635 { { ".trace_abbrev", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7636 display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
7637 { { ".trace_aranges", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7638 display_debug_aranges
, &do_trace_aranges
, FALSE
},
7639 { { ".debug_info.dwo", ".zdebug_info.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
, 0, NULL
},
7640 display_debug_info
, &do_debug_info
, TRUE
},
7641 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7642 display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
7643 { { ".debug_types.dwo", ".zdebug_types.dwo", NULL
, NULL
, 0, 0, abbrev_dwo
, NULL
, 0, NULL
},
7644 display_debug_types
, &do_debug_info
, TRUE
},
7645 { { ".debug_line.dwo", ".zdebug_line.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7646 display_debug_lines
, &do_debug_lines
, TRUE
},
7647 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7648 display_debug_loc
, &do_debug_loc
, TRUE
},
7649 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7650 display_debug_macro
, &do_debug_macinfo
, TRUE
},
7651 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7652 display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
7653 { { ".debug_str.dwo", ".zdebug_str.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7654 display_debug_str
, &do_debug_str
, TRUE
},
7655 { { ".debug_str_offsets", ".zdebug_str_offsets", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7656 display_debug_str_offsets
, NULL
, FALSE
},
7657 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7658 display_debug_str_offsets
, NULL
, FALSE
},
7659 { { ".debug_addr", ".zdebug_addr", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7660 display_debug_addr
, &do_debug_addr
, TRUE
},
7661 { { ".debug_cu_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7662 display_cu_index
, &do_debug_cu_index
, FALSE
},
7663 { { ".debug_tu_index", "", NULL
, NULL
, 0, 0, 0, NULL
, 0, NULL
},
7664 display_cu_index
, &do_debug_cu_index
, FALSE
},