1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2021 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"
27 #include "elf/common.h"
30 #include "gdb/gdb-index.h"
31 #include "filenames.h"
32 #include "safe-ctype.h"
35 #ifdef HAVE_LIBDEBUGINFOD
36 #include <elfutils/debuginfod.h>
44 #ifndef ENABLE_CHECKING
45 #define ENABLE_CHECKING 0
50 #define MAX(a, b) ((a) > (b) ? (a) : (b))
51 #define MIN(a, b) ((a) < (b) ? (a) : (b))
53 static const char *regname (unsigned int regno
, int row
);
54 static const char *regname_internal_by_table_only (unsigned int regno
);
56 static int have_frame_base
;
57 static int need_base_address
;
59 static unsigned int num_debug_info_entries
= 0;
60 static unsigned int alloc_num_debug_info_entries
= 0;
61 static debug_info
*debug_information
= NULL
;
62 /* Special value for num_debug_info_entries to indicate
63 that the .debug_info section could not be loaded/parsed. */
64 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
66 /* A .debug_info section can contain multiple links to separate
67 DWO object files. We use these structures to record these links. */
75 typedef struct dwo_info
80 struct dwo_info
* next
;
83 static dwo_info
*first_dwo_info
= NULL
;
84 static bool need_dwo_info
;
86 separate_info
* first_separate_info
= NULL
;
88 unsigned int eh_addr_size
;
93 int do_debug_pubnames
;
94 int do_debug_pubtypes
;
98 int do_debug_frames_interp
;
101 int do_debug_str_offsets
;
105 int do_trace_abbrevs
;
106 int do_trace_aranges
;
108 int do_debug_cu_index
;
111 int do_follow_links
= DEFAULT_FOR_FOLLOW_LINKS
;
114 int dwarf_cutoff_level
= -1;
115 unsigned long dwarf_start_die
;
119 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
120 testing whether e.g. a locview list is present. */
121 static const dwarf_vma vm1
= -1;
123 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
124 sections. For version 1 package files, each set is stored in SHNDX_POOL
125 as a zero-terminated list of section indexes comprising one set of debug
126 sections from a .dwo file. */
128 static unsigned int *shndx_pool
= NULL
;
129 static unsigned int shndx_pool_size
= 0;
130 static unsigned int shndx_pool_used
= 0;
132 /* For version 2 package files, each set contains an array of section offsets
133 and an array of section sizes, giving the offset and size of the
134 contribution from a CU or TU within one of the debug sections.
135 When displaying debug info from a package file, we need to use these
136 tables to locate the corresponding contributions to each section. */
141 dwarf_vma section_offsets
[DW_SECT_MAX
];
142 size_t section_sizes
[DW_SECT_MAX
];
145 static int cu_count
= 0;
146 static int tu_count
= 0;
147 static struct cu_tu_set
*cu_sets
= NULL
;
148 static struct cu_tu_set
*tu_sets
= NULL
;
150 static bool load_cu_tu_indexes (void *);
152 /* An array that indicates for a given level of CU nesting whether
153 the latest DW_AT_type seen for that level was a signed type or
155 #define MAX_CU_NESTING (1 << 8)
156 static bool level_type_signed
[MAX_CU_NESTING
];
158 /* Values for do_debug_lines. */
159 #define FLAG_DEBUG_LINES_RAW 1
160 #define FLAG_DEBUG_LINES_DECODED 2
163 size_of_encoded_value (int encoding
)
165 switch (encoding
& 0x7)
168 case 0: return eh_addr_size
;
176 get_encoded_value (unsigned char **pdata
,
178 struct dwarf_section
*section
,
181 unsigned char * data
= * pdata
;
182 unsigned int size
= size_of_encoded_value (encoding
);
185 if (data
>= end
|| size
> (size_t) (end
- data
))
187 warn (_("Encoded value extends past end of section\n"));
192 /* PR 17512: file: 002-829853-0.004. */
195 warn (_("Encoded size of %d is too large to read\n"), size
);
200 /* PR 17512: file: 1085-5603-0.004. */
203 warn (_("Encoded size of 0 is too small to read\n"));
208 if (encoding
& DW_EH_PE_signed
)
209 val
= byte_get_signed (data
, size
);
211 val
= byte_get (data
, size
);
213 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
214 val
+= section
->address
+ (data
- section
->start
);
216 * pdata
= data
+ size
;
220 #if SIZEOF_LONG_LONG > SIZEOF_LONG
222 # define DWARF_VMA_FMT "ll"
223 # define DWARF_VMA_FMT_LONG "%16.16llx"
225 # define DWARF_VMA_FMT "I64"
226 # define DWARF_VMA_FMT_LONG "%016I64x"
229 # define DWARF_VMA_FMT "l"
230 # define DWARF_VMA_FMT_LONG "%16.16lx"
233 /* Convert a dwarf vma value into a string. Returns a pointer to a static
234 buffer containing the converted VALUE. The value is converted according
235 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
236 it specifies the maximum number of bytes to be displayed in the converted
237 value and FMTCH is ignored - hex is always used. */
240 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
242 /* As dwarf_vmatoa is used more then once in a printf call
243 for output, we are cycling through an fixed array of pointers
244 for return address. */
245 static int buf_pos
= 0;
246 static struct dwarf_vmatoa_buf
252 ret
= buf
[buf_pos
++].place
;
253 buf_pos
%= ARRAY_SIZE (buf
);
257 /* Printf does not have a way of specifying a maximum field width for an
258 integer value, so we print the full value into a buffer and then select
259 the precision we need. */
260 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
263 return ret
+ (16 - 2 * num_bytes
);
270 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
272 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
273 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
278 static inline const char *
279 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
281 return dwarf_vmatoa_1 (fmtch
, value
, 0);
284 /* Print a dwarf_vma value (typically an address, offset or length) in
285 hexadecimal format, followed by a space. The length of the VALUE (and
286 hence the precision displayed) is determined by the NUM_BYTES parameter. */
289 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
291 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
294 /* Print a view number in hexadecimal value, with the same width
295 print_dwarf_vma would have printed it with the same num_bytes.
296 Print blanks for zero view, unless force is nonzero. */
299 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
307 assert (value
== (unsigned long) value
);
309 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
311 printf ("%*s", len
+ 1, "");
314 /* Read in a LEB128 encoded value starting at address DATA.
315 If SIGN is true, return a signed LEB128 value.
316 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
317 If STATUS_RETURN is not NULL, return with bit 0 (LSB) set if the
318 terminating byte was not found and with bit 1 set if the value
319 overflows a dwarf_vma.
320 No bytes will be read at address END or beyond. */
323 read_leb128 (unsigned char *data
,
324 const unsigned char *const end
,
326 unsigned int *length_return
,
329 dwarf_vma result
= 0;
330 unsigned int num_read
= 0;
331 unsigned int shift
= 0;
336 unsigned char byte
= *data
++;
337 unsigned char lost
, mask
;
341 if (shift
< CHAR_BIT
* sizeof (result
))
343 result
|= ((dwarf_vma
) (byte
& 0x7f)) << shift
;
344 /* These bits overflowed. */
345 lost
= byte
^ (result
>> shift
);
346 /* And this is the mask of possible overflow bits. */
347 mask
= 0x7f ^ ((dwarf_vma
) 0x7f << shift
>> shift
);
355 if ((lost
& mask
) != (sign
&& (dwarf_signed_vma
) result
< 0 ? mask
: 0))
358 if ((byte
& 0x80) == 0)
361 if (sign
&& shift
< CHAR_BIT
* sizeof (result
) && (byte
& 0x40))
362 result
|= -((dwarf_vma
) 1 << shift
);
367 if (length_return
!= NULL
)
368 *length_return
= num_read
;
369 if (status_return
!= NULL
)
370 *status_return
= status
;
375 /* Read AMOUNT bytes from PTR and store them in VAL.
376 Checks to make sure that the read will not reach or pass END.
377 FUNC chooses whether the value read is unsigned or signed, and may
378 be either byte_get or byte_get_signed. If INC is true, PTR is
379 incremented after reading the value.
380 This macro cannot protect against PTR values derived from user input.
381 The C standard sections 6.5.6 and 6.5.8 say attempts to do so using
382 pointers is undefined behaviour. */
383 #define SAFE_BYTE_GET_INTERNAL(VAL, PTR, AMOUNT, END, FUNC, INC) \
386 size_t amount = (AMOUNT); \
387 if (sizeof (VAL) < amount) \
389 error (ngettext ("internal error: attempt to read %d byte " \
390 "of data in to %d sized variable", \
391 "internal error: attempt to read %d bytes " \
392 "of data in to %d sized variable", \
394 (int) amount, (int) sizeof (VAL)); \
395 amount = sizeof (VAL); \
397 if (ENABLE_CHECKING) \
398 assert ((PTR) <= (END)); \
399 size_t avail = (END) - (PTR); \
402 if (amount > avail) \
407 (VAL) = (FUNC) ((PTR), amount); \
413 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
414 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, false)
416 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
417 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, true)
419 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
420 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, false)
422 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
423 SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, true)
425 typedef struct State_Machine_Registers
434 unsigned char op_index
;
435 unsigned char end_sequence
;
436 /* This variable hold the number of the last entry seen
437 in the File Table. */
438 unsigned int last_file_entry
;
441 static SMR state_machine_regs
;
444 reset_state_machine (int is_stmt
)
446 state_machine_regs
.address
= 0;
447 state_machine_regs
.view
= 0;
448 state_machine_regs
.op_index
= 0;
449 state_machine_regs
.file
= 1;
450 state_machine_regs
.line
= 1;
451 state_machine_regs
.column
= 0;
452 state_machine_regs
.is_stmt
= is_stmt
;
453 state_machine_regs
.basic_block
= 0;
454 state_machine_regs
.end_sequence
= 0;
455 state_machine_regs
.last_file_entry
= 0;
458 /* Handled an extend line op.
459 Returns the number of bytes read. */
462 process_extended_line_op (unsigned char * data
,
466 unsigned char op_code
;
467 size_t len
, header_len
;
469 unsigned char *orig_data
= data
;
472 READ_ULEB (len
, data
, end
);
473 header_len
= data
- orig_data
;
475 if (len
== 0 || data
>= end
|| len
> (size_t) (end
- data
))
477 warn (_("Badly formed extended line op encountered!\n"));
483 printf (_(" Extended opcode %d: "), op_code
);
487 case DW_LNE_end_sequence
:
488 printf (_("End of Sequence\n\n"));
489 reset_state_machine (is_stmt
);
492 case DW_LNE_set_address
:
493 /* PR 17512: file: 002-100480-0.004. */
496 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
497 (unsigned long) len
- 1);
501 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
502 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
503 state_machine_regs
.address
= adr
;
504 state_machine_regs
.view
= 0;
505 state_machine_regs
.op_index
= 0;
508 case DW_LNE_define_file
:
509 printf (_("define new File Table entry\n"));
510 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
511 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
517 l
= strnlen ((char *) data
, end
- data
);
521 READ_ULEB (val
, data
, end
);
522 printf ("%s\t", dwarf_vmatoa ("u", val
));
523 READ_ULEB (val
, data
, end
);
524 printf ("%s\t", dwarf_vmatoa ("u", val
));
525 READ_ULEB (val
, data
, end
);
526 printf ("%s\t", dwarf_vmatoa ("u", val
));
527 printf ("%.*s\n\n", (int) l
, name
);
530 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
>= end
)
531 warn (_("DW_LNE_define_file: Bad opcode length\n"));
534 case DW_LNE_set_discriminator
:
535 READ_ULEB (val
, data
, end
);
536 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val
));
540 case DW_LNE_HP_negate_is_UV_update
:
541 printf ("DW_LNE_HP_negate_is_UV_update\n");
543 case DW_LNE_HP_push_context
:
544 printf ("DW_LNE_HP_push_context\n");
546 case DW_LNE_HP_pop_context
:
547 printf ("DW_LNE_HP_pop_context\n");
549 case DW_LNE_HP_set_file_line_column
:
550 printf ("DW_LNE_HP_set_file_line_column\n");
552 case DW_LNE_HP_set_routine_name
:
553 printf ("DW_LNE_HP_set_routine_name\n");
555 case DW_LNE_HP_set_sequence
:
556 printf ("DW_LNE_HP_set_sequence\n");
558 case DW_LNE_HP_negate_post_semantics
:
559 printf ("DW_LNE_HP_negate_post_semantics\n");
561 case DW_LNE_HP_negate_function_exit
:
562 printf ("DW_LNE_HP_negate_function_exit\n");
564 case DW_LNE_HP_negate_front_end_logical
:
565 printf ("DW_LNE_HP_negate_front_end_logical\n");
567 case DW_LNE_HP_define_proc
:
568 printf ("DW_LNE_HP_define_proc\n");
570 case DW_LNE_HP_source_file_correlation
:
572 unsigned char *edata
= data
+ len
- 1;
574 printf ("DW_LNE_HP_source_file_correlation\n");
580 READ_ULEB (opc
, data
, edata
);
584 case DW_LNE_HP_SFC_formfeed
:
585 printf (" DW_LNE_HP_SFC_formfeed\n");
587 case DW_LNE_HP_SFC_set_listing_line
:
588 READ_ULEB (val
, data
, edata
);
589 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
590 dwarf_vmatoa ("u", val
));
592 case DW_LNE_HP_SFC_associate
:
593 printf (" DW_LNE_HP_SFC_associate ");
594 READ_ULEB (val
, data
, edata
);
595 printf ("(%s", dwarf_vmatoa ("u", val
));
596 READ_ULEB (val
, data
, edata
);
597 printf (",%s", dwarf_vmatoa ("u", val
));
598 READ_ULEB (val
, data
, edata
);
599 printf (",%s)\n", dwarf_vmatoa ("u", val
));
602 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
612 unsigned int rlen
= len
- 1;
614 if (op_code
>= DW_LNE_lo_user
615 /* The test against DW_LNW_hi_user is redundant due to
616 the limited range of the unsigned char data type used
618 /*&& op_code <= DW_LNE_hi_user*/)
619 printf (_("user defined: "));
621 printf (_("UNKNOWN: "));
622 printf (_("length %d ["), rlen
);
624 printf (" %02x", *data
++);
630 return len
+ header_len
;
633 static const unsigned char *
634 fetch_indirect_string (dwarf_vma offset
)
636 struct dwarf_section
*section
= &debug_displays
[str
].section
;
637 const unsigned char * ret
;
639 if (section
->start
== NULL
)
640 return (const unsigned char *) _("<no .debug_str section>");
642 if (offset
>= section
->size
)
644 warn (_("DW_FORM_strp offset too big: 0x%s\n"),
645 dwarf_vmatoa ("x", offset
));
646 return (const unsigned char *) _("<offset is too big>");
649 ret
= section
->start
+ offset
;
650 /* Unfortunately we cannot rely upon the .debug_str section ending with a
651 NUL byte. Since our caller is expecting to receive a well formed C
652 string we test for the lack of a terminating byte here. */
653 if (strnlen ((const char *) ret
, section
->size
- offset
)
654 == section
->size
- offset
)
655 ret
= (const unsigned char *)
656 _("<no NUL byte at end of .debug_str section>");
661 static const unsigned char *
662 fetch_indirect_line_string (dwarf_vma offset
)
664 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
665 const unsigned char * ret
;
667 if (section
->start
== NULL
)
668 return (const unsigned char *) _("<no .debug_line_str section>");
670 if (offset
>= section
->size
)
672 warn (_("DW_FORM_line_strp offset too big: 0x%s\n"),
673 dwarf_vmatoa ("x", offset
));
674 return (const unsigned char *) _("<offset is too big>");
677 ret
= section
->start
+ offset
;
678 /* Unfortunately we cannot rely upon the .debug_line_str section ending
679 with a NUL byte. Since our caller is expecting to receive a well formed
680 C string we test for the lack of a terminating byte here. */
681 if (strnlen ((const char *) ret
, section
->size
- offset
)
682 == section
->size
- offset
)
683 ret
= (const unsigned char *)
684 _("<no NUL byte at end of .debug_line_str section>");
690 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
691 dwarf_vma offset_size
, bool dwo
)
693 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
694 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
695 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
696 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
697 dwarf_vma index_offset
;
698 dwarf_vma str_offset
;
700 unsigned char *curr
= index_section
->start
;
701 unsigned char *end
= curr
+ index_section
->size
;
704 if (index_section
->start
== NULL
)
705 return (dwo
? _("<no .debug_str_offsets.dwo section>")
706 : _("<no .debug_str_offsets section>"));
708 if (str_section
->start
== NULL
)
709 return (dwo
? _("<no .debug_str.dwo section>")
710 : _("<no .debug_str section>"));
712 /* FIXME: We should cache the length... */
713 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
714 if (length
== 0xffffffff)
716 if (offset_size
!= 8)
717 warn (_("Expected offset size of 8 but given %s"), dwarf_vmatoa ("x", offset_size
));
718 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
720 else if (offset_size
!= 4)
722 warn (_("Expected offset size of 4 but given %s"), dwarf_vmatoa ("x", offset_size
));
727 /* This is probably an old style .debug_str_offset section which
728 just contains offsets and no header (and the first offset is 0). */
729 curr
= index_section
->start
;
730 length
= index_section
->size
;
734 /* Skip the version and padding bytes.
735 We assume that they are correct. */
746 && this_set
->section_sizes
[DW_SECT_STR_OFFSETS
] < length
)
747 length
= this_set
->section_sizes
[DW_SECT_STR_OFFSETS
];
749 if (length
> (dwarf_vma
) (end
- curr
))
751 warn (_("index table size too large for section %s vs %s\n"),
752 dwarf_vmatoa ("x", length
),
753 dwarf_vmatoa ("x", index_section
->size
));
757 if (length
< offset_size
)
759 warn (_("index table size %s is too small\n"),
760 dwarf_vmatoa ("x", length
));
761 return _("<table too small>");
765 index_offset
= idx
* offset_size
;
767 if (this_set
!= NULL
)
768 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
770 if (index_offset
>= length
771 || length
- index_offset
< offset_size
)
773 warn (_("DW_FORM_GNU_str_index offset too big: 0x%s vs 0x%s\n"),
774 dwarf_vmatoa ("x", index_offset
),
775 dwarf_vmatoa ("x", length
));
776 return _("<index offset is too big>");
779 str_offset
= byte_get (curr
+ index_offset
, offset_size
);
780 str_offset
-= str_section
->address
;
781 if (str_offset
>= str_section
->size
)
783 warn (_("DW_FORM_GNU_str_index indirect offset too big: 0x%s\n"),
784 dwarf_vmatoa ("x", str_offset
));
785 return _("<indirect index offset is too big>");
788 ret
= (const char *) str_section
->start
+ str_offset
;
789 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
790 Since our caller is expecting to receive a well formed C string we test
791 for the lack of a terminating byte here. */
792 if (strnlen (ret
, str_section
->size
- str_offset
)
793 == str_section
->size
- str_offset
)
794 ret
= (const char *) _("<no NUL byte at end of section>");
800 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
802 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
804 if (section
->start
== NULL
)
805 return (_("<no .debug_addr section>"));
807 if (offset
+ bytes
> section
->size
)
809 warn (_("Offset into section %s too big: 0x%s\n"),
810 section
->name
, dwarf_vmatoa ("x", offset
));
811 return "<offset too big>";
814 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
818 /* FIXME: There are better and more efficient ways to handle
819 these structures. For now though, I just want something that
820 is simple to implement. */
821 /* Records a single attribute in an abbrev. */
822 typedef struct abbrev_attr
824 unsigned long attribute
;
826 bfd_signed_vma implicit_const
;
827 struct abbrev_attr
* next
;
831 /* Records a single abbrev. */
832 typedef struct abbrev_entry
834 unsigned long number
;
837 struct abbrev_attr
* first_attr
;
838 struct abbrev_attr
* last_attr
;
839 struct abbrev_entry
* next
;
843 /* Records a set of abbreviations. */
844 typedef struct abbrev_list
846 abbrev_entry
* first_abbrev
;
847 abbrev_entry
* last_abbrev
;
848 dwarf_vma abbrev_base
;
849 dwarf_vma abbrev_offset
;
850 struct abbrev_list
* next
;
851 unsigned char * start_of_next_abbrevs
;
855 /* Records all the abbrevs found so far. */
856 static struct abbrev_list
* abbrev_lists
= NULL
;
858 typedef struct abbrev_map
865 /* Maps between CU offsets and abbrev sets. */
866 static abbrev_map
* cu_abbrev_map
= NULL
;
867 static unsigned long num_abbrev_map_entries
= 0;
868 static unsigned long next_free_abbrev_map_entry
= 0;
870 #define INITIAL_NUM_ABBREV_MAP_ENTRIES 8
871 #define ABBREV_MAP_ENTRIES_INCREMENT 8
874 record_abbrev_list_for_cu (dwarf_vma start
, dwarf_vma end
, abbrev_list
* list
)
876 if (cu_abbrev_map
== NULL
)
878 num_abbrev_map_entries
= INITIAL_NUM_ABBREV_MAP_ENTRIES
;
879 cu_abbrev_map
= xmalloc (num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
881 else if (next_free_abbrev_map_entry
== num_abbrev_map_entries
)
883 num_abbrev_map_entries
+= ABBREV_MAP_ENTRIES_INCREMENT
;
884 cu_abbrev_map
= xrealloc (cu_abbrev_map
, num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
887 cu_abbrev_map
[next_free_abbrev_map_entry
].start
= start
;
888 cu_abbrev_map
[next_free_abbrev_map_entry
].end
= end
;
889 cu_abbrev_map
[next_free_abbrev_map_entry
].list
= list
;
890 next_free_abbrev_map_entry
++;
894 free_all_abbrevs (void)
898 for (list
= abbrev_lists
; list
!= NULL
;)
900 abbrev_list
* next
= list
->next
;
901 abbrev_entry
* abbrv
;
903 for (abbrv
= list
->first_abbrev
; abbrv
!= NULL
;)
905 abbrev_entry
* next_abbrev
= abbrv
->next
;
908 for (attr
= abbrv
->first_attr
; attr
;)
910 abbrev_attr
*next_attr
= attr
->next
;
928 new_abbrev_list (dwarf_vma abbrev_base
, dwarf_vma abbrev_offset
)
930 abbrev_list
* list
= (abbrev_list
*) xcalloc (sizeof * list
, 1);
932 list
->abbrev_base
= abbrev_base
;
933 list
->abbrev_offset
= abbrev_offset
;
935 list
->next
= abbrev_lists
;
942 find_abbrev_list_by_abbrev_offset (dwarf_vma abbrev_base
,
943 dwarf_vma abbrev_offset
)
947 for (list
= abbrev_lists
; list
!= NULL
; list
= list
->next
)
948 if (list
->abbrev_base
== abbrev_base
949 && list
->abbrev_offset
== abbrev_offset
)
955 /* Find the abbreviation map for the CU that includes OFFSET.
956 OFFSET is an absolute offset from the start of the .debug_info section. */
957 /* FIXME: This function is going to slow down readelf & objdump.
958 Consider using a better algorithm to mitigate this effect. */
961 find_abbrev_map_by_offset (dwarf_vma offset
)
965 for (i
= 0; i
< next_free_abbrev_map_entry
; i
++)
966 if (cu_abbrev_map
[i
].start
<= offset
967 && cu_abbrev_map
[i
].end
> offset
)
968 return cu_abbrev_map
+ i
;
974 add_abbrev (unsigned long number
,
979 abbrev_entry
* entry
;
981 entry
= (abbrev_entry
*) xmalloc (sizeof (*entry
));
983 entry
->number
= number
;
985 entry
->children
= children
;
986 entry
->first_attr
= NULL
;
987 entry
->last_attr
= NULL
;
990 assert (list
!= NULL
);
992 if (list
->first_abbrev
== NULL
)
993 list
->first_abbrev
= entry
;
995 list
->last_abbrev
->next
= entry
;
997 list
->last_abbrev
= entry
;
1001 add_abbrev_attr (unsigned long attribute
,
1003 bfd_signed_vma implicit_const
,
1008 attr
= (abbrev_attr
*) xmalloc (sizeof (*attr
));
1010 attr
->attribute
= attribute
;
1012 attr
->implicit_const
= implicit_const
;
1015 assert (list
!= NULL
&& list
->last_abbrev
!= NULL
);
1017 if (list
->last_abbrev
->first_attr
== NULL
)
1018 list
->last_abbrev
->first_attr
= attr
;
1020 list
->last_abbrev
->last_attr
->next
= attr
;
1022 list
->last_abbrev
->last_attr
= attr
;
1025 /* Processes the (partial) contents of a .debug_abbrev section.
1026 Returns NULL if the end of the section was encountered.
1027 Returns the address after the last byte read if the end of
1028 an abbreviation set was found. */
1030 static unsigned char *
1031 process_abbrev_set (struct dwarf_section
*section
,
1032 dwarf_vma abbrev_base
,
1033 dwarf_vma abbrev_size
,
1034 dwarf_vma abbrev_offset
,
1037 if (abbrev_base
>= section
->size
1038 || abbrev_size
> section
->size
- abbrev_base
)
1040 /* PR 17531: file:4bcd9ce9. */
1041 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than "
1042 "abbrev section size (%lx)\n"),
1043 (unsigned long) (abbrev_base
+ abbrev_size
),
1044 (unsigned long) section
->size
);
1047 if (abbrev_offset
>= abbrev_size
)
1049 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than "
1050 "abbrev section size (%lx)\n"),
1051 (unsigned long) abbrev_offset
,
1052 (unsigned long) abbrev_size
);
1056 unsigned char *start
= section
->start
+ abbrev_base
;
1057 unsigned char *end
= start
+ abbrev_size
;
1058 start
+= abbrev_offset
;
1061 unsigned long entry
;
1063 unsigned long attribute
;
1066 READ_ULEB (entry
, start
, end
);
1068 /* A single zero is supposed to end the set according
1069 to the standard. If there's more, then signal that to
1076 READ_ULEB (tag
, start
, end
);
1080 children
= *start
++;
1082 add_abbrev (entry
, tag
, children
, list
);
1087 /* Initialize it due to a false compiler warning. */
1088 bfd_signed_vma implicit_const
= -1;
1090 READ_ULEB (attribute
, start
, end
);
1094 READ_ULEB (form
, start
, end
);
1098 if (form
== DW_FORM_implicit_const
)
1100 READ_SLEB (implicit_const
, start
, end
);
1105 add_abbrev_attr (attribute
, form
, implicit_const
, list
);
1107 while (attribute
!= 0);
1110 /* Report the missing single zero which ends the section. */
1111 error (_(".debug_abbrev section not zero terminated\n"));
1117 get_TAG_name (unsigned long tag
)
1119 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
1123 static char buffer
[100];
1125 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
1126 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
1128 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
1136 get_FORM_name (unsigned long form
)
1141 return "DW_FORM value: 0";
1143 name
= get_DW_FORM_name (form
);
1146 static char buffer
[100];
1148 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1156 get_IDX_name (unsigned long idx
)
1158 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1162 static char buffer
[100];
1164 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1171 static unsigned char *
1172 display_block (unsigned char *data
,
1174 const unsigned char * const end
, char delimiter
)
1178 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1180 return (unsigned char *) end
;
1182 maxlen
= (dwarf_vma
) (end
- data
);
1183 length
= length
> maxlen
? maxlen
: length
;
1186 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1192 decode_location_expression (unsigned char * data
,
1193 unsigned int pointer_size
,
1194 unsigned int offset_size
,
1197 dwarf_vma cu_offset
,
1198 struct dwarf_section
* section
)
1202 dwarf_signed_vma svalue
;
1203 unsigned char *end
= data
+ length
;
1204 int need_frame_base
= 0;
1213 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1214 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1217 printf ("DW_OP_deref");
1220 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1221 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1224 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1225 printf ("DW_OP_const1s: %ld", (long) svalue
);
1228 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1229 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1232 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1233 printf ("DW_OP_const2s: %ld", (long) svalue
);
1236 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1237 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1240 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1241 printf ("DW_OP_const4s: %ld", (long) svalue
);
1244 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1245 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1246 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1247 printf ("%lu", (unsigned long) uvalue
);
1250 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1251 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1252 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1253 printf ("%ld", (long) svalue
);
1256 READ_ULEB (uvalue
, data
, end
);
1257 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue
));
1260 READ_SLEB (svalue
, data
, end
);
1261 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue
));
1264 printf ("DW_OP_dup");
1267 printf ("DW_OP_drop");
1270 printf ("DW_OP_over");
1273 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1274 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1277 printf ("DW_OP_swap");
1280 printf ("DW_OP_rot");
1283 printf ("DW_OP_xderef");
1286 printf ("DW_OP_abs");
1289 printf ("DW_OP_and");
1292 printf ("DW_OP_div");
1295 printf ("DW_OP_minus");
1298 printf ("DW_OP_mod");
1301 printf ("DW_OP_mul");
1304 printf ("DW_OP_neg");
1307 printf ("DW_OP_not");
1310 printf ("DW_OP_or");
1313 printf ("DW_OP_plus");
1315 case DW_OP_plus_uconst
:
1316 READ_ULEB (uvalue
, data
, end
);
1317 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue
));
1320 printf ("DW_OP_shl");
1323 printf ("DW_OP_shr");
1326 printf ("DW_OP_shra");
1329 printf ("DW_OP_xor");
1332 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1333 printf ("DW_OP_bra: %ld", (long) svalue
);
1336 printf ("DW_OP_eq");
1339 printf ("DW_OP_ge");
1342 printf ("DW_OP_gt");
1345 printf ("DW_OP_le");
1348 printf ("DW_OP_lt");
1351 printf ("DW_OP_ne");
1354 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1355 printf ("DW_OP_skip: %ld", (long) svalue
);
1390 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1425 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1426 regname (op
- DW_OP_reg0
, 1));
1461 READ_SLEB (svalue
, data
, end
);
1462 printf ("DW_OP_breg%d (%s): %s", op
- DW_OP_breg0
,
1463 regname (op
- DW_OP_breg0
, 1), dwarf_vmatoa ("d", svalue
));
1467 READ_ULEB (uvalue
, data
, end
);
1468 printf ("DW_OP_regx: %s (%s)",
1469 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1472 need_frame_base
= 1;
1473 READ_SLEB (svalue
, data
, end
);
1474 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue
));
1477 READ_ULEB (uvalue
, data
, end
);
1478 READ_SLEB (svalue
, data
, end
);
1479 printf ("DW_OP_bregx: %s (%s) %s",
1480 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1481 dwarf_vmatoa ("d", svalue
));
1484 READ_ULEB (uvalue
, data
, end
);
1485 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue
));
1487 case DW_OP_deref_size
:
1488 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1489 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1491 case DW_OP_xderef_size
:
1492 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1493 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1496 printf ("DW_OP_nop");
1499 /* DWARF 3 extensions. */
1500 case DW_OP_push_object_address
:
1501 printf ("DW_OP_push_object_address");
1504 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1505 this ought to be an 8-byte wide computation. */
1506 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1507 printf ("DW_OP_call2: <0x%s>",
1508 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1511 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1512 this ought to be an 8-byte wide computation. */
1513 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1514 printf ("DW_OP_call4: <0x%s>",
1515 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1517 case DW_OP_call_ref
:
1518 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1519 this ought to be an 8-byte wide computation. */
1520 if (dwarf_version
== -1)
1522 printf (_("(DW_OP_call_ref in frame info)"));
1523 /* No way to tell where the next op is, so just bail. */
1524 return need_frame_base
;
1526 if (dwarf_version
== 2)
1528 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1532 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1534 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1536 case DW_OP_form_tls_address
:
1537 printf ("DW_OP_form_tls_address");
1539 case DW_OP_call_frame_cfa
:
1540 printf ("DW_OP_call_frame_cfa");
1542 case DW_OP_bit_piece
:
1543 printf ("DW_OP_bit_piece: ");
1544 READ_ULEB (uvalue
, data
, end
);
1545 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue
));
1546 READ_ULEB (uvalue
, data
, end
);
1547 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue
));
1550 /* DWARF 4 extensions. */
1551 case DW_OP_stack_value
:
1552 printf ("DW_OP_stack_value");
1555 case DW_OP_implicit_value
:
1556 printf ("DW_OP_implicit_value");
1557 READ_ULEB (uvalue
, data
, end
);
1558 data
= display_block (data
, uvalue
, end
, ' ');
1561 /* GNU extensions. */
1562 case DW_OP_GNU_push_tls_address
:
1563 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1565 case DW_OP_GNU_uninit
:
1566 printf ("DW_OP_GNU_uninit");
1567 /* FIXME: Is there data associated with this OP ? */
1569 case DW_OP_GNU_encoded_addr
:
1576 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1578 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1579 print_dwarf_vma (addr
, pointer_size
);
1582 case DW_OP_implicit_pointer
:
1583 case DW_OP_GNU_implicit_pointer
:
1584 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1585 this ought to be an 8-byte wide computation. */
1586 if (dwarf_version
== -1)
1588 printf (_("(%s in frame info)"),
1589 (op
== DW_OP_implicit_pointer
1590 ? "DW_OP_implicit_pointer"
1591 : "DW_OP_GNU_implicit_pointer"));
1592 /* No way to tell where the next op is, so just bail. */
1593 return need_frame_base
;
1595 if (dwarf_version
== 2)
1597 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1601 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1603 READ_SLEB (svalue
, data
, end
);
1604 printf ("%s: <0x%s> %s",
1605 (op
== DW_OP_implicit_pointer
1606 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1607 dwarf_vmatoa ("x", uvalue
),
1608 dwarf_vmatoa ("d", svalue
));
1610 case DW_OP_entry_value
:
1611 case DW_OP_GNU_entry_value
:
1612 READ_ULEB (uvalue
, data
, end
);
1613 /* PR 17531: file: 0cc9cd00. */
1614 if (uvalue
> (dwarf_vma
) (end
- data
))
1615 uvalue
= end
- data
;
1616 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1617 : "DW_OP_GNU_entry_value"));
1618 if (decode_location_expression (data
, pointer_size
, offset_size
,
1619 dwarf_version
, uvalue
,
1620 cu_offset
, section
))
1621 need_frame_base
= 1;
1625 case DW_OP_const_type
:
1626 case DW_OP_GNU_const_type
:
1627 READ_ULEB (uvalue
, data
, end
);
1628 printf ("%s: <0x%s> ",
1629 (op
== DW_OP_const_type
? "DW_OP_const_type"
1630 : "DW_OP_GNU_const_type"),
1631 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1632 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1633 data
= display_block (data
, uvalue
, end
, ' ');
1635 case DW_OP_regval_type
:
1636 case DW_OP_GNU_regval_type
:
1637 READ_ULEB (uvalue
, data
, end
);
1638 printf ("%s: %s (%s)",
1639 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1640 : "DW_OP_GNU_regval_type"),
1641 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1642 READ_ULEB (uvalue
, data
, end
);
1643 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1645 case DW_OP_deref_type
:
1646 case DW_OP_GNU_deref_type
:
1647 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1649 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1650 : "DW_OP_GNU_deref_type"),
1652 READ_ULEB (uvalue
, data
, end
);
1653 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1656 case DW_OP_GNU_convert
:
1657 READ_ULEB (uvalue
, data
, end
);
1658 printf ("%s <0x%s>",
1659 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1660 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1662 case DW_OP_reinterpret
:
1663 case DW_OP_GNU_reinterpret
:
1664 READ_ULEB (uvalue
, data
, end
);
1665 printf ("%s <0x%s>",
1666 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1667 : "DW_OP_GNU_reinterpret"),
1668 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1670 case DW_OP_GNU_parameter_ref
:
1671 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1672 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1673 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1675 case DW_OP_GNU_addr_index
:
1676 READ_ULEB (uvalue
, data
, end
);
1677 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1679 case DW_OP_GNU_const_index
:
1680 READ_ULEB (uvalue
, data
, end
);
1681 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1683 case DW_OP_GNU_variable_value
:
1684 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1685 this ought to be an 8-byte wide computation. */
1686 if (dwarf_version
== -1)
1688 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1689 /* No way to tell where the next op is, so just bail. */
1690 return need_frame_base
;
1692 if (dwarf_version
== 2)
1694 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1698 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1700 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1703 /* HP extensions. */
1704 case DW_OP_HP_is_value
:
1705 printf ("DW_OP_HP_is_value");
1706 /* FIXME: Is there data associated with this OP ? */
1708 case DW_OP_HP_fltconst4
:
1709 printf ("DW_OP_HP_fltconst4");
1710 /* FIXME: Is there data associated with this OP ? */
1712 case DW_OP_HP_fltconst8
:
1713 printf ("DW_OP_HP_fltconst8");
1714 /* FIXME: Is there data associated with this OP ? */
1716 case DW_OP_HP_mod_range
:
1717 printf ("DW_OP_HP_mod_range");
1718 /* FIXME: Is there data associated with this OP ? */
1720 case DW_OP_HP_unmod_range
:
1721 printf ("DW_OP_HP_unmod_range");
1722 /* FIXME: Is there data associated with this OP ? */
1725 printf ("DW_OP_HP_tls");
1726 /* FIXME: Is there data associated with this OP ? */
1729 /* PGI (STMicroelectronics) extensions. */
1730 case DW_OP_PGI_omp_thread_num
:
1731 /* Pushes the thread number for the current thread as it would be
1732 returned by the standard OpenMP library function:
1733 omp_get_thread_num(). The "current thread" is the thread for
1734 which the expression is being evaluated. */
1735 printf ("DW_OP_PGI_omp_thread_num");
1739 if (op
>= DW_OP_lo_user
1740 && op
<= DW_OP_hi_user
)
1741 printf (_("(User defined location op 0x%x)"), op
);
1743 printf (_("(Unknown location op 0x%x)"), op
);
1744 /* No way to tell where the next op is, so just bail. */
1745 return need_frame_base
;
1748 /* Separate the ops. */
1753 return need_frame_base
;
1756 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1757 This is used for DWARF package files. */
1759 static struct cu_tu_set
*
1760 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1762 struct cu_tu_set
*p
;
1764 unsigned int dw_sect
;
1770 dw_sect
= DW_SECT_TYPES
;
1776 dw_sect
= DW_SECT_INFO
;
1780 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1789 fetch_alt_indirect_string (dwarf_vma offset
)
1793 if (! do_follow_links
)
1796 if (first_separate_info
== NULL
)
1797 return _("<no links available>");
1799 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1801 struct dwarf_section
* section
;
1804 if (! load_debug_section (separate_debug_str
, i
->handle
))
1807 section
= &debug_displays
[separate_debug_str
].section
;
1809 if (section
->start
== NULL
)
1812 if (offset
>= section
->size
)
1815 ret
= (const char *) (section
->start
+ offset
);
1816 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1817 NUL byte. Since our caller is expecting to receive a well formed C
1818 string we test for the lack of a terminating byte here. */
1819 if (strnlen ((const char *) ret
, section
->size
- offset
)
1820 == section
->size
- offset
)
1821 return _("<no NUL byte at end of alt .debug_str section>");
1826 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1827 dwarf_vmatoa ("x", offset
));
1828 return _("<offset is too big>");
1832 get_AT_name (unsigned long attribute
)
1837 return "DW_AT value: 0";
1839 /* One value is shared by the MIPS and HP extensions: */
1840 if (attribute
== DW_AT_MIPS_fde
)
1841 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1843 name
= get_DW_AT_name (attribute
);
1847 static char buffer
[100];
1849 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1858 add_dwo_info (const char * value
, dwarf_vma cu_offset
, dwo_type type
)
1860 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1862 dwinfo
->type
= type
;
1863 dwinfo
->value
= value
;
1864 dwinfo
->cu_offset
= cu_offset
;
1865 dwinfo
->next
= first_dwo_info
;
1866 first_dwo_info
= dwinfo
;
1870 add_dwo_name (const char * name
, dwarf_vma cu_offset
)
1872 add_dwo_info (name
, cu_offset
, DWO_NAME
);
1876 add_dwo_dir (const char * dir
, dwarf_vma cu_offset
)
1878 add_dwo_info (dir
, cu_offset
, DWO_DIR
);
1882 add_dwo_id (const char * id
, dwarf_vma cu_offset
)
1884 add_dwo_info (id
, cu_offset
, DWO_ID
);
1888 free_dwo_info (void)
1893 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1895 next
= dwinfo
->next
;
1898 first_dwo_info
= NULL
;
1901 /* Ensure that START + UVALUE is less than END.
1902 Return an adjusted UVALUE if necessary to ensure this relationship. */
1904 static inline dwarf_vma
1905 check_uvalue (const unsigned char * start
,
1907 const unsigned char * end
)
1909 dwarf_vma max_uvalue
= end
- start
;
1911 /* See PR 17512: file: 008-103549-0.001:0.1.
1912 and PR 24829 for examples of where these tests are triggered. */
1913 if (uvalue
> max_uvalue
)
1915 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1916 uvalue
= max_uvalue
;
1922 static unsigned char *
1923 skip_attr_bytes (unsigned long form
,
1924 unsigned char *data
,
1926 dwarf_vma pointer_size
,
1927 dwarf_vma offset_size
,
1929 dwarf_vma
*value_return
)
1931 dwarf_signed_vma svalue
;
1932 dwarf_vma uvalue
= 0;
1939 case DW_FORM_ref_addr
:
1940 if (dwarf_version
== 2)
1941 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1942 else if (dwarf_version
> 2)
1943 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1949 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1953 case DW_FORM_line_strp
:
1954 case DW_FORM_sec_offset
:
1955 case DW_FORM_GNU_ref_alt
:
1956 case DW_FORM_GNU_strp_alt
:
1957 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1960 case DW_FORM_flag_present
:
1968 case DW_FORM_addrx1
:
1969 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1973 case DW_FORM_addrx3
:
1974 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
1980 case DW_FORM_addrx2
:
1981 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1987 case DW_FORM_addrx4
:
1988 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1992 READ_SLEB (svalue
, data
, end
);
1996 case DW_FORM_ref_udata
:
1998 case DW_FORM_GNU_str_index
:
2000 case DW_FORM_GNU_addr_index
:
2002 READ_ULEB (uvalue
, data
, end
);
2006 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2010 case DW_FORM_ref_sig8
:
2014 case DW_FORM_data16
:
2018 case DW_FORM_string
:
2019 inc
= strnlen ((char *) data
, end
- data
) + 1;
2023 case DW_FORM_exprloc
:
2024 READ_ULEB (uvalue
, data
, end
);
2028 case DW_FORM_block1
:
2029 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2033 case DW_FORM_block2
:
2034 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2038 case DW_FORM_block4
:
2039 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2043 case DW_FORM_indirect
:
2044 READ_ULEB (form
, data
, end
);
2045 if (form
== DW_FORM_implicit_const
)
2046 SKIP_ULEB (data
, end
);
2047 return skip_attr_bytes (form
, data
, end
, pointer_size
, offset_size
,
2048 dwarf_version
, value_return
);
2054 * value_return
= uvalue
;
2055 if (inc
<= (dwarf_vma
) (end
- data
))
2062 /* Given form FORM with value UVALUE, locate and return the abbreviation
2063 associated with it. */
2065 static abbrev_entry
*
2066 get_type_abbrev_from_form (unsigned long form
,
2067 unsigned long uvalue
,
2068 dwarf_vma cu_offset
,
2069 const struct dwarf_section
*section
,
2070 unsigned long *abbrev_num_return
,
2071 unsigned char **data_return
,
2072 abbrev_map
**map_return
)
2074 unsigned long abbrev_number
;
2076 abbrev_entry
* entry
;
2077 unsigned char * data
;
2079 if (abbrev_num_return
!= NULL
)
2080 * abbrev_num_return
= 0;
2081 if (data_return
!= NULL
)
2082 * data_return
= NULL
;
2086 case DW_FORM_GNU_ref_alt
:
2087 case DW_FORM_ref_sig8
:
2088 /* FIXME: We are unable to handle this form at the moment. */
2091 case DW_FORM_ref_addr
:
2092 if (uvalue
>= section
->size
)
2094 warn (_("Unable to resolve ref_addr form: uvalue %lx > section size %lx (%s)\n"),
2095 uvalue
, (long) section
->size
, section
->name
);
2100 case DW_FORM_ref_sup4
:
2101 case DW_FORM_ref_sup8
:
2108 case DW_FORM_ref_udata
:
2109 if (uvalue
+ cu_offset
> section
->size
)
2111 warn (_("Unable to resolve ref form: uvalue %lx + cu_offset %lx > section size %lx\n"),
2112 uvalue
, (long) cu_offset
, (long) section
->size
);
2115 uvalue
+= cu_offset
;
2118 /* FIXME: Are there other DW_FORMs that can be used by types ? */
2121 warn (_("Unexpected form %lx encountered whilst finding abbreviation for type\n"), form
);
2125 data
= (unsigned char *) section
->start
+ uvalue
;
2126 map
= find_abbrev_map_by_offset (uvalue
);
2130 warn (_("Unable to find abbreviations for CU offset %#lx\n"), uvalue
);
2133 if (map
->list
== NULL
)
2135 warn (_("Empty abbreviation list encountered for CU offset %lx\n"), uvalue
);
2139 if (map_return
!= NULL
)
2141 if (form
== DW_FORM_ref_addr
)
2147 READ_ULEB (abbrev_number
, data
, section
->start
+ section
->size
);
2149 for (entry
= map
->list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2150 if (entry
->number
== abbrev_number
)
2153 if (abbrev_num_return
!= NULL
)
2154 * abbrev_num_return
= abbrev_number
;
2156 if (data_return
!= NULL
)
2157 * data_return
= data
;
2160 warn (_("Unable to find entry for abbreviation %lu\n"), abbrev_number
);
2165 /* Return IS_SIGNED set to TRUE if the type using abbreviation ENTRY
2166 can be determined to be a signed type. The data for ENTRY can be
2167 found starting at DATA. */
2170 get_type_signedness (abbrev_entry
*entry
,
2171 const struct dwarf_section
*section
,
2172 unsigned char *data
,
2174 dwarf_vma cu_offset
,
2175 dwarf_vma pointer_size
,
2176 dwarf_vma offset_size
,
2179 unsigned int nesting
)
2183 * is_signed
= false;
2185 #define MAX_NESTING 20
2186 if (nesting
> MAX_NESTING
)
2188 /* FIXME: Warn - or is this expected ?
2189 NB/ We need to avoid infinite recursion. */
2193 for (attr
= entry
->first_attr
;
2194 attr
!= NULL
&& attr
->attribute
;
2197 unsigned char * orig_data
= data
;
2198 dwarf_vma uvalue
= 0;
2200 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
2201 offset_size
, dwarf_version
, & uvalue
);
2205 switch (attr
->attribute
)
2207 case DW_AT_linkage_name
:
2211 if (attr
->form
== DW_FORM_strp
)
2212 printf (", %s", fetch_indirect_string (uvalue
));
2213 else if (attr
->form
== DW_FORM_string
)
2214 printf (", %s", orig_data
);
2221 abbrev_entry
*type_abbrev
;
2222 unsigned char *type_data
;
2225 type_abbrev
= get_type_abbrev_from_form (attr
->form
,
2229 NULL
/* abbrev num return */,
2232 if (type_abbrev
== NULL
)
2235 get_type_signedness (type_abbrev
, section
, type_data
,
2236 map
? section
->start
+ map
->end
: end
,
2237 map
? map
->start
: cu_offset
,
2238 pointer_size
, offset_size
, dwarf_version
,
2239 is_signed
, nesting
+ 1);
2243 case DW_AT_encoding
:
2244 /* Determine signness. */
2247 case DW_ATE_address
:
2248 /* FIXME - some architectures have signed addresses. */
2249 case DW_ATE_boolean
:
2250 case DW_ATE_unsigned
:
2251 case DW_ATE_unsigned_char
:
2252 case DW_ATE_unsigned_fixed
:
2253 * is_signed
= false;
2257 case DW_ATE_complex_float
:
2260 case DW_ATE_signed_char
:
2261 case DW_ATE_imaginary_float
:
2262 case DW_ATE_decimal_float
:
2263 case DW_ATE_signed_fixed
:
2273 read_and_print_leb128 (unsigned char *data
,
2274 unsigned int *bytes_read
,
2275 unsigned const char *end
,
2279 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2281 report_leb_status (status
, __FILE__
, __LINE__
);
2283 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2287 display_discr_list (unsigned long form
,
2289 unsigned char * data
,
2290 unsigned const char * end
,
2295 printf ("[default]");
2302 case DW_FORM_block1
:
2303 case DW_FORM_block2
:
2304 case DW_FORM_block4
:
2305 /* Move data pointer back to the start of the byte array. */
2309 printf ("<corrupt>\n");
2310 warn (_("corrupt discr_list - not using a block form\n"));
2316 printf ("<corrupt>\n");
2317 warn (_("corrupt discr_list - block not long enough\n"));
2322 (level
> 0 && level
<= MAX_CU_NESTING
)
2323 ? level_type_signed
[level
- 1] : false;
2328 unsigned char discriminant
;
2329 unsigned int bytes_read
;
2331 SAFE_BYTE_GET_AND_INC (discriminant
, data
, 1, end
);
2334 assert (uvalue
> 0);
2335 switch (discriminant
)
2339 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2340 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2341 uvalue
-= bytes_read
;
2347 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2348 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2349 uvalue
-= bytes_read
;
2353 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2354 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2355 uvalue
-= bytes_read
;
2360 printf ("<corrupt>\n");
2361 warn (_("corrupt discr_list - unrecognized discriminant byte %#x\n"),
2371 printf (")(signed)");
2373 printf (")(unsigned)");
2376 static unsigned char *
2377 read_and_display_attr_value (unsigned long attribute
,
2379 dwarf_signed_vma implicit_const
,
2380 unsigned char * start
,
2381 unsigned char * data
,
2382 unsigned char * end
,
2383 dwarf_vma cu_offset
,
2384 dwarf_vma pointer_size
,
2385 dwarf_vma offset_size
,
2387 debug_info
* debug_info_p
,
2389 struct dwarf_section
* section
,
2390 struct cu_tu_set
* this_set
,
2394 dwarf_signed_vma svalue
;
2395 dwarf_vma uvalue
= 0;
2396 dwarf_vma uvalue_hi
= 0;
2397 unsigned char *block_start
= NULL
;
2398 unsigned char *orig_data
= data
;
2400 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2402 warn (_("Corrupt attribute\n"));
2406 if (do_wide
&& ! do_loc
)
2408 /* PR 26847: Display the name of the form. */
2409 const char * name
= get_FORM_name (form
);
2411 /* For convenience we skip the DW_FORM_ prefix to the name. */
2413 name
+= 8; /* strlen ("DW_FORM_") */
2414 printf ("%c(%s)", delimiter
, name
);
2422 case DW_FORM_ref_addr
:
2423 if (dwarf_version
== 2)
2424 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2425 else if (dwarf_version
> 2)
2426 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2428 error (_("Internal error: DW_FORM_ref_addr is not supported in DWARF version 1.\n"));
2432 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2435 case DW_FORM_strp_sup
:
2437 case DW_FORM_line_strp
:
2438 case DW_FORM_sec_offset
:
2439 case DW_FORM_GNU_ref_alt
:
2440 case DW_FORM_GNU_strp_alt
:
2441 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2444 case DW_FORM_flag_present
:
2452 case DW_FORM_addrx1
:
2453 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2459 case DW_FORM_addrx2
:
2460 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2464 case DW_FORM_addrx3
:
2465 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
2468 case DW_FORM_ref_sup4
:
2472 case DW_FORM_addrx4
:
2473 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2476 case DW_FORM_ref_sup8
:
2479 case DW_FORM_ref_sig8
:
2480 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2483 case DW_FORM_data16
:
2484 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2485 SAFE_BYTE_GET_AND_INC (uvalue_hi
, data
, 8, end
);
2486 if (byte_get
!= byte_get_little_endian
)
2488 dwarf_vma utmp
= uvalue
;
2495 READ_SLEB (svalue
, data
, end
);
2499 case DW_FORM_GNU_str_index
:
2501 case DW_FORM_ref_udata
:
2503 case DW_FORM_GNU_addr_index
:
2505 READ_ULEB (uvalue
, data
, end
);
2508 case DW_FORM_indirect
:
2509 READ_ULEB (form
, data
, end
);
2511 printf ("%c%s", delimiter
, get_FORM_name (form
));
2512 if (form
== DW_FORM_implicit_const
)
2513 READ_SLEB (implicit_const
, data
, end
);
2514 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2516 cu_offset
, pointer_size
,
2517 offset_size
, dwarf_version
,
2518 debug_info_p
, do_loc
,
2519 section
, this_set
, delimiter
, level
);
2524 case DW_FORM_ref_addr
:
2526 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2529 case DW_FORM_GNU_ref_alt
:
2533 /* We have already printed the form name. */
2534 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2536 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2538 /* FIXME: Follow the reference... */
2544 case DW_FORM_ref_sup4
:
2545 case DW_FORM_ref_udata
:
2547 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2552 case DW_FORM_sec_offset
:
2554 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2557 case DW_FORM_flag_present
:
2564 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2567 case DW_FORM_implicit_const
:
2569 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2572 case DW_FORM_ref_sup8
:
2577 dwarf_vma utmp
= uvalue
;
2578 if (form
== DW_FORM_ref8
)
2580 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", utmp
));
2584 case DW_FORM_data16
:
2587 uvalue_hi
== 0 ? "" : dwarf_vmatoa ("x", uvalue_hi
),
2588 dwarf_vmatoa_1 ("x", uvalue
, uvalue_hi
== 0 ? 0 : 8));
2591 case DW_FORM_string
:
2593 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2594 data
+= strnlen ((char *) data
, end
- data
);
2600 case DW_FORM_exprloc
:
2601 READ_ULEB (uvalue
, data
, end
);
2604 if (block_start
>= end
)
2606 warn (_("Block ends prematurely\n"));
2611 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2614 data
= block_start
+ uvalue
;
2616 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2619 case DW_FORM_block1
:
2620 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2623 case DW_FORM_block2
:
2624 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2627 case DW_FORM_block4
:
2628 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2635 /* We have already displayed the form name. */
2636 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2637 dwarf_vmatoa ("x", uvalue
),
2638 fetch_indirect_string (uvalue
));
2640 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2641 dwarf_vmatoa ("x", uvalue
),
2642 fetch_indirect_string (uvalue
));
2646 case DW_FORM_line_strp
:
2650 /* We have already displayed the form name. */
2651 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2652 dwarf_vmatoa ("x", uvalue
),
2653 fetch_indirect_line_string (uvalue
));
2655 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2656 dwarf_vmatoa ("x", uvalue
),
2657 fetch_indirect_line_string (uvalue
));
2661 case DW_FORM_GNU_str_index
:
2669 const char *suffix
= strrchr (section
->name
, '.');
2670 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
2673 /* We have already displayed the form name. */
2674 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2675 dwarf_vmatoa ("x", uvalue
),
2676 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2678 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2679 dwarf_vmatoa ("x", uvalue
),
2680 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2684 case DW_FORM_GNU_strp_alt
:
2688 /* We have already displayed the form name. */
2689 printf (_("%c(offset: 0x%s) %s"), delimiter
,
2690 dwarf_vmatoa ("x", uvalue
),
2691 fetch_alt_indirect_string (uvalue
));
2693 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2694 dwarf_vmatoa ("x", uvalue
),
2695 fetch_alt_indirect_string (uvalue
));
2699 case DW_FORM_indirect
:
2700 /* Handled above. */
2703 case DW_FORM_ref_sig8
:
2705 printf ("%c%s: 0x%s", delimiter
, do_wide
? "" : "signature",
2706 dwarf_vmatoa ("x", uvalue
));
2709 case DW_FORM_GNU_addr_index
:
2711 case DW_FORM_addrx1
:
2712 case DW_FORM_addrx2
:
2713 case DW_FORM_addrx3
:
2714 case DW_FORM_addrx4
:
2720 if (debug_info_p
== NULL
)
2722 else if (debug_info_p
->addr_base
== DEBUG_INFO_UNAVAILABLE
)
2725 base
= debug_info_p
->addr_base
;
2727 offset
= base
+ uvalue
* pointer_size
;
2730 /* We have already displayed the form name. */
2731 printf (_("%c(index: 0x%s): %s"), delimiter
,
2732 dwarf_vmatoa ("x", uvalue
),
2733 fetch_indexed_value (offset
, pointer_size
));
2735 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2736 dwarf_vmatoa ("x", uvalue
),
2737 fetch_indexed_value (offset
, pointer_size
));
2741 case DW_FORM_strp_sup
:
2743 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2747 warn (_("Unrecognized form: 0x%lx\n"), form
);
2751 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2752 && num_debug_info_entries
== 0
2753 && debug_info_p
!= NULL
)
2757 case DW_AT_frame_base
:
2758 have_frame_base
= 1;
2760 case DW_AT_location
:
2761 case DW_AT_GNU_locviews
:
2762 case DW_AT_string_length
:
2763 case DW_AT_return_addr
:
2764 case DW_AT_data_member_location
:
2765 case DW_AT_vtable_elem_location
:
2767 case DW_AT_static_link
:
2768 case DW_AT_use_location
:
2769 case DW_AT_call_value
:
2770 case DW_AT_GNU_call_site_value
:
2771 case DW_AT_call_data_value
:
2772 case DW_AT_GNU_call_site_data_value
:
2773 case DW_AT_call_target
:
2774 case DW_AT_GNU_call_site_target
:
2775 case DW_AT_call_target_clobbered
:
2776 case DW_AT_GNU_call_site_target_clobbered
:
2777 if ((dwarf_version
< 4
2778 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2779 || form
== DW_FORM_sec_offset
)
2781 /* Process location list. */
2782 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2783 unsigned int num
= debug_info_p
->num_loc_offsets
;
2785 if (lmax
== 0 || num
>= lmax
)
2788 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2789 xcrealloc (debug_info_p
->loc_offsets
,
2790 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2791 debug_info_p
->loc_views
= (dwarf_vma
*)
2792 xcrealloc (debug_info_p
->loc_views
,
2793 lmax
, sizeof (*debug_info_p
->loc_views
));
2794 debug_info_p
->have_frame_base
= (int *)
2795 xcrealloc (debug_info_p
->have_frame_base
,
2796 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2797 debug_info_p
->max_loc_offsets
= lmax
;
2799 if (this_set
!= NULL
)
2800 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2801 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2802 if (attribute
!= DW_AT_GNU_locviews
)
2804 /* Corrupt DWARF info can produce more offsets than views.
2805 See PR 23062 for an example. */
2806 if (debug_info_p
->num_loc_offsets
2807 > debug_info_p
->num_loc_views
)
2808 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2811 debug_info_p
->loc_offsets
[num
] = uvalue
;
2812 debug_info_p
->num_loc_offsets
++;
2817 assert (debug_info_p
->num_loc_views
<= num
);
2818 num
= debug_info_p
->num_loc_views
;
2819 if (num
> debug_info_p
->num_loc_offsets
)
2820 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2823 debug_info_p
->loc_views
[num
] = uvalue
;
2824 debug_info_p
->num_loc_views
++;
2831 if (need_base_address
)
2832 debug_info_p
->base_address
= uvalue
;
2835 case DW_AT_GNU_addr_base
:
2836 case DW_AT_addr_base
:
2837 debug_info_p
->addr_base
= uvalue
;
2840 case DW_AT_GNU_ranges_base
:
2841 debug_info_p
->ranges_base
= uvalue
;
2845 if ((dwarf_version
< 4
2846 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2847 || form
== DW_FORM_sec_offset
)
2849 /* Process range list. */
2850 unsigned int lmax
= debug_info_p
->max_range_lists
;
2851 unsigned int num
= debug_info_p
->num_range_lists
;
2853 if (lmax
== 0 || num
>= lmax
)
2856 debug_info_p
->range_lists
= (dwarf_vma
*)
2857 xcrealloc (debug_info_p
->range_lists
,
2858 lmax
, sizeof (*debug_info_p
->range_lists
));
2859 debug_info_p
->max_range_lists
= lmax
;
2861 debug_info_p
->range_lists
[num
] = uvalue
;
2862 debug_info_p
->num_range_lists
++;
2866 case DW_AT_GNU_dwo_name
:
2867 case DW_AT_dwo_name
:
2872 add_dwo_name ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2874 case DW_FORM_GNU_strp_alt
:
2875 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
), cu_offset
);
2877 case DW_FORM_GNU_str_index
:
2883 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2885 case DW_FORM_string
:
2886 add_dwo_name ((const char *) orig_data
, cu_offset
);
2889 warn (_("Unsupported form (%s) for attribute %s\n"),
2890 get_FORM_name (form
), get_AT_name (attribute
));
2895 case DW_AT_comp_dir
:
2896 /* FIXME: Also extract a build-id in a CU/TU. */
2901 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2903 case DW_FORM_GNU_strp_alt
:
2904 add_dwo_dir (fetch_alt_indirect_string (uvalue
), cu_offset
);
2906 case DW_FORM_line_strp
:
2907 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
), cu_offset
);
2909 case DW_FORM_GNU_str_index
:
2915 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2917 case DW_FORM_string
:
2918 add_dwo_dir ((const char *) orig_data
, cu_offset
);
2921 warn (_("Unsupported form (%s) for attribute %s\n"),
2922 get_FORM_name (form
), get_AT_name (attribute
));
2927 case DW_AT_GNU_dwo_id
:
2932 /* FIXME: Record the length of the ID as well ? */
2933 add_dwo_id ((const char *) (data
- 8), cu_offset
);
2936 warn (_("Unsupported form (%s) for attribute %s\n"),
2937 get_FORM_name (form
), get_AT_name (attribute
));
2947 if (do_loc
|| attribute
== 0)
2950 /* For some attributes we can display further information. */
2954 if (level
>= 0 && level
< MAX_CU_NESTING
2955 && uvalue
< (size_t) (end
- start
))
2957 bool is_signed
= false;
2958 abbrev_entry
*type_abbrev
;
2959 unsigned char *type_data
;
2962 type_abbrev
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
2963 section
, NULL
, &type_data
, &map
);
2964 if (type_abbrev
!= NULL
)
2966 get_type_signedness (type_abbrev
, section
, type_data
,
2967 map
? section
->start
+ map
->end
: end
,
2968 map
? map
->start
: cu_offset
,
2969 pointer_size
, offset_size
, dwarf_version
,
2972 level_type_signed
[level
] = is_signed
;
2980 case DW_INL_not_inlined
:
2981 printf (_("(not inlined)"));
2983 case DW_INL_inlined
:
2984 printf (_("(inlined)"));
2986 case DW_INL_declared_not_inlined
:
2987 printf (_("(declared as inline but ignored)"));
2989 case DW_INL_declared_inlined
:
2990 printf (_("(declared as inline and inlined)"));
2993 printf (_(" (Unknown inline attribute value: %s)"),
2994 dwarf_vmatoa ("x", uvalue
));
2999 case DW_AT_language
:
3003 /* Ordered by the numeric value of these constants. */
3004 case DW_LANG_C89
: printf ("(ANSI C)"); break;
3005 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
3006 case DW_LANG_Ada83
: printf ("(Ada)"); break;
3007 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
3008 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
3009 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
3010 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
3011 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
3012 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
3013 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
3014 /* DWARF 2.1 values. */
3015 case DW_LANG_Java
: printf ("(Java)"); break;
3016 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
3017 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
3018 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
3019 /* DWARF 3 values. */
3020 case DW_LANG_PLI
: printf ("(PLI)"); break;
3021 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
3022 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
3023 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
3024 case DW_LANG_D
: printf ("(D)"); break;
3025 /* DWARF 4 values. */
3026 case DW_LANG_Python
: printf ("(Python)"); break;
3027 /* DWARF 5 values. */
3028 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
3029 case DW_LANG_Go
: printf ("(Go)"); break;
3030 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
3031 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
3032 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
3033 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
3034 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
3035 case DW_LANG_Rust
: printf ("(Rust)"); break;
3036 case DW_LANG_C11
: printf ("(C11)"); break;
3037 case DW_LANG_Swift
: printf ("(Swift)"); break;
3038 case DW_LANG_Julia
: printf ("(Julia)"); break;
3039 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
3040 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
3041 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
3042 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
3043 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
3044 /* MIPS extension. */
3045 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
3046 /* UPC extension. */
3047 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
3049 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
3050 printf (_("(implementation defined: %s)"),
3051 dwarf_vmatoa ("x", uvalue
));
3053 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
3058 case DW_AT_encoding
:
3062 case DW_ATE_void
: printf ("(void)"); break;
3063 case DW_ATE_address
: printf ("(machine address)"); break;
3064 case DW_ATE_boolean
: printf ("(boolean)"); break;
3065 case DW_ATE_complex_float
: printf ("(complex float)"); break;
3066 case DW_ATE_float
: printf ("(float)"); break;
3067 case DW_ATE_signed
: printf ("(signed)"); break;
3068 case DW_ATE_signed_char
: printf ("(signed char)"); break;
3069 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
3070 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
3071 /* DWARF 2.1 values: */
3072 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
3073 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
3074 /* DWARF 3 values: */
3075 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
3076 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
3077 case DW_ATE_edited
: printf ("(edited)"); break;
3078 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
3079 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
3080 /* DWARF 4 values: */
3081 case DW_ATE_UTF
: printf ("(unicode string)"); break;
3082 /* DWARF 5 values: */
3083 case DW_ATE_UCS
: printf ("(UCS)"); break;
3084 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
3086 /* HP extensions: */
3087 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
3088 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
3089 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
3090 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
3091 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
3092 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
3093 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
3096 if (uvalue
>= DW_ATE_lo_user
3097 && uvalue
<= DW_ATE_hi_user
)
3098 printf (_("(user defined type)"));
3100 printf (_("(unknown type)"));
3105 case DW_AT_accessibility
:
3109 case DW_ACCESS_public
: printf ("(public)"); break;
3110 case DW_ACCESS_protected
: printf ("(protected)"); break;
3111 case DW_ACCESS_private
: printf ("(private)"); break;
3113 printf (_("(unknown accessibility)"));
3118 case DW_AT_visibility
:
3122 case DW_VIS_local
: printf ("(local)"); break;
3123 case DW_VIS_exported
: printf ("(exported)"); break;
3124 case DW_VIS_qualified
: printf ("(qualified)"); break;
3125 default: printf (_("(unknown visibility)")); break;
3129 case DW_AT_endianity
:
3133 case DW_END_default
: printf ("(default)"); break;
3134 case DW_END_big
: printf ("(big)"); break;
3135 case DW_END_little
: printf ("(little)"); break;
3137 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
3138 printf (_("(user specified)"));
3140 printf (_("(unknown endianity)"));
3145 case DW_AT_virtuality
:
3149 case DW_VIRTUALITY_none
: printf ("(none)"); break;
3150 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
3151 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
3152 default: printf (_("(unknown virtuality)")); break;
3156 case DW_AT_identifier_case
:
3160 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
3161 case DW_ID_up_case
: printf ("(up_case)"); break;
3162 case DW_ID_down_case
: printf ("(down_case)"); break;
3163 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
3164 default: printf (_("(unknown case)")); break;
3168 case DW_AT_calling_convention
:
3172 case DW_CC_normal
: printf ("(normal)"); break;
3173 case DW_CC_program
: printf ("(program)"); break;
3174 case DW_CC_nocall
: printf ("(nocall)"); break;
3175 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
3176 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
3177 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
3178 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
3180 if (uvalue
>= DW_CC_lo_user
3181 && uvalue
<= DW_CC_hi_user
)
3182 printf (_("(user defined)"));
3184 printf (_("(unknown convention)"));
3188 case DW_AT_ordering
:
3193 case -1: printf (_("(undefined)")); break;
3194 case 0: printf ("(row major)"); break;
3195 case 1: printf ("(column major)"); break;
3199 case DW_AT_decimal_sign
:
3203 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
3204 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
3205 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
3206 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
3207 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
3208 default: printf (_("(unrecognised)")); break;
3212 case DW_AT_defaulted
:
3216 case DW_DEFAULTED_no
: printf (_("(no)")); break;
3217 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
3218 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
3219 default: printf (_("(unrecognised)")); break;
3223 case DW_AT_discr_list
:
3225 display_discr_list (form
, uvalue
, data
, end
, level
);
3228 case DW_AT_frame_base
:
3229 have_frame_base
= 1;
3231 case DW_AT_location
:
3232 case DW_AT_string_length
:
3233 case DW_AT_return_addr
:
3234 case DW_AT_data_member_location
:
3235 case DW_AT_vtable_elem_location
:
3237 case DW_AT_static_link
:
3238 case DW_AT_use_location
:
3239 case DW_AT_call_value
:
3240 case DW_AT_GNU_call_site_value
:
3241 case DW_AT_call_data_value
:
3242 case DW_AT_GNU_call_site_data_value
:
3243 case DW_AT_call_target
:
3244 case DW_AT_GNU_call_site_target
:
3245 case DW_AT_call_target_clobbered
:
3246 case DW_AT_GNU_call_site_target_clobbered
:
3247 if ((dwarf_version
< 4
3248 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3249 || form
== DW_FORM_sec_offset
)
3250 printf (_(" (location list)"));
3252 case DW_AT_allocated
:
3253 case DW_AT_associated
:
3254 case DW_AT_data_location
:
3256 case DW_AT_upper_bound
:
3257 case DW_AT_lower_bound
:
3260 int need_frame_base
;
3263 need_frame_base
= decode_location_expression (block_start
,
3268 cu_offset
, section
);
3270 if (need_frame_base
&& !have_frame_base
)
3271 printf (_(" [without DW_AT_frame_base]"));
3275 case DW_AT_data_bit_offset
:
3276 case DW_AT_byte_size
:
3277 case DW_AT_bit_size
:
3278 case DW_AT_string_length_byte_size
:
3279 case DW_AT_string_length_bit_size
:
3280 case DW_AT_bit_stride
:
3281 if (form
== DW_FORM_exprloc
)
3284 (void) decode_location_expression (block_start
, pointer_size
,
3285 offset_size
, dwarf_version
,
3286 uvalue
, cu_offset
, section
);
3293 unsigned long abbrev_number
;
3294 abbrev_entry
*entry
;
3296 entry
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
3297 section
, & abbrev_number
, NULL
, NULL
);
3300 if (form
!= DW_FORM_GNU_ref_alt
)
3301 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
3302 dwarf_vmatoa ("x", uvalue
),
3303 (unsigned long) (orig_data
- section
->start
));
3307 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3308 printf (" (%s)", get_TAG_name (entry
->tag
));
3321 static unsigned char *
3322 read_and_display_attr (unsigned long attribute
,
3324 dwarf_signed_vma implicit_const
,
3325 unsigned char * start
,
3326 unsigned char * data
,
3327 unsigned char * end
,
3328 dwarf_vma cu_offset
,
3329 dwarf_vma pointer_size
,
3330 dwarf_vma offset_size
,
3332 debug_info
* debug_info_p
,
3334 struct dwarf_section
* section
,
3335 struct cu_tu_set
* this_set
,
3339 printf (" %-18s:", get_AT_name (attribute
));
3340 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3342 cu_offset
, pointer_size
, offset_size
,
3343 dwarf_version
, debug_info_p
,
3344 do_loc
, section
, this_set
, ' ', level
);
3350 /* Like load_debug_section, but if the ordinary call fails, and we are
3351 following debug links, then attempt to load the requested section
3352 from one of the separate debug info files. */
3355 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3358 if (load_debug_section (sec_enum
, handle
))
3360 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3362 /* See if we can associate a filename with this section. */
3365 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3366 if (i
->handle
== handle
)
3368 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3376 if (do_follow_links
)
3380 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3382 if (load_debug_section (sec_enum
, i
->handle
))
3384 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3386 /* FIXME: We should check to see if any of the remaining debug info
3387 files also contain this section, and, umm, do something about it. */
3397 introduce (struct dwarf_section
* section
, bool raw
)
3401 if (do_follow_links
&& section
->filename
)
3402 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3403 section
->name
, section
->filename
);
3405 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3409 if (do_follow_links
&& section
->filename
)
3410 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3411 section
->name
, section
->filename
);
3413 printf (_("Contents of the %s section:\n\n"), section
->name
);
3417 /* Process the contents of a .debug_info section.
3418 If do_loc is TRUE then we are scanning for location lists and dwo tags
3419 and we do not want to display anything to the user.
3420 If do_types is TRUE, we are processing a .debug_types section instead of
3421 a .debug_info section.
3422 The information displayed is restricted by the values in DWARF_START_DIE
3423 and DWARF_CUTOFF_LEVEL.
3424 Returns TRUE upon success. Otherwise an error or warning message is
3425 printed and FALSE is returned. */
3428 process_debug_info (struct dwarf_section
* section
,
3430 enum dwarf_section_display_enum abbrev_sec
,
3434 unsigned char *start
= section
->start
;
3435 unsigned char *end
= start
+ section
->size
;
3436 unsigned char *section_begin
;
3438 unsigned int num_units
= 0;
3440 /* First scan the section to get the number of comp units.
3441 Length sanity checks are done here. */
3442 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3447 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3448 will be the length. For a 64-bit DWARF section, it'll be
3449 the escape code 0xffffffff followed by an 8 byte length. */
3450 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 4, end
);
3452 if (length
== 0xffffffff)
3453 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 8, end
);
3454 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3456 warn (_("Reserved length value (0x%s) found in section %s\n"),
3457 dwarf_vmatoa ("x", length
), section
->name
);
3461 /* Negative values are illegal, they may even cause infinite
3462 looping. This can happen if we can't accurately apply
3463 relocations to an object file, or if the file is corrupt. */
3464 if (length
> (size_t) (end
- section_begin
))
3466 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3467 dwarf_vmatoa ("x", length
), section
->name
);
3470 section_begin
+= length
;
3475 error (_("No comp units in %s section ?\n"), section
->name
);
3479 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3480 && num_debug_info_entries
== 0
3484 /* Then allocate an array to hold the information. */
3485 debug_information
= (debug_info
*) cmalloc (num_units
,
3486 sizeof (* debug_information
));
3487 if (debug_information
== NULL
)
3489 error (_("Not enough memory for a debug info array of %u entries\n"),
3491 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3495 /* PR 17531: file: 92ca3797.
3496 We cannot rely upon the debug_information array being initialised
3497 before it is used. A corrupt file could easily contain references
3498 to a unit for which information has not been made available. So
3499 we ensure that the array is zeroed here. */
3500 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3502 alloc_num_debug_info_entries
= num_units
;
3507 load_debug_section_with_follow (str
, file
);
3508 load_debug_section_with_follow (line_str
, file
);
3509 load_debug_section_with_follow (str_dwo
, file
);
3510 load_debug_section_with_follow (str_index
, file
);
3511 load_debug_section_with_follow (str_index_dwo
, file
);
3512 load_debug_section_with_follow (debug_addr
, file
);
3515 load_debug_section_with_follow (abbrev_sec
, file
);
3516 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3518 warn (_("Unable to locate %s section!\n"),
3519 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3523 if (!do_loc
&& dwarf_start_die
== 0)
3524 introduce (section
, false);
3526 free_all_abbrevs ();
3527 free (cu_abbrev_map
);
3528 cu_abbrev_map
= NULL
;
3529 next_free_abbrev_map_entry
= 0;
3531 /* In order to be able to resolve DW_FORM_ref_attr forms we need
3532 to load *all* of the abbrevs for all CUs in this .debug_info
3533 section. This does effectively mean that we (partially) read
3534 every CU header twice. */
3535 for (section_begin
= start
; start
< end
;)
3537 DWARF2_Internal_CompUnit compunit
;
3538 unsigned char * hdrptr
;
3539 dwarf_vma abbrev_base
;
3541 dwarf_vma cu_offset
;
3542 unsigned int offset_size
;
3543 struct cu_tu_set
* this_set
;
3545 unsigned char *end_cu
;
3548 cu_offset
= start
- section_begin
;
3550 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3552 if (compunit
.cu_length
== 0xffffffff)
3554 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3559 end_cu
= hdrptr
+ compunit
.cu_length
;
3561 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3563 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3565 if (compunit
.cu_version
< 5)
3567 compunit
.cu_unit_type
= DW_UT_compile
;
3568 /* Initialize it due to a false compiler warning. */
3569 compunit
.cu_pointer_size
= -1;
3573 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3574 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3576 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3579 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
,
3582 if (compunit
.cu_unit_type
== DW_UT_split_compile
3583 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3586 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3589 if (this_set
== NULL
)
3592 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3596 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3597 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3600 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3601 compunit
.cu_abbrev_offset
);
3604 unsigned char * next
;
3606 list
= new_abbrev_list (abbrev_base
,
3607 compunit
.cu_abbrev_offset
);
3608 next
= process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3609 abbrev_base
, abbrev_size
,
3610 compunit
.cu_abbrev_offset
, list
);
3611 list
->start_of_next_abbrevs
= next
;
3615 record_abbrev_list_for_cu (cu_offset
, start
- section_begin
, list
);
3618 for (start
= section_begin
, unit
= 0; start
< end
; unit
++)
3620 DWARF2_Internal_CompUnit compunit
;
3621 unsigned char *hdrptr
;
3622 unsigned char *tags
;
3623 int level
, last_level
, saved_level
;
3624 dwarf_vma cu_offset
;
3625 unsigned int offset_size
;
3626 dwarf_vma signature
= 0;
3627 dwarf_vma type_offset
= 0;
3628 struct cu_tu_set
*this_set
;
3629 dwarf_vma abbrev_base
;
3631 abbrev_list
* list
= NULL
;
3632 unsigned char *end_cu
;
3635 cu_offset
= start
- section_begin
;
3637 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3639 if (compunit
.cu_length
== 0xffffffff)
3641 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3646 end_cu
= hdrptr
+ compunit
.cu_length
;
3648 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3650 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3652 if (compunit
.cu_version
< 5)
3654 compunit
.cu_unit_type
= DW_UT_compile
;
3655 /* Initialize it due to a false compiler warning. */
3656 compunit
.cu_pointer_size
= -1;
3660 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3661 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3663 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3666 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end_cu
);
3668 if (this_set
== NULL
)
3671 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3675 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3676 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3679 if (compunit
.cu_version
< 5)
3680 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3682 bool do_dwo_id
= false;
3683 uint64_t dwo_id
= 0;
3684 if (compunit
.cu_unit_type
== DW_UT_split_compile
3685 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3687 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3691 /* PR 17512: file: 001-108546-0.001:0.1. */
3692 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3694 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3695 compunit
.cu_pointer_size
, offset_size
);
3696 compunit
.cu_pointer_size
= offset_size
;
3701 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, end_cu
);
3702 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end_cu
);
3705 if (dwarf_start_die
>= (size_t) (end_cu
- section_begin
))
3711 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3712 && num_debug_info_entries
== 0
3713 && alloc_num_debug_info_entries
> unit
3716 debug_information
[unit
].cu_offset
= cu_offset
;
3717 debug_information
[unit
].pointer_size
3718 = compunit
.cu_pointer_size
;
3719 debug_information
[unit
].offset_size
= offset_size
;
3720 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3721 debug_information
[unit
].base_address
= 0;
3722 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3723 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3724 debug_information
[unit
].loc_offsets
= NULL
;
3725 debug_information
[unit
].have_frame_base
= NULL
;
3726 debug_information
[unit
].max_loc_offsets
= 0;
3727 debug_information
[unit
].num_loc_offsets
= 0;
3728 debug_information
[unit
].range_lists
= NULL
;
3729 debug_information
[unit
].max_range_lists
= 0;
3730 debug_information
[unit
].num_range_lists
= 0;
3733 if (!do_loc
&& dwarf_start_die
== 0)
3735 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3736 dwarf_vmatoa ("x", cu_offset
));
3737 printf (_(" Length: 0x%s (%s)\n"),
3738 dwarf_vmatoa ("x", compunit
.cu_length
),
3739 offset_size
== 8 ? "64-bit" : "32-bit");
3740 printf (_(" Version: %d\n"), compunit
.cu_version
);
3741 if (compunit
.cu_version
>= 5)
3743 const char *name
= get_DW_UT_name (compunit
.cu_unit_type
);
3745 printf (_(" Unit Type: %s (%x)\n"),
3746 name
? name
: "???",
3747 compunit
.cu_unit_type
);
3749 printf (_(" Abbrev Offset: 0x%s\n"),
3750 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3751 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3754 printf (_(" Signature: 0x%s\n"),
3755 dwarf_vmatoa ("x", signature
));
3756 printf (_(" Type Offset: 0x%s\n"),
3757 dwarf_vmatoa ("x", type_offset
));
3760 printf (_(" DWO ID: 0x%s\n"), dwarf_vmatoa ("x", dwo_id
));
3761 if (this_set
!= NULL
)
3763 dwarf_vma
*offsets
= this_set
->section_offsets
;
3764 size_t *sizes
= this_set
->section_sizes
;
3766 printf (_(" Section contributions:\n"));
3767 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3768 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3769 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3770 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3771 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3772 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3773 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3774 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3775 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3776 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3777 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3778 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3785 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3787 warn (_("CU at offset %s contains corrupt or "
3788 "unsupported version number: %d.\n"),
3789 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3793 if (compunit
.cu_unit_type
!= DW_UT_compile
3794 && compunit
.cu_unit_type
!= DW_UT_partial
3795 && compunit
.cu_unit_type
!= DW_UT_type
3796 && compunit
.cu_unit_type
!= DW_UT_split_compile
3797 && compunit
.cu_unit_type
!= DW_UT_skeleton
)
3799 warn (_("CU at offset %s contains corrupt or "
3800 "unsupported unit type: %d.\n"),
3801 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3805 /* Process the abbrevs used by this compilation unit. */
3806 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3807 compunit
.cu_abbrev_offset
);
3810 unsigned char *next
;
3812 list
= new_abbrev_list (abbrev_base
,
3813 compunit
.cu_abbrev_offset
);
3814 next
= process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3815 abbrev_base
, abbrev_size
,
3816 compunit
.cu_abbrev_offset
, list
);
3817 list
->start_of_next_abbrevs
= next
;
3823 while (tags
< start
)
3825 unsigned long abbrev_number
;
3826 unsigned long die_offset
;
3827 abbrev_entry
*entry
;
3829 int do_printing
= 1;
3831 die_offset
= tags
- section_begin
;
3833 READ_ULEB (abbrev_number
, tags
, start
);
3835 /* A null DIE marks the end of a list of siblings or it may also be
3836 a section padding. */
3837 if (abbrev_number
== 0)
3839 /* Check if it can be a section padding for the last CU. */
3840 if (level
== 0 && start
== end
)
3844 for (chk
= tags
; chk
< start
; chk
++)
3851 if (!do_loc
&& die_offset
>= dwarf_start_die
3852 && (dwarf_cutoff_level
== -1
3853 || level
< dwarf_cutoff_level
))
3854 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3860 static unsigned num_bogus_warns
= 0;
3862 if (num_bogus_warns
< 3)
3864 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3865 die_offset
, section
->name
);
3867 if (num_bogus_warns
== 3)
3868 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3871 if (dwarf_start_die
!= 0 && level
< saved_level
)
3878 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3882 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3883 saved_level
= level
;
3884 do_printing
= (dwarf_cutoff_level
== -1
3885 || level
< dwarf_cutoff_level
);
3887 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3888 level
, die_offset
, abbrev_number
);
3889 else if (dwarf_cutoff_level
== -1
3890 || last_level
< dwarf_cutoff_level
)
3891 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3896 /* Scan through the abbreviation list until we reach the
3901 for (entry
= list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
3902 if (entry
->number
== abbrev_number
)
3907 if (!do_loc
&& do_printing
)
3912 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3913 die_offset
, abbrev_number
);
3917 if (!do_loc
&& do_printing
)
3918 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3923 need_base_address
= 0;
3925 case DW_TAG_compile_unit
:
3926 need_base_address
= 1;
3927 need_dwo_info
= do_loc
;
3929 case DW_TAG_entry_point
:
3930 case DW_TAG_subprogram
:
3931 need_base_address
= 0;
3932 /* Assuming that there is no DW_AT_frame_base. */
3933 have_frame_base
= 0;
3937 debug_info
*debug_info_p
=
3938 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3939 ? debug_information
+ unit
: NULL
;
3941 assert (!debug_info_p
3942 || (debug_info_p
->num_loc_offsets
3943 == debug_info_p
->num_loc_views
));
3945 for (attr
= entry
->first_attr
;
3946 attr
&& attr
->attribute
;
3949 if (! do_loc
&& do_printing
)
3950 /* Show the offset from where the tag was extracted. */
3951 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3952 tags
= read_and_display_attr (attr
->attribute
,
3954 attr
->implicit_const
,
3959 compunit
.cu_pointer_size
,
3961 compunit
.cu_version
,
3963 do_loc
|| ! do_printing
,
3969 /* If a locview attribute appears before a location one,
3970 make sure we don't associate it with an earlier
3973 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3976 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3977 debug_info_p
->num_loc_views
++;
3978 assert (debug_info_p
->num_loc_views
3979 == debug_info_p
->num_loc_offsets
);
3986 warn(_("DIE has locviews without loclist\n"));
3987 debug_info_p
->num_loc_views
--;
3994 if (entry
->children
)
3999 /* Set num_debug_info_entries here so that it can be used to check if
4000 we need to process .debug_loc and .debug_ranges sections. */
4001 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
4002 && num_debug_info_entries
== 0
4005 if (num_units
> alloc_num_debug_info_entries
)
4006 num_debug_info_entries
= alloc_num_debug_info_entries
;
4008 num_debug_info_entries
= num_units
;
4017 /* Locate and scan the .debug_info section in the file and record the pointer
4018 sizes and offsets for the compilation units in it. Usually an executable
4019 will have just one pointer size, but this is not guaranteed, and so we try
4020 not to make any assumptions. Returns zero upon failure, or the number of
4021 compilation units upon success. */
4024 load_debug_info (void * file
)
4026 /* If we have already tried and failed to load the .debug_info
4027 section then do not bother to repeat the task. */
4028 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4031 /* If we already have the information there is nothing else to do. */
4032 if (num_debug_info_entries
> 0)
4033 return num_debug_info_entries
;
4035 /* If this is a DWARF package file, load the CU and TU indexes. */
4036 (void) load_cu_tu_indexes (file
);
4038 if (load_debug_section_with_follow (info
, file
)
4039 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, true, false))
4040 return num_debug_info_entries
;
4042 if (load_debug_section_with_follow (info_dwo
, file
)
4043 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
4044 abbrev_dwo
, true, false))
4045 return num_debug_info_entries
;
4047 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
4051 /* Read a DWARF .debug_line section header starting at DATA.
4052 Upon success returns an updated DATA pointer and the LINFO
4053 structure and the END_OF_SEQUENCE pointer will be filled in.
4054 Otherwise returns NULL. */
4056 static unsigned char *
4057 read_debug_line_header (struct dwarf_section
* section
,
4058 unsigned char * data
,
4059 unsigned char * end
,
4060 DWARF2_Internal_LineInfo
* linfo
,
4061 unsigned char ** end_of_sequence
)
4063 unsigned char *hdrptr
;
4065 /* Extract information from the Line Number Program Header.
4066 (section 6.2.4 in the Dwarf3 doc). */
4069 /* Get and check the length of the block. */
4070 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
4072 if (linfo
->li_length
== 0xffffffff)
4074 /* This section is 64-bit DWARF 3. */
4075 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
4076 linfo
->li_offset_size
= 8;
4079 linfo
->li_offset_size
= 4;
4081 if (linfo
->li_length
> (size_t) (end
- hdrptr
))
4083 /* If the length field has a relocation against it, then we should
4084 not complain if it is inaccurate (and probably negative). This
4085 happens in object files when the .debug_line section is actually
4086 comprised of several different .debug_line.* sections, (some of
4087 which may be removed by linker garbage collection), and a relocation
4088 is used to compute the correct length once that is done. */
4089 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
4091 linfo
->li_length
= end
- hdrptr
;
4095 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
4096 (long) linfo
->li_length
);
4100 end
= hdrptr
+ linfo
->li_length
;
4102 /* Get and check the version number. */
4103 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
4105 if (linfo
->li_version
!= 2
4106 && linfo
->li_version
!= 3
4107 && linfo
->li_version
!= 4
4108 && linfo
->li_version
!= 5)
4110 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
4111 "is currently supported.\n"));
4115 if (linfo
->li_version
>= 5)
4117 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
4119 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
4120 if (linfo
->li_segment_size
!= 0)
4122 warn (_("The %s section contains "
4123 "unsupported segment selector size: %d.\n"),
4124 section
->name
, linfo
->li_segment_size
);
4129 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
4130 linfo
->li_offset_size
, end
);
4131 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
4133 if (linfo
->li_version
>= 4)
4135 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
4137 if (linfo
->li_max_ops_per_insn
== 0)
4139 warn (_("Invalid maximum operations per insn.\n"));
4144 linfo
->li_max_ops_per_insn
= 1;
4146 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
4147 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
4148 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
4149 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
4151 *end_of_sequence
= end
;
4155 static unsigned char *
4156 display_formatted_table (unsigned char *data
,
4157 unsigned char *start
,
4159 const DWARF2_Internal_LineInfo
*linfo
,
4160 struct dwarf_section
*section
,
4163 unsigned char *format_start
, format_count
, *format
, formati
;
4164 dwarf_vma data_count
, datai
;
4165 unsigned int namepass
, last_entry
= 0;
4166 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
4168 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4169 if (do_checks
&& format_count
> 5)
4170 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
4171 table_name
, format_count
);
4173 format_start
= data
;
4174 for (formati
= 0; formati
< format_count
; formati
++)
4176 SKIP_ULEB (data
, end
);
4177 SKIP_ULEB (data
, end
);
4180 warn (_("%s: Corrupt format description entry\n"), table_name
);
4185 READ_ULEB (data_count
, data
, end
);
4186 if (data_count
== 0)
4188 printf (_("\n The %s is empty.\n"), table_name
);
4191 else if (data
>= end
)
4193 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
4194 table_name
, dwarf_vmatoa ("x", data_count
));
4198 else if (format_count
== 0)
4200 warn (_("%s: format count is zero, but the table is not empty\n"),
4205 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
4206 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
4209 printf (_(" Entry"));
4210 /* Delay displaying name as the last entry for better screen layout. */
4211 for (namepass
= 0; namepass
< 2; namepass
++)
4213 format
= format_start
;
4214 for (formati
= 0; formati
< format_count
; formati
++)
4216 dwarf_vma content_type
;
4218 READ_ULEB (content_type
, format
, end
);
4219 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
4220 switch (content_type
)
4223 printf (_("\tName"));
4225 case DW_LNCT_directory_index
:
4226 printf (_("\tDir"));
4228 case DW_LNCT_timestamp
:
4229 printf (_("\tTime"));
4232 printf (_("\tSize"));
4235 printf (_("\tMD5\t\t\t"));
4238 printf (_("\t(Unknown format content type %s)"),
4239 dwarf_vmatoa ("u", content_type
));
4241 SKIP_ULEB (format
, end
);
4246 for (datai
= 0; datai
< data_count
; datai
++)
4248 unsigned char *datapass
= data
;
4250 printf (" %d", last_entry
++);
4251 /* Delay displaying name as the last entry for better screen layout. */
4252 for (namepass
= 0; namepass
< 2; namepass
++)
4254 format
= format_start
;
4256 for (formati
= 0; formati
< format_count
; formati
++)
4258 dwarf_vma content_type
, form
;
4260 READ_ULEB (content_type
, format
, end
);
4261 READ_ULEB (form
, format
, end
);
4262 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4263 0, 0, linfo
->li_offset_size
,
4264 linfo
->li_version
, NULL
,
4265 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
4266 section
, NULL
, '\t', -1);
4270 if (data
>= end
&& (datai
< data_count
- 1))
4272 warn (_("\n%s: Corrupt entries list\n"), table_name
);
4281 display_debug_sup (struct dwarf_section
* section
,
4282 void * file ATTRIBUTE_UNUSED
)
4284 unsigned char * start
= section
->start
;
4285 unsigned char * end
= section
->start
+ section
->size
;
4286 unsigned int version
;
4287 char is_supplementary
;
4288 const unsigned char * sup_filename
;
4289 size_t sup_filename_len
;
4290 unsigned int num_read
;
4292 dwarf_vma checksum_len
;
4295 introduce (section
, true);
4296 if (section
->size
< 4)
4298 error (_("corrupt .debug_sup section: size is too small\n"));
4302 /* Read the data. */
4303 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
4305 warn (_("corrupt .debug_sup section: version < 5"));
4307 SAFE_BYTE_GET_AND_INC (is_supplementary
, start
, 1, end
);
4308 if (is_supplementary
!= 0 && is_supplementary
!= 1)
4309 warn (_("corrupt .debug_sup section: is_supplementary not 0 or 1\n"));
4311 sup_filename
= start
;
4312 if (is_supplementary
&& sup_filename
[0] != 0)
4313 warn (_("corrupt .debug_sup section: filename not empty in supplementary section\n"));
4315 sup_filename_len
= strnlen ((const char *) start
, end
- start
);
4316 if (sup_filename_len
== (size_t) (end
- start
))
4318 error (_("corrupt .debug_sup section: filename is not NUL terminated\n"));
4321 start
+= sup_filename_len
+ 1;
4323 checksum_len
= read_leb128 (start
, end
, false /* unsigned */, & num_read
, & status
);
4326 error (_("corrupt .debug_sup section: bad LEB128 field for checksum length\n"));
4330 if (checksum_len
> (dwarf_vma
) (end
- start
))
4332 error (_("corrupt .debug_sup section: checksum length is longer than the remaining section length\n"));
4333 checksum_len
= end
- start
;
4335 else if (checksum_len
< (dwarf_vma
) (end
- start
))
4337 warn (_("corrupt .debug_sup section: there are 0x%lx extra, unused bytes at the end of the section\n"),
4338 (long) ((end
- start
) - checksum_len
));
4341 printf (_(" Version: %u\n"), version
);
4342 printf (_(" Is Supp: %u\n"), is_supplementary
);
4343 printf (_(" Filename: %s\n"), sup_filename
);
4344 printf (_(" Checksum Len: %lu\n"), (long) checksum_len
);
4345 if (checksum_len
> 0)
4347 printf (_(" Checksum: "));
4348 while (checksum_len
--)
4349 printf ("0x%x ", * start
++ );
4356 display_debug_lines_raw (struct dwarf_section
* section
,
4357 unsigned char * data
,
4358 unsigned char * end
,
4361 unsigned char *start
= section
->start
;
4362 int verbose_view
= 0;
4364 introduce (section
, true);
4368 static DWARF2_Internal_LineInfo saved_linfo
;
4369 DWARF2_Internal_LineInfo linfo
;
4370 unsigned char *standard_opcodes
;
4371 unsigned char *end_of_sequence
;
4374 if (startswith (section
->name
, ".debug_line.")
4375 /* Note: the following does not apply to .debug_line.dwo sections.
4376 These are full debug_line sections. */
4377 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4379 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4380 section containing just the Line Number Statements. They are
4381 created by the assembler and intended to be used alongside gcc's
4382 -ffunction-sections command line option. When the linker's
4383 garbage collection decides to discard a .text.<foo> section it
4384 can then also discard the line number information in .debug_line.<foo>.
4386 Since the section is a fragment it does not have the details
4387 needed to fill out a LineInfo structure, so instead we use the
4388 details from the last full debug_line section that we processed. */
4389 end_of_sequence
= end
;
4390 standard_opcodes
= NULL
;
4391 linfo
= saved_linfo
;
4392 /* PR 17531: file: 0522b371. */
4393 if (linfo
.li_line_range
== 0)
4395 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4398 reset_state_machine (linfo
.li_default_is_stmt
);
4402 unsigned char * hdrptr
;
4404 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4405 & end_of_sequence
)) == NULL
)
4408 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
4409 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
4410 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4411 if (linfo
.li_version
>= 5)
4413 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
4414 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
4416 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4417 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4418 if (linfo
.li_version
>= 4)
4419 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4420 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4421 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4422 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4423 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4425 /* PR 17512: file: 1665-6428-0.004. */
4426 if (linfo
.li_line_range
== 0)
4428 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4429 linfo
.li_line_range
= 1;
4432 reset_state_machine (linfo
.li_default_is_stmt
);
4434 /* Display the contents of the Opcodes table. */
4435 standard_opcodes
= hdrptr
;
4437 /* PR 17512: file: 002-417945-0.004. */
4438 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4440 warn (_("Line Base extends beyond end of section\n"));
4444 printf (_("\n Opcodes:\n"));
4446 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4447 printf (ngettext (" Opcode %d has %d arg\n",
4448 " Opcode %d has %d args\n",
4449 standard_opcodes
[i
- 1]),
4450 i
, standard_opcodes
[i
- 1]);
4452 /* Display the contents of the Directory table. */
4453 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4455 if (linfo
.li_version
>= 5)
4457 load_debug_section_with_follow (line_str
, file
);
4459 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4461 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4467 printf (_("\n The Directory Table is empty.\n"));
4470 unsigned int last_dir_entry
= 0;
4472 printf (_("\n The Directory Table (offset 0x%lx):\n"),
4473 (long)(data
- start
));
4475 while (data
< end
&& *data
!= 0)
4477 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4479 data
+= strnlen ((char *) data
, end
- data
);
4484 /* PR 17512: file: 002-132094-0.004. */
4485 if (data
>= end
- 1)
4489 /* Skip the NUL at the end of the table. */
4493 /* Display the contents of the File Name table. */
4494 if (data
>= end
|| *data
== 0)
4495 printf (_("\n The File Name Table is empty.\n"));
4498 printf (_("\n The File Name Table (offset 0x%lx):\n"),
4499 (long)(data
- start
));
4500 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4502 while (data
< end
&& *data
!= 0)
4504 unsigned char *name
;
4507 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4509 data
+= strnlen ((char *) data
, end
- data
);
4513 READ_ULEB (val
, data
, end
);
4514 printf ("%s\t", dwarf_vmatoa ("u", val
));
4515 READ_ULEB (val
, data
, end
);
4516 printf ("%s\t", dwarf_vmatoa ("u", val
));
4517 READ_ULEB (val
, data
, end
);
4518 printf ("%s\t", dwarf_vmatoa ("u", val
));
4519 printf ("%.*s\n", (int)(end
- name
), name
);
4523 warn (_("Corrupt file name table entry\n"));
4529 /* Skip the NUL at the end of the table. */
4535 saved_linfo
= linfo
;
4538 /* Now display the statements. */
4539 if (data
>= end_of_sequence
)
4540 printf (_(" No Line Number Statements.\n"));
4543 printf (_(" Line Number Statements:\n"));
4545 while (data
< end_of_sequence
)
4547 unsigned char op_code
;
4548 dwarf_signed_vma adv
;
4551 printf (" [0x%08lx]", (long)(data
- start
));
4555 if (op_code
>= linfo
.li_opcode_base
)
4557 op_code
-= linfo
.li_opcode_base
;
4558 uladv
= (op_code
/ linfo
.li_line_range
);
4559 if (linfo
.li_max_ops_per_insn
== 1)
4561 uladv
*= linfo
.li_min_insn_length
;
4562 state_machine_regs
.address
+= uladv
;
4564 state_machine_regs
.view
= 0;
4565 printf (_(" Special opcode %d: "
4566 "advance Address by %s to 0x%s%s"),
4567 op_code
, dwarf_vmatoa ("u", uladv
),
4568 dwarf_vmatoa ("x", state_machine_regs
.address
),
4569 verbose_view
&& uladv
4570 ? _(" (reset view)") : "");
4575 = ((state_machine_regs
.op_index
+ uladv
)
4576 / linfo
.li_max_ops_per_insn
)
4577 * linfo
.li_min_insn_length
;
4579 state_machine_regs
.address
+= addrdelta
;
4580 state_machine_regs
.op_index
4581 = (state_machine_regs
.op_index
+ uladv
)
4582 % linfo
.li_max_ops_per_insn
;
4584 state_machine_regs
.view
= 0;
4585 printf (_(" Special opcode %d: "
4586 "advance Address by %s to 0x%s[%d]%s"),
4587 op_code
, dwarf_vmatoa ("u", uladv
),
4588 dwarf_vmatoa ("x", state_machine_regs
.address
),
4589 state_machine_regs
.op_index
,
4590 verbose_view
&& addrdelta
4591 ? _(" (reset view)") : "");
4593 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4594 state_machine_regs
.line
+= adv
;
4595 printf (_(" and Line by %s to %d"),
4596 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4597 if (verbose_view
|| state_machine_regs
.view
)
4598 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4601 state_machine_regs
.view
++;
4606 case DW_LNS_extended_op
:
4607 data
+= process_extended_line_op (data
,
4608 linfo
.li_default_is_stmt
,
4613 printf (_(" Copy"));
4614 if (verbose_view
|| state_machine_regs
.view
)
4615 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4618 state_machine_regs
.view
++;
4621 case DW_LNS_advance_pc
:
4622 READ_ULEB (uladv
, data
, end
);
4623 if (linfo
.li_max_ops_per_insn
== 1)
4625 uladv
*= linfo
.li_min_insn_length
;
4626 state_machine_regs
.address
+= uladv
;
4628 state_machine_regs
.view
= 0;
4629 printf (_(" Advance PC by %s to 0x%s%s\n"),
4630 dwarf_vmatoa ("u", uladv
),
4631 dwarf_vmatoa ("x", state_machine_regs
.address
),
4632 verbose_view
&& uladv
4633 ? _(" (reset view)") : "");
4638 = ((state_machine_regs
.op_index
+ uladv
)
4639 / linfo
.li_max_ops_per_insn
)
4640 * linfo
.li_min_insn_length
;
4641 state_machine_regs
.address
4643 state_machine_regs
.op_index
4644 = (state_machine_regs
.op_index
+ uladv
)
4645 % linfo
.li_max_ops_per_insn
;
4647 state_machine_regs
.view
= 0;
4648 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4649 dwarf_vmatoa ("u", uladv
),
4650 dwarf_vmatoa ("x", state_machine_regs
.address
),
4651 state_machine_regs
.op_index
,
4652 verbose_view
&& addrdelta
4653 ? _(" (reset view)") : "");
4657 case DW_LNS_advance_line
:
4658 READ_SLEB (adv
, data
, end
);
4659 state_machine_regs
.line
+= adv
;
4660 printf (_(" Advance Line by %s to %d\n"),
4661 dwarf_vmatoa ("d", adv
),
4662 state_machine_regs
.line
);
4665 case DW_LNS_set_file
:
4666 READ_ULEB (uladv
, data
, end
);
4667 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4668 dwarf_vmatoa ("u", uladv
));
4669 state_machine_regs
.file
= uladv
;
4672 case DW_LNS_set_column
:
4673 READ_ULEB (uladv
, data
, end
);
4674 printf (_(" Set column to %s\n"),
4675 dwarf_vmatoa ("u", uladv
));
4676 state_machine_regs
.column
= uladv
;
4679 case DW_LNS_negate_stmt
:
4680 adv
= state_machine_regs
.is_stmt
;
4682 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4683 state_machine_regs
.is_stmt
= adv
;
4686 case DW_LNS_set_basic_block
:
4687 printf (_(" Set basic block\n"));
4688 state_machine_regs
.basic_block
= 1;
4691 case DW_LNS_const_add_pc
:
4692 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4693 if (linfo
.li_max_ops_per_insn
)
4695 uladv
*= linfo
.li_min_insn_length
;
4696 state_machine_regs
.address
+= uladv
;
4698 state_machine_regs
.view
= 0;
4699 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4700 dwarf_vmatoa ("u", uladv
),
4701 dwarf_vmatoa ("x", state_machine_regs
.address
),
4702 verbose_view
&& uladv
4703 ? _(" (reset view)") : "");
4708 = ((state_machine_regs
.op_index
+ uladv
)
4709 / linfo
.li_max_ops_per_insn
)
4710 * linfo
.li_min_insn_length
;
4711 state_machine_regs
.address
4713 state_machine_regs
.op_index
4714 = (state_machine_regs
.op_index
+ uladv
)
4715 % linfo
.li_max_ops_per_insn
;
4717 state_machine_regs
.view
= 0;
4718 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4719 dwarf_vmatoa ("u", uladv
),
4720 dwarf_vmatoa ("x", state_machine_regs
.address
),
4721 state_machine_regs
.op_index
,
4722 verbose_view
&& addrdelta
4723 ? _(" (reset view)") : "");
4727 case DW_LNS_fixed_advance_pc
:
4728 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4729 state_machine_regs
.address
+= uladv
;
4730 state_machine_regs
.op_index
= 0;
4731 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4732 dwarf_vmatoa ("u", uladv
),
4733 dwarf_vmatoa ("x", state_machine_regs
.address
));
4734 /* Do NOT reset view. */
4737 case DW_LNS_set_prologue_end
:
4738 printf (_(" Set prologue_end to true\n"));
4741 case DW_LNS_set_epilogue_begin
:
4742 printf (_(" Set epilogue_begin to true\n"));
4745 case DW_LNS_set_isa
:
4746 READ_ULEB (uladv
, data
, end
);
4747 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4751 printf (_(" Unknown opcode %d with operands: "), op_code
);
4753 if (standard_opcodes
!= NULL
)
4754 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4756 READ_ULEB (uladv
, data
, end
);
4757 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4758 i
== 1 ? "" : ", ");
4773 unsigned char *name
;
4774 unsigned int directory_index
;
4775 unsigned int modification_date
;
4776 unsigned int length
;
4779 /* Output a decoded representation of the .debug_line section. */
4782 display_debug_lines_decoded (struct dwarf_section
* section
,
4783 unsigned char * start
,
4784 unsigned char * data
,
4785 unsigned char * end
,
4788 static DWARF2_Internal_LineInfo saved_linfo
;
4790 introduce (section
, false);
4794 /* This loop amounts to one iteration per compilation unit. */
4795 DWARF2_Internal_LineInfo linfo
;
4796 unsigned char *standard_opcodes
;
4797 unsigned char *end_of_sequence
;
4799 File_Entry
*file_table
= NULL
;
4800 unsigned int n_files
= 0;
4801 unsigned char **directory_table
= NULL
;
4802 dwarf_vma n_directories
= 0;
4804 if (startswith (section
->name
, ".debug_line.")
4805 /* Note: the following does not apply to .debug_line.dwo sections.
4806 These are full debug_line sections. */
4807 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4809 /* See comment in display_debug_lines_raw(). */
4810 end_of_sequence
= end
;
4811 standard_opcodes
= NULL
;
4812 linfo
= saved_linfo
;
4813 /* PR 17531: file: 0522b371. */
4814 if (linfo
.li_line_range
== 0)
4816 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4819 reset_state_machine (linfo
.li_default_is_stmt
);
4823 unsigned char *hdrptr
;
4825 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4826 & end_of_sequence
)) == NULL
)
4829 /* PR 17531: file: 0522b371. */
4830 if (linfo
.li_line_range
== 0)
4832 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4833 linfo
.li_line_range
= 1;
4835 reset_state_machine (linfo
.li_default_is_stmt
);
4837 /* Save a pointer to the contents of the Opcodes table. */
4838 standard_opcodes
= hdrptr
;
4840 /* Traverse the Directory table just to count entries. */
4841 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4845 warn (_("opcode base of %d extends beyond end of section\n"),
4846 linfo
.li_opcode_base
);
4850 if (linfo
.li_version
>= 5)
4852 unsigned char *format_start
, format_count
, *format
;
4853 dwarf_vma formati
, entryi
;
4855 load_debug_section_with_follow (line_str
, fileptr
);
4857 /* Skip directories format. */
4858 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4859 if (do_checks
&& format_count
> 1)
4860 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4862 format_start
= data
;
4863 for (formati
= 0; formati
< format_count
; formati
++)
4865 SKIP_ULEB (data
, end
);
4866 SKIP_ULEB (data
, end
);
4869 READ_ULEB (n_directories
, data
, end
);
4872 warn (_("Corrupt directories list\n"));
4876 if (n_directories
== 0)
4877 directory_table
= NULL
;
4879 directory_table
= (unsigned char **)
4880 xmalloc (n_directories
* sizeof (unsigned char *));
4882 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4884 unsigned char **pathp
= &directory_table
[entryi
];
4886 format
= format_start
;
4887 for (formati
= 0; formati
< format_count
; formati
++)
4889 dwarf_vma content_type
, form
;
4892 READ_ULEB (content_type
, format
, end
);
4893 READ_ULEB (form
, format
, end
);
4896 warn (_("Corrupt directories list\n"));
4899 switch (content_type
)
4904 case DW_FORM_string
:
4907 case DW_FORM_line_strp
:
4908 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4910 /* Remove const by the cast. */
4911 *pathp
= (unsigned char *)
4912 fetch_indirect_line_string (uvalue
);
4917 data
= read_and_display_attr_value (0, form
, 0, start
,
4919 linfo
.li_offset_size
,
4926 warn (_("Corrupt directories list\n"));
4931 /* Skip files format. */
4932 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4933 if (do_checks
&& format_count
> 5)
4934 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
4936 format_start
= data
;
4937 for (formati
= 0; formati
< format_count
; formati
++)
4939 SKIP_ULEB (data
, end
);
4940 SKIP_ULEB (data
, end
);
4943 READ_ULEB (n_files
, data
, end
);
4944 if (data
>= end
&& n_files
> 0)
4946 warn (_("Corrupt file name list\n"));
4953 file_table
= (File_Entry
*) xcalloc (1, n_files
4954 * sizeof (File_Entry
));
4956 for (entryi
= 0; entryi
< n_files
; entryi
++)
4958 File_Entry
*file
= &file_table
[entryi
];
4960 format
= format_start
;
4961 for (formati
= 0; formati
< format_count
; formati
++)
4963 dwarf_vma content_type
, form
;
4967 READ_ULEB (content_type
, format
, end
);
4968 READ_ULEB (form
, format
, end
);
4971 warn (_("Corrupt file name list\n"));
4974 switch (content_type
)
4979 case DW_FORM_string
:
4982 case DW_FORM_line_strp
:
4983 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4985 /* Remove const by the cast. */
4986 file
->name
= (unsigned char *)
4987 fetch_indirect_line_string (uvalue
);
4991 case DW_LNCT_directory_index
:
4995 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4999 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
5004 READ_ULEB (file
->directory_index
, tmp
, end
);
5009 data
= read_and_display_attr_value (0, form
, 0, start
,
5011 linfo
.li_offset_size
,
5018 warn (_("Corrupt file name list\n"));
5027 unsigned char *ptr_directory_table
= data
;
5029 while (data
< end
&& *data
!= 0)
5031 data
+= strnlen ((char *) data
, end
- data
);
5040 warn (_("directory table ends unexpectedly\n"));
5045 /* Go through the directory table again to save the directories. */
5046 directory_table
= (unsigned char **)
5047 xmalloc (n_directories
* sizeof (unsigned char *));
5050 while (*ptr_directory_table
!= 0)
5052 directory_table
[i
] = ptr_directory_table
;
5054 += strlen ((char *) ptr_directory_table
) + 1;
5058 /* Skip the NUL at the end of the table. */
5061 /* Traverse the File Name table just to count the entries. */
5062 if (data
< end
&& *data
!= 0)
5064 unsigned char *ptr_file_name_table
= data
;
5066 while (data
< end
&& *data
!= 0)
5068 /* Skip Name, directory index, last modification
5069 time and length of file. */
5070 data
+= strnlen ((char *) data
, end
- data
);
5073 SKIP_ULEB (data
, end
);
5074 SKIP_ULEB (data
, end
);
5075 SKIP_ULEB (data
, end
);
5081 warn (_("file table ends unexpectedly\n"));
5086 /* Go through the file table again to save the strings. */
5087 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
5090 while (*ptr_file_name_table
!= 0)
5092 file_table
[i
].name
= ptr_file_name_table
;
5094 += strlen ((char *) ptr_file_name_table
) + 1;
5096 /* We are not interested in directory, time or size. */
5097 READ_ULEB (file_table
[i
].directory_index
,
5098 ptr_file_name_table
, end
);
5099 READ_ULEB (file_table
[i
].modification_date
,
5100 ptr_file_name_table
, end
);
5101 READ_ULEB (file_table
[i
].length
,
5102 ptr_file_name_table
, end
);
5108 /* Skip the NUL at the end of the table. */
5112 /* Print the Compilation Unit's name and a header. */
5113 if (file_table
== NULL
)
5114 printf (_("CU: No directory table\n"));
5115 else if (directory_table
== NULL
)
5116 printf (_("CU: %s:\n"), file_table
[0].name
);
5119 unsigned int ix
= file_table
[0].directory_index
;
5120 const char *directory
;
5125 else if (n_directories
== 0)
5126 directory
= _("<unknown>");
5127 else if (ix
> n_directories
)
5129 warn (_("directory index %u > number of directories %s\n"),
5130 ix
, dwarf_vmatoa ("u", n_directories
));
5131 directory
= _("<corrupt>");
5134 directory
= (char *) directory_table
[ix
- 1];
5136 if (do_wide
|| strlen (directory
) < 76)
5137 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
5139 printf ("%s:\n", file_table
[0].name
);
5143 printf (_("File name Line number Starting address View Stmt\n"));
5145 printf (_("CU: Empty file name table\n"));
5146 saved_linfo
= linfo
;
5149 /* This loop iterates through the Dwarf Line Number Program. */
5150 while (data
< end_of_sequence
)
5152 unsigned char op_code
;
5155 unsigned long int uladv
;
5156 int is_special_opcode
= 0;
5161 if (op_code
>= linfo
.li_opcode_base
)
5163 op_code
-= linfo
.li_opcode_base
;
5164 uladv
= (op_code
/ linfo
.li_line_range
);
5165 if (linfo
.li_max_ops_per_insn
== 1)
5167 uladv
*= linfo
.li_min_insn_length
;
5168 state_machine_regs
.address
+= uladv
;
5170 state_machine_regs
.view
= 0;
5175 = ((state_machine_regs
.op_index
+ uladv
)
5176 / linfo
.li_max_ops_per_insn
)
5177 * linfo
.li_min_insn_length
;
5178 state_machine_regs
.address
5180 state_machine_regs
.op_index
5181 = (state_machine_regs
.op_index
+ uladv
)
5182 % linfo
.li_max_ops_per_insn
;
5184 state_machine_regs
.view
= 0;
5187 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
5188 state_machine_regs
.line
+= adv
;
5189 is_special_opcode
= 1;
5190 /* Increment view after printing this row. */
5195 case DW_LNS_extended_op
:
5197 unsigned int ext_op_code_len
;
5198 unsigned char ext_op_code
;
5199 unsigned char *op_code_end
;
5200 unsigned char *op_code_data
= data
;
5202 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
5203 op_code_end
= op_code_data
+ ext_op_code_len
;
5204 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
5206 warn (_("Badly formed extended line op encountered!\n"));
5209 ext_op_code
= *op_code_data
++;
5213 switch (ext_op_code
)
5215 case DW_LNE_end_sequence
:
5216 /* Reset stuff after printing this row. */
5218 case DW_LNE_set_address
:
5219 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
5221 op_code_end
- op_code_data
,
5223 state_machine_regs
.op_index
= 0;
5224 state_machine_regs
.view
= 0;
5226 case DW_LNE_define_file
:
5227 file_table
= (File_Entry
*) xrealloc
5228 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
5230 ++state_machine_regs
.last_file_entry
;
5231 /* Source file name. */
5232 file_table
[n_files
].name
= op_code_data
;
5233 op_code_data
+= strlen ((char *) op_code_data
) + 1;
5234 /* Directory index. */
5235 READ_ULEB (file_table
[n_files
].directory_index
,
5236 op_code_data
, op_code_end
);
5237 /* Last modification time. */
5238 READ_ULEB (file_table
[n_files
].modification_date
,
5239 op_code_data
, op_code_end
);
5241 READ_ULEB (file_table
[n_files
].length
,
5242 op_code_data
, op_code_end
);
5246 case DW_LNE_set_discriminator
:
5247 case DW_LNE_HP_set_sequence
:
5248 /* Simply ignored. */
5252 printf (_("UNKNOWN (%u): length %ld\n"),
5253 ext_op_code
, (long int) (op_code_data
- data
));
5260 /* Increment view after printing this row. */
5263 case DW_LNS_advance_pc
:
5264 READ_ULEB (uladv
, data
, end
);
5265 if (linfo
.li_max_ops_per_insn
== 1)
5267 uladv
*= linfo
.li_min_insn_length
;
5268 state_machine_regs
.address
+= uladv
;
5270 state_machine_regs
.view
= 0;
5275 = ((state_machine_regs
.op_index
+ uladv
)
5276 / linfo
.li_max_ops_per_insn
)
5277 * linfo
.li_min_insn_length
;
5278 state_machine_regs
.address
5280 state_machine_regs
.op_index
5281 = (state_machine_regs
.op_index
+ uladv
)
5282 % linfo
.li_max_ops_per_insn
;
5284 state_machine_regs
.view
= 0;
5288 case DW_LNS_advance_line
:
5289 READ_SLEB (adv
, data
, end
);
5290 state_machine_regs
.line
+= adv
;
5293 case DW_LNS_set_file
:
5294 READ_ULEB (uladv
, data
, end
);
5295 state_machine_regs
.file
= uladv
;
5298 unsigned file
= state_machine_regs
.file
- 1;
5301 if (file_table
== NULL
|| n_files
== 0)
5302 printf (_("\n [Use file table entry %d]\n"), file
);
5304 else if (file
>= n_files
)
5306 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
5307 printf (_("\n <over large file table index %u>"), file
);
5309 else if ((dir
= file_table
[file
].directory_index
) == 0)
5310 /* If directory index is 0, that means current directory. */
5311 printf ("\n./%s:[++]\n", file_table
[file
].name
);
5312 else if (directory_table
== NULL
|| n_directories
== 0)
5313 printf (_("\n [Use file %s in directory table entry %d]\n"),
5314 file_table
[file
].name
, dir
);
5316 else if (dir
> n_directories
)
5318 warn (_("directory index %u > number of directories %s\n"),
5319 dir
, dwarf_vmatoa ("u", n_directories
));
5320 printf (_("\n <over large directory table entry %u>\n"), dir
);
5323 printf ("\n%s/%s:\n",
5324 /* The directory index starts counting at 1. */
5325 directory_table
[dir
- 1], file_table
[file
].name
);
5329 case DW_LNS_set_column
:
5330 READ_ULEB (uladv
, data
, end
);
5331 state_machine_regs
.column
= uladv
;
5334 case DW_LNS_negate_stmt
:
5335 adv
= state_machine_regs
.is_stmt
;
5337 state_machine_regs
.is_stmt
= adv
;
5340 case DW_LNS_set_basic_block
:
5341 state_machine_regs
.basic_block
= 1;
5344 case DW_LNS_const_add_pc
:
5345 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5346 if (linfo
.li_max_ops_per_insn
== 1)
5348 uladv
*= linfo
.li_min_insn_length
;
5349 state_machine_regs
.address
+= uladv
;
5351 state_machine_regs
.view
= 0;
5356 = ((state_machine_regs
.op_index
+ uladv
)
5357 / linfo
.li_max_ops_per_insn
)
5358 * linfo
.li_min_insn_length
;
5359 state_machine_regs
.address
5361 state_machine_regs
.op_index
5362 = (state_machine_regs
.op_index
+ uladv
)
5363 % linfo
.li_max_ops_per_insn
;
5365 state_machine_regs
.view
= 0;
5369 case DW_LNS_fixed_advance_pc
:
5370 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5371 state_machine_regs
.address
+= uladv
;
5372 state_machine_regs
.op_index
= 0;
5373 /* Do NOT reset view. */
5376 case DW_LNS_set_prologue_end
:
5379 case DW_LNS_set_epilogue_begin
:
5382 case DW_LNS_set_isa
:
5383 READ_ULEB (uladv
, data
, end
);
5384 printf (_(" Set ISA to %lu\n"), uladv
);
5388 printf (_(" Unknown opcode %d with operands: "), op_code
);
5390 if (standard_opcodes
!= NULL
)
5391 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5395 READ_ULEB (val
, data
, end
);
5396 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
5397 i
== 1 ? "" : ", ");
5403 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5404 to the DWARF address/line matrix. */
5405 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5406 || (xop
== DW_LNS_copy
))
5408 const unsigned int MAX_FILENAME_LENGTH
= 35;
5410 char *newFileName
= NULL
;
5411 size_t fileNameLength
;
5415 unsigned indx
= state_machine_regs
.file
- 1;
5417 if (indx
>= n_files
)
5419 warn (_("corrupt file index %u encountered\n"), indx
);
5420 fileName
= _("<corrupt>");
5423 fileName
= (char *) file_table
[indx
].name
;
5426 fileName
= _("<unknown>");
5428 fileNameLength
= strlen (fileName
);
5430 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
5432 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5433 /* Truncate file name */
5434 strncpy (newFileName
,
5435 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5436 MAX_FILENAME_LENGTH
+ 1);
5437 /* FIXME: This is to pacify gcc-10 which can warn that the
5438 strncpy above might leave a non-NUL terminated string
5439 in newFileName. It won't, but gcc's analysis doesn't
5440 quite go far enough to discover this. */
5441 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5445 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
5446 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
5449 /* A row with end_seq set to true has a meaningful address, but
5450 the other information in the same row is not significant.
5451 In such a row, print line as "-", and don't print
5453 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
5455 if (linfo
.li_max_ops_per_insn
== 1)
5457 if (xop
== -DW_LNE_end_sequence
)
5458 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x",
5460 state_machine_regs
.address
);
5462 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
5463 newFileName
, state_machine_regs
.line
,
5464 state_machine_regs
.address
);
5468 if (xop
== -DW_LNE_end_sequence
)
5469 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5471 state_machine_regs
.address
,
5472 state_machine_regs
.op_index
);
5474 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5475 newFileName
, state_machine_regs
.line
,
5476 state_machine_regs
.address
,
5477 state_machine_regs
.op_index
);
5482 if (linfo
.li_max_ops_per_insn
== 1)
5484 if (xop
== -DW_LNE_end_sequence
)
5485 printf ("%s %11s %#18" DWARF_VMA_FMT
"x",
5487 state_machine_regs
.address
);
5489 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5490 newFileName
, state_machine_regs
.line
,
5491 state_machine_regs
.address
);
5495 if (xop
== -DW_LNE_end_sequence
)
5496 printf ("%s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5498 state_machine_regs
.address
,
5499 state_machine_regs
.op_index
);
5501 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5502 newFileName
, state_machine_regs
.line
,
5503 state_machine_regs
.address
,
5504 state_machine_regs
.op_index
);
5508 if (xop
!= -DW_LNE_end_sequence
)
5510 if (state_machine_regs
.view
)
5511 printf (" %6u", state_machine_regs
.view
);
5515 if (state_machine_regs
.is_stmt
)
5520 state_machine_regs
.view
++;
5522 if (xop
== -DW_LNE_end_sequence
)
5524 reset_state_machine (linfo
.li_default_is_stmt
);
5539 if (directory_table
)
5541 free (directory_table
);
5542 directory_table
= NULL
;
5553 display_debug_lines (struct dwarf_section
*section
, void *file
)
5555 unsigned char *data
= section
->start
;
5556 unsigned char *end
= data
+ section
->size
;
5558 int retValDecoded
= 1;
5560 if (do_debug_lines
== 0)
5561 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5563 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5564 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5566 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5567 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5569 if (!retValRaw
|| !retValDecoded
)
5576 find_debug_info_for_offset (unsigned long offset
)
5580 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5583 for (i
= 0; i
< num_debug_info_entries
; i
++)
5584 if (debug_information
[i
].cu_offset
== offset
)
5585 return debug_information
+ i
;
5591 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5593 /* See gdb/gdb-index.h. */
5594 static const char * const kinds
[] =
5606 return _ (kinds
[kind
]);
5610 display_debug_pubnames_worker (struct dwarf_section
*section
,
5611 void *file ATTRIBUTE_UNUSED
,
5614 DWARF2_Internal_PubNames names
;
5615 unsigned char *start
= section
->start
;
5616 unsigned char *end
= start
+ section
->size
;
5618 /* It does not matter if this load fails,
5619 we test for that later on. */
5620 load_debug_info (file
);
5622 introduce (section
, false);
5626 unsigned char *data
;
5627 unsigned long sec_off
= start
- section
->start
;
5628 unsigned int offset_size
;
5630 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5631 if (names
.pn_length
== 0xffffffff)
5633 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5639 if (names
.pn_length
> (size_t) (end
- start
))
5641 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5644 dwarf_vmatoa ("x", names
.pn_length
));
5649 start
+= names
.pn_length
;
5651 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, start
);
5652 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, start
);
5654 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5655 && num_debug_info_entries
> 0
5656 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5657 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5658 (unsigned long) names
.pn_offset
, section
->name
);
5660 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, start
);
5662 printf (_(" Length: %ld\n"),
5663 (long) names
.pn_length
);
5664 printf (_(" Version: %d\n"),
5666 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5667 (unsigned long) names
.pn_offset
);
5668 printf (_(" Size of area in .debug_info section: %ld\n"),
5669 (long) names
.pn_size
);
5671 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5673 static int warned
= 0;
5677 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5685 printf (_("\n Offset Kind Name\n"));
5687 printf (_("\n Offset\tName\n"));
5691 bfd_size_type maxprint
;
5694 SAFE_BYTE_GET_AND_INC (offset
, data
, offset_size
, start
);
5701 maxprint
= (start
- data
) - 1;
5705 unsigned int kind_data
;
5706 gdb_index_symbol_kind kind
;
5707 const char *kind_name
;
5710 SAFE_BYTE_GET_AND_INC (kind_data
, data
, 1, start
);
5712 /* GCC computes the kind as the upper byte in the CU index
5713 word, and then right shifts it by the CU index size.
5714 Left shift KIND to where the gdb-index.h accessor macros
5716 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5717 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5718 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5719 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5720 printf (" %-6lx %s,%-10s %.*s\n",
5721 (unsigned long) offset
, is_static
? _("s") : _("g"),
5722 kind_name
, (int) maxprint
, data
);
5725 printf (" %-6lx\t%.*s\n",
5726 (unsigned long) offset
, (int) maxprint
, data
);
5728 data
+= strnlen ((char *) data
, maxprint
);
5741 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5743 return display_debug_pubnames_worker (section
, file
, 0);
5747 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5749 return display_debug_pubnames_worker (section
, file
, 1);
5753 display_debug_macinfo (struct dwarf_section
*section
,
5754 void *file ATTRIBUTE_UNUSED
)
5756 unsigned char *start
= section
->start
;
5757 unsigned char *end
= start
+ section
->size
;
5758 unsigned char *curr
= start
;
5759 enum dwarf_macinfo_record_type op
;
5761 introduce (section
, false);
5765 unsigned int lineno
;
5766 const unsigned char *string
;
5768 op
= (enum dwarf_macinfo_record_type
) *curr
;
5773 case DW_MACINFO_start_file
:
5775 unsigned int filenum
;
5777 READ_ULEB (lineno
, curr
, end
);
5778 READ_ULEB (filenum
, curr
, end
);
5779 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5784 case DW_MACINFO_end_file
:
5785 printf (_(" DW_MACINFO_end_file\n"));
5788 case DW_MACINFO_define
:
5789 READ_ULEB (lineno
, curr
, end
);
5791 curr
+= strnlen ((char *) string
, end
- string
);
5792 printf (_(" DW_MACINFO_define - lineno : %d macro : %*s\n"),
5793 lineno
, (int) (curr
- string
), string
);
5798 case DW_MACINFO_undef
:
5799 READ_ULEB (lineno
, curr
, end
);
5801 curr
+= strnlen ((char *) string
, end
- string
);
5802 printf (_(" DW_MACINFO_undef - lineno : %d macro : %*s\n"),
5803 lineno
, (int) (curr
- string
), string
);
5808 case DW_MACINFO_vendor_ext
:
5810 unsigned int constant
;
5812 READ_ULEB (constant
, curr
, end
);
5814 curr
+= strnlen ((char *) string
, end
- string
);
5815 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %*s\n"),
5816 constant
, (int) (curr
- string
), string
);
5827 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5828 filename and dirname corresponding to file name table entry with index
5829 FILEIDX. Return NULL on failure. */
5831 static unsigned char *
5832 get_line_filename_and_dirname (dwarf_vma line_offset
,
5834 unsigned char **dir_name
)
5836 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5837 unsigned char *hdrptr
, *dirtable
, *file_name
;
5838 unsigned int offset_size
;
5839 unsigned int version
, opcode_base
;
5840 dwarf_vma length
, diridx
;
5841 const unsigned char * end
;
5844 if (section
->start
== NULL
5845 || line_offset
>= section
->size
5849 hdrptr
= section
->start
+ line_offset
;
5850 end
= section
->start
+ section
->size
;
5852 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5853 if (length
== 0xffffffff)
5855 /* This section is 64-bit DWARF 3. */
5856 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5862 if (length
> (size_t) (end
- hdrptr
)
5863 || length
< 2 + offset_size
+ 1 + 3 + 1)
5865 end
= hdrptr
+ length
;
5867 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5868 if (version
!= 2 && version
!= 3 && version
!= 4)
5870 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5872 hdrptr
++; /* Skip max_ops_per_insn. */
5873 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5875 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5876 if (opcode_base
== 0
5877 || opcode_base
- 1 >= (size_t) (end
- hdrptr
))
5880 hdrptr
+= opcode_base
- 1;
5883 /* Skip over dirname table. */
5884 while (*hdrptr
!= '\0')
5886 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5892 hdrptr
++; /* Skip the NUL at the end of the table. */
5894 /* Now skip over preceding filename table entries. */
5895 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5897 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5900 SKIP_ULEB (hdrptr
, end
);
5901 SKIP_ULEB (hdrptr
, end
);
5902 SKIP_ULEB (hdrptr
, end
);
5904 if (hdrptr
>= end
|| *hdrptr
== '\0')
5908 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5913 READ_ULEB (diridx
, hdrptr
, end
);
5916 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5918 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
);
5922 if (dirtable
>= end
|| *dirtable
== '\0')
5924 *dir_name
= dirtable
;
5929 display_debug_macro (struct dwarf_section
*section
,
5932 unsigned char *start
= section
->start
;
5933 unsigned char *end
= start
+ section
->size
;
5934 unsigned char *curr
= start
;
5935 unsigned char *extended_op_buf
[256];
5936 bool is_dwo
= false;
5937 const char *suffix
= strrchr (section
->name
, '.');
5939 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
5942 load_debug_section_with_follow (str
, file
);
5943 load_debug_section_with_follow (line
, file
);
5944 load_debug_section_with_follow (str_index
, file
);
5946 introduce (section
, false);
5950 unsigned int lineno
, version
, flags
;
5951 unsigned int offset_size
;
5952 const unsigned char *string
;
5953 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5954 unsigned char **extended_ops
= NULL
;
5956 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5957 if (version
!= 4 && version
!= 5)
5959 error (_("Expected to find a version number of 4 or 5 in section %s but found %d instead\n"),
5960 section
->name
, version
);
5964 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5965 offset_size
= (flags
& 1) ? 8 : 4;
5966 printf (_(" Offset: 0x%lx\n"),
5967 (unsigned long) sec_offset
);
5968 printf (_(" Version: %d\n"), version
);
5969 printf (_(" Offset size: %d\n"), offset_size
);
5972 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5973 printf (_(" Offset into .debug_line: 0x%lx\n"),
5974 (unsigned long) line_offset
);
5978 unsigned int i
, count
, op
;
5981 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5983 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5984 extended_ops
= extended_op_buf
;
5987 printf (_(" Extension opcode arguments:\n"));
5988 for (i
= 0; i
< count
; i
++)
5990 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5991 extended_ops
[op
] = curr
;
5992 READ_ULEB (nargs
, curr
, end
);
5994 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5997 printf (_(" DW_MACRO_%02x arguments: "), op
);
5998 for (n
= 0; n
< nargs
; n
++)
6002 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
6003 printf ("%s%s", get_FORM_name (form
),
6004 n
== nargs
- 1 ? "\n" : ", ");
6014 case DW_FORM_block1
:
6015 case DW_FORM_block2
:
6016 case DW_FORM_block4
:
6018 case DW_FORM_string
:
6020 case DW_FORM_sec_offset
:
6023 error (_("Invalid extension opcode form %s\n"),
6024 get_FORM_name (form
));
6040 error (_(".debug_macro section not zero terminated\n"));
6044 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6050 case DW_MACRO_define
:
6051 READ_ULEB (lineno
, curr
, end
);
6053 curr
+= strnlen ((char *) string
, end
- string
);
6054 printf (_(" DW_MACRO_define - lineno : %d macro : %*s\n"),
6055 lineno
, (int) (curr
- string
), string
);
6060 case DW_MACRO_undef
:
6061 READ_ULEB (lineno
, curr
, end
);
6063 curr
+= strnlen ((char *) string
, end
- string
);
6064 printf (_(" DW_MACRO_undef - lineno : %d macro : %*s\n"),
6065 lineno
, (int) (curr
- string
), string
);
6070 case DW_MACRO_start_file
:
6072 unsigned int filenum
;
6073 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6075 READ_ULEB (lineno
, curr
, end
);
6076 READ_ULEB (filenum
, curr
, end
);
6078 if ((flags
& 2) == 0)
6079 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6082 = get_line_filename_and_dirname (line_offset
, filenum
,
6084 if (file_name
== NULL
)
6085 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6088 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6090 dir_name
!= NULL
? (const char *) dir_name
: "",
6091 dir_name
!= NULL
? "/" : "", file_name
);
6095 case DW_MACRO_end_file
:
6096 printf (_(" DW_MACRO_end_file\n"));
6099 case DW_MACRO_define_strp
:
6100 READ_ULEB (lineno
, curr
, end
);
6101 if (version
== 4 && is_dwo
)
6102 READ_ULEB (offset
, curr
, end
);
6104 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6105 string
= fetch_indirect_string (offset
);
6106 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6110 case DW_MACRO_undef_strp
:
6111 READ_ULEB (lineno
, curr
, end
);
6112 if (version
== 4 && is_dwo
)
6113 READ_ULEB (offset
, curr
, end
);
6115 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6116 string
= fetch_indirect_string (offset
);
6117 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6121 case DW_MACRO_import
:
6122 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6123 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
6124 (unsigned long) offset
);
6127 case DW_MACRO_define_sup
:
6128 READ_ULEB (lineno
, curr
, end
);
6129 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6130 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
6131 lineno
, (unsigned long) offset
);
6134 case DW_MACRO_undef_sup
:
6135 READ_ULEB (lineno
, curr
, end
);
6136 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6137 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
6138 lineno
, (unsigned long) offset
);
6141 case DW_MACRO_import_sup
:
6142 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6143 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
6144 (unsigned long) offset
);
6147 case DW_MACRO_define_strx
:
6148 case DW_MACRO_undef_strx
:
6149 READ_ULEB (lineno
, curr
, end
);
6150 READ_ULEB (offset
, curr
, end
);
6151 string
= (const unsigned char *)
6152 fetch_indexed_string (offset
, NULL
, offset_size
, false);
6153 if (op
== DW_MACRO_define_strx
)
6154 printf (" DW_MACRO_define_strx ");
6156 printf (" DW_MACRO_undef_strx ");
6158 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
6159 printf (_("lineno : %d macro : %s\n"),
6164 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6166 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6170 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6172 error (_(" Unknown macro opcode %02x seen\n"), op
);
6177 /* Skip over unhandled opcodes. */
6179 unsigned char *desc
= extended_ops
[op
];
6180 READ_ULEB (nargs
, desc
, end
);
6183 printf (_(" DW_MACRO_%02x\n"), op
);
6186 printf (_(" DW_MACRO_%02x -"), op
);
6187 for (n
= 0; n
< nargs
; n
++)
6191 /* DW_FORM_implicit_const is not expected here. */
6192 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6194 = read_and_display_attr_value (0, val
, 0,
6195 start
, curr
, end
, 0, 0, offset_size
,
6196 version
, NULL
, 0, NULL
,
6214 display_debug_abbrev (struct dwarf_section
*section
,
6215 void *file ATTRIBUTE_UNUSED
)
6217 abbrev_entry
*entry
;
6218 unsigned char *start
= section
->start
;
6220 introduce (section
, false);
6227 offset
= start
- section
->start
;
6228 list
= find_abbrev_list_by_abbrev_offset (0, offset
);
6231 list
= new_abbrev_list (0, offset
);
6232 start
= process_abbrev_set (section
, 0, section
->size
, offset
, list
);
6233 list
->start_of_next_abbrevs
= start
;
6236 start
= list
->start_of_next_abbrevs
;
6238 if (list
->first_abbrev
== NULL
)
6241 printf (_(" Number TAG (0x%lx)\n"), (long) offset
);
6243 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6247 printf (" %ld %s [%s]\n",
6249 get_TAG_name (entry
->tag
),
6250 entry
->children
? _("has children") : _("no children"));
6252 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6254 printf (" %-18s %s",
6255 get_AT_name (attr
->attribute
),
6256 get_FORM_name (attr
->form
));
6257 if (attr
->form
== DW_FORM_implicit_const
)
6258 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
6270 /* Return true when ADDR is the maximum address, when addresses are
6271 POINTER_SIZE bytes long. */
6274 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
6276 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
6277 return ((addr
& mask
) == mask
);
6280 /* Display a view pair list starting at *VSTART_PTR and ending at
6281 VLISTEND within SECTION. */
6284 display_view_pair_list (struct dwarf_section
*section
,
6285 unsigned char **vstart_ptr
,
6286 unsigned int debug_info_entry
,
6287 unsigned char *vlistend
)
6289 unsigned char *vstart
= *vstart_ptr
;
6290 unsigned char *section_end
= section
->start
+ section
->size
;
6291 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6293 if (vlistend
< section_end
)
6294 section_end
= vlistend
;
6298 while (vstart
< section_end
)
6300 dwarf_vma off
= vstart
- section
->start
;
6301 dwarf_vma vbegin
, vend
;
6303 READ_ULEB (vbegin
, vstart
, section_end
);
6304 if (vstart
== section_end
)
6307 READ_ULEB (vend
, vstart
, section_end
);
6308 printf (" %8.8lx ", (unsigned long) off
);
6310 print_dwarf_view (vbegin
, pointer_size
, 1);
6311 print_dwarf_view (vend
, pointer_size
, 1);
6312 printf (_("location view pair\n"));
6316 *vstart_ptr
= vstart
;
6319 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6322 display_loc_list (struct dwarf_section
*section
,
6323 unsigned char **start_ptr
,
6324 unsigned int debug_info_entry
,
6326 dwarf_vma base_address
,
6327 unsigned char **vstart_ptr
,
6330 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6331 unsigned char *section_end
= section
->start
+ section
->size
;
6332 unsigned long cu_offset
;
6333 unsigned int pointer_size
;
6334 unsigned int offset_size
;
6339 unsigned short length
;
6340 int need_frame_base
;
6342 if (debug_info_entry
>= num_debug_info_entries
)
6344 warn (_("No debug information available for loc lists of entry: %u\n"),
6349 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6350 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6351 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6352 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6354 if (pointer_size
< 2 || pointer_size
> 8)
6356 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6357 pointer_size
, debug_info_entry
);
6363 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6364 dwarf_vma vbegin
= vm1
, vend
= vm1
;
6366 if (2 * pointer_size
> (size_t) (section_end
- start
))
6368 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6369 (unsigned long) offset
);
6373 printf (" %8.8lx ", (unsigned long) off
);
6375 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6376 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6378 if (begin
== 0 && end
== 0)
6380 /* PR 18374: In a object file we can have a location list that
6381 starts with a begin and end of 0 because there are relocations
6382 that need to be applied to the addresses. Actually applying
6383 the relocations now does not help as they will probably resolve
6384 to 0, since the object file has not been fully linked. Real
6385 end of list markers will not have any relocations against them. */
6386 if (! reloc_at (section
, off
)
6387 && ! reloc_at (section
, off
+ pointer_size
))
6389 printf (_("<End of list>\n"));
6394 /* Check base address specifiers. */
6395 if (is_max_address (begin
, pointer_size
)
6396 && !is_max_address (end
, pointer_size
))
6399 print_dwarf_vma (begin
, pointer_size
);
6400 print_dwarf_vma (end
, pointer_size
);
6401 printf (_("(base address)\n"));
6407 off
= offset
+ (vstart
- *start_ptr
);
6409 READ_ULEB (vbegin
, vstart
, section_end
);
6410 print_dwarf_view (vbegin
, pointer_size
, 1);
6412 READ_ULEB (vend
, vstart
, section_end
);
6413 print_dwarf_view (vend
, pointer_size
, 1);
6415 printf (_("views at %8.8lx for:\n %*s "),
6416 (unsigned long) off
, 8, "");
6419 if (2 > (size_t) (section_end
- start
))
6421 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6422 (unsigned long) offset
);
6426 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6428 if (length
> (size_t) (section_end
- start
))
6430 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6431 (unsigned long) offset
);
6435 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6436 print_dwarf_vma (end
+ base_address
, pointer_size
);
6439 need_frame_base
= decode_location_expression (start
,
6444 cu_offset
, section
);
6447 if (need_frame_base
&& !has_frame_base
)
6448 printf (_(" [without DW_AT_frame_base]"));
6450 if (begin
== end
&& vbegin
== vend
)
6451 fputs (_(" (start == end)"), stdout
);
6452 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6453 fputs (_(" (start > end)"), stdout
);
6461 *vstart_ptr
= vstart
;
6464 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6467 display_loclists_list (struct dwarf_section
*section
,
6468 unsigned char **start_ptr
,
6469 unsigned int debug_info_entry
,
6471 dwarf_vma base_address
,
6472 unsigned char **vstart_ptr
,
6475 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6476 unsigned char *section_end
= section
->start
+ section
->size
;
6477 unsigned long cu_offset
;
6478 unsigned int pointer_size
;
6479 unsigned int offset_size
;
6482 /* Initialize it due to a false compiler warning. */
6483 dwarf_vma begin
= -1, vbegin
= -1;
6484 dwarf_vma end
= -1, vend
= -1;
6486 int need_frame_base
;
6488 if (debug_info_entry
>= num_debug_info_entries
)
6490 warn (_("No debug information available for "
6491 "loclists lists of entry: %u\n"),
6496 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6497 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6498 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6499 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6501 if (pointer_size
< 2 || pointer_size
> 8)
6503 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6504 pointer_size
, debug_info_entry
);
6510 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6511 enum dwarf_location_list_entry_type llet
;
6513 if (start
+ 1 > section_end
)
6515 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6516 (unsigned long) offset
);
6520 printf (" %8.8lx ", (unsigned long) off
);
6522 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6524 if (vstart
&& (llet
== DW_LLE_offset_pair
6525 || llet
== DW_LLE_start_end
6526 || llet
== DW_LLE_start_length
))
6528 off
= offset
+ (vstart
- *start_ptr
);
6530 READ_ULEB (vbegin
, vstart
, section_end
);
6531 print_dwarf_view (vbegin
, pointer_size
, 1);
6533 READ_ULEB (vend
, vstart
, section_end
);
6534 print_dwarf_view (vend
, pointer_size
, 1);
6536 printf (_("views at %8.8lx for:\n %*s "),
6537 (unsigned long) off
, 8, "");
6542 case DW_LLE_end_of_list
:
6543 printf (_("<End of list>\n"));
6545 case DW_LLE_offset_pair
:
6546 READ_ULEB (begin
, start
, section_end
);
6547 begin
+= base_address
;
6548 READ_ULEB (end
, start
, section_end
);
6549 end
+= base_address
;
6551 case DW_LLE_start_end
:
6552 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6553 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6555 case DW_LLE_start_length
:
6556 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6557 READ_ULEB (end
, start
, section_end
);
6560 case DW_LLE_base_address
:
6561 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6563 print_dwarf_vma (base_address
, pointer_size
);
6564 printf (_("(base address)\n"));
6566 #ifdef DW_LLE_view_pair
6567 case DW_LLE_view_pair
:
6569 printf (_("View pair entry in loclist with locviews attribute\n"));
6570 READ_ULEB (vbegin
, start
, section_end
);
6571 print_dwarf_view (vbegin
, pointer_size
, 1);
6573 READ_ULEB (vend
, start
, section_end
);
6574 print_dwarf_view (vend
, pointer_size
, 1);
6576 printf (_("views for:\n"));
6580 error (_("Invalid location list entry type %d\n"), llet
);
6583 if (llet
== DW_LLE_end_of_list
)
6585 if (llet
!= DW_LLE_offset_pair
6586 && llet
!= DW_LLE_start_end
6587 && llet
!= DW_LLE_start_length
)
6590 if (start
== section_end
)
6592 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6593 (unsigned long) offset
);
6596 READ_ULEB (length
, start
, section_end
);
6598 if (length
> (size_t) (section_end
- start
))
6600 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6601 (unsigned long) offset
);
6605 print_dwarf_vma (begin
, pointer_size
);
6606 print_dwarf_vma (end
, pointer_size
);
6609 need_frame_base
= decode_location_expression (start
,
6614 cu_offset
, section
);
6617 if (need_frame_base
&& !has_frame_base
)
6618 printf (_(" [without DW_AT_frame_base]"));
6620 if (begin
== end
&& vbegin
== vend
)
6621 fputs (_(" (start == end)"), stdout
);
6622 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6623 fputs (_(" (start > end)"), stdout
);
6631 if (vbegin
!= vm1
|| vend
!= vm1
)
6632 printf (_("Trailing view pair not used in a range"));
6635 *vstart_ptr
= vstart
;
6638 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6639 right-adjusted in a field of length LEN, and followed by a space. */
6642 print_addr_index (unsigned int idx
, unsigned int len
)
6644 static char buf
[15];
6645 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6646 printf ("%*s ", len
, buf
);
6649 /* Display a location list from a .dwo section. It uses address indexes rather
6650 than embedded addresses. This code closely follows display_loc_list, but the
6651 two are sufficiently different that combining things is very ugly. */
6654 display_loc_list_dwo (struct dwarf_section
*section
,
6655 unsigned char **start_ptr
,
6656 unsigned int debug_info_entry
,
6658 unsigned char **vstart_ptr
,
6661 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6662 unsigned char *section_end
= section
->start
+ section
->size
;
6663 unsigned long cu_offset
;
6664 unsigned int pointer_size
;
6665 unsigned int offset_size
;
6668 unsigned short length
;
6669 int need_frame_base
;
6672 if (debug_info_entry
>= num_debug_info_entries
)
6674 warn (_("No debug information for loc lists of entry: %u\n"),
6679 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6680 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6681 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6682 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6684 if (pointer_size
< 2 || pointer_size
> 8)
6686 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6687 pointer_size
, debug_info_entry
);
6693 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6695 if (start
>= section_end
)
6697 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6698 (unsigned long) offset
);
6702 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6715 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6717 READ_ULEB (view
, vstart
, section_end
);
6718 print_dwarf_view (view
, 8, 1);
6720 READ_ULEB (view
, vstart
, section_end
);
6721 print_dwarf_view (view
, 8, 1);
6723 printf (_("views at %8.8lx for:\n %*s "),
6724 (unsigned long) off
, 8, "");
6732 case 0: /* A terminating entry. */
6734 *vstart_ptr
= vstart
;
6735 printf (_("<End of list>\n"));
6737 case 1: /* A base-address entry. */
6738 READ_ULEB (idx
, start
, section_end
);
6739 print_addr_index (idx
, 8);
6740 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6741 printf (_("(base address selection entry)\n"));
6743 case 2: /* A start/end entry. */
6744 READ_ULEB (idx
, start
, section_end
);
6745 print_addr_index (idx
, 8);
6746 READ_ULEB (idx
, start
, section_end
);
6747 print_addr_index (idx
, 8);
6749 case 3: /* A start/length entry. */
6750 READ_ULEB (idx
, start
, section_end
);
6751 print_addr_index (idx
, 8);
6752 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6753 printf ("%08x ", idx
);
6755 case 4: /* An offset pair entry. */
6756 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6757 printf ("%08x ", idx
);
6758 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6759 printf ("%08x ", idx
);
6762 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6764 *vstart_ptr
= vstart
;
6768 if (2 > (size_t) (section_end
- start
))
6770 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6771 (unsigned long) offset
);
6775 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6776 if (length
> (size_t) (section_end
- start
))
6778 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6779 (unsigned long) offset
);
6784 need_frame_base
= decode_location_expression (start
,
6789 cu_offset
, section
);
6792 if (need_frame_base
&& !has_frame_base
)
6793 printf (_(" [without DW_AT_frame_base]"));
6801 *vstart_ptr
= vstart
;
6804 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6807 static dwarf_vma
*loc_offsets
, *loc_views
;
6810 loc_offsets_compar (const void *ap
, const void *bp
)
6812 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6813 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6815 int ret
= (a
> b
) - (b
> a
);
6819 a
= loc_views
[*(const unsigned int *) ap
];
6820 b
= loc_views
[*(const unsigned int *) bp
];
6822 ret
= (a
> b
) - (b
> a
);
6828 display_debug_loc (struct dwarf_section
*section
, void *file
)
6830 unsigned char *start
= section
->start
, *vstart
= NULL
;
6831 unsigned long bytes
;
6832 unsigned char *section_begin
= start
;
6833 unsigned int num_loc_list
= 0;
6834 unsigned long last_offset
= 0;
6835 unsigned long last_view
= 0;
6836 unsigned int first
= 0;
6839 int seen_first_offset
= 0;
6840 int locs_sorted
= 1;
6841 unsigned char *next
= start
, *vnext
= vstart
;
6842 unsigned int *array
= NULL
;
6843 const char *suffix
= strrchr (section
->name
, '.');
6844 bool is_dwo
= false;
6845 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6846 dwarf_vma expected_start
= 0;
6848 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6851 bytes
= section
->size
;
6855 printf (_("\nThe %s section is empty.\n"), section
->name
);
6861 unsigned char *hdrptr
= section_begin
;
6862 dwarf_vma ll_length
;
6863 unsigned short ll_version
;
6864 unsigned char *end
= section_begin
+ section
->size
;
6865 unsigned char address_size
, segment_selector_size
;
6866 uint32_t offset_entry_count
;
6868 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6869 if (ll_length
== 0xffffffff)
6870 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6872 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6873 if (ll_version
!= 5)
6875 warn (_("The %s section contains corrupt or "
6876 "unsupported version number: %d.\n"),
6877 section
->name
, ll_version
);
6881 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6883 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6884 if (segment_selector_size
!= 0)
6886 warn (_("The %s section contains "
6887 "unsupported segment selector size: %d.\n"),
6888 section
->name
, segment_selector_size
);
6892 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6893 if (offset_entry_count
!= 0)
6895 warn (_("The %s section contains "
6896 "unsupported offset entry count: %d.\n"),
6897 section
->name
, offset_entry_count
);
6901 expected_start
= hdrptr
- section_begin
;
6904 if (load_debug_info (file
) == 0)
6906 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6911 /* Check the order of location list in .debug_info section. If
6912 offsets of location lists are in the ascending order, we can
6913 use `debug_information' directly. */
6914 for (i
= 0; i
< num_debug_info_entries
; i
++)
6918 num
= debug_information
[i
].num_loc_offsets
;
6919 if (num
> num_loc_list
)
6922 /* Check if we can use `debug_information' directly. */
6923 if (locs_sorted
&& num
!= 0)
6925 if (!seen_first_offset
)
6927 /* This is the first location list. */
6928 last_offset
= debug_information
[i
].loc_offsets
[0];
6929 last_view
= debug_information
[i
].loc_views
[0];
6931 seen_first_offset
= 1;
6937 for (; j
< num
; j
++)
6940 debug_information
[i
].loc_offsets
[j
]
6941 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6942 && last_view
> debug_information
[i
].loc_views
[j
]))
6947 last_offset
= debug_information
[i
].loc_offsets
[j
];
6948 last_view
= debug_information
[i
].loc_views
[j
];
6953 if (!seen_first_offset
)
6954 error (_("No location lists in .debug_info section!\n"));
6956 if (debug_information
[first
].num_loc_offsets
> 0
6957 && debug_information
[first
].loc_offsets
[0] != expected_start
6958 && debug_information
[first
].loc_views
[0] != expected_start
)
6959 warn (_("Location lists in %s section start at 0x%s\n"),
6961 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6964 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6966 introduce (section
, false);
6968 if (reloc_at (section
, 0))
6969 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6971 printf (_(" Offset Begin End Expression\n"));
6973 seen_first_offset
= 0;
6974 for (i
= first
; i
< num_debug_info_entries
; i
++)
6976 dwarf_vma offset
, voffset
;
6977 dwarf_vma base_address
;
6983 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6985 loc_offsets
= debug_information
[i
].loc_offsets
;
6986 loc_views
= debug_information
[i
].loc_views
;
6987 qsort (array
, debug_information
[i
].num_loc_offsets
,
6988 sizeof (*array
), loc_offsets_compar
);
6991 int adjacent_view_loclists
= 1;
6992 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6994 j
= locs_sorted
? k
: array
[k
];
6996 && (debug_information
[i
].loc_offsets
[locs_sorted
6997 ? k
- 1 : array
[k
- 1]]
6998 == debug_information
[i
].loc_offsets
[j
])
6999 && (debug_information
[i
].loc_views
[locs_sorted
7000 ? k
- 1 : array
[k
- 1]]
7001 == debug_information
[i
].loc_views
[j
]))
7003 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
7004 offset
= debug_information
[i
].loc_offsets
[j
];
7005 next
= section_begin
+ offset
;
7006 voffset
= debug_information
[i
].loc_views
[j
];
7008 vnext
= section_begin
+ voffset
;
7011 base_address
= debug_information
[i
].base_address
;
7013 if (vnext
&& vnext
< next
)
7016 display_view_pair_list (section
, &vstart
, i
, next
);
7021 if (!seen_first_offset
|| !adjacent_view_loclists
)
7022 seen_first_offset
= 1;
7026 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
7027 (unsigned long) (start
- section_begin
),
7028 (unsigned long) offset
);
7029 else if (start
> next
)
7030 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
7031 (unsigned long) (start
- section_begin
),
7032 (unsigned long) offset
);
7037 if (offset
>= bytes
)
7039 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
7040 (unsigned long) offset
);
7044 if (vnext
&& voffset
>= bytes
)
7046 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
7047 (unsigned long) voffset
);
7054 display_loc_list_dwo (section
, &start
, i
, offset
,
7055 &vstart
, has_frame_base
);
7057 display_loc_list (section
, &start
, i
, offset
, base_address
,
7058 &vstart
, has_frame_base
);
7063 warn (_("DWO is not yet supported.\n"));
7065 display_loclists_list (section
, &start
, i
, offset
, base_address
,
7066 &vstart
, has_frame_base
);
7069 /* FIXME: this arrangement is quite simplistic. Nothing
7070 requires locview lists to be adjacent to corresponding
7071 loclists, and a single loclist could be augmented by
7072 different locview lists, and vice-versa, unlikely as it
7073 is that it would make sense to do so. Hopefully we'll
7074 have view pair support built into loclists before we ever
7075 need to address all these possibilities. */
7076 if (adjacent_view_loclists
&& vnext
7077 && vnext
!= start
&& vstart
!= next
)
7079 adjacent_view_loclists
= 0;
7080 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7083 if (vnext
&& vnext
== start
)
7084 display_view_pair_list (section
, &start
, i
, vstart
);
7088 if (start
< section
->start
+ section
->size
)
7089 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7090 "There are %ld unused bytes at the end of section %s\n",
7091 (long) (section
->start
+ section
->size
- start
)),
7092 (long) (section
->start
+ section
->size
- start
), section
->name
);
7099 display_debug_str (struct dwarf_section
*section
,
7100 void *file ATTRIBUTE_UNUSED
)
7102 unsigned char *start
= section
->start
;
7103 unsigned long bytes
= section
->size
;
7104 dwarf_vma addr
= section
->address
;
7108 printf (_("\nThe %s section is empty.\n"), section
->name
);
7112 introduce (section
, false);
7120 lbytes
= (bytes
> 16 ? 16 : bytes
);
7122 printf (" 0x%8.8lx ", (unsigned long) addr
);
7124 for (j
= 0; j
< 16; j
++)
7127 printf ("%2.2x", start
[j
]);
7135 for (j
= 0; j
< lbytes
; j
++)
7138 if (k
>= ' ' && k
< 0x80)
7157 display_debug_info (struct dwarf_section
*section
, void *file
)
7159 return process_debug_info (section
, file
, section
->abbrev_sec
, false, false);
7163 display_debug_types (struct dwarf_section
*section
, void *file
)
7165 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7169 display_trace_info (struct dwarf_section
*section
, void *file
)
7171 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7175 display_debug_aranges (struct dwarf_section
*section
,
7176 void *file ATTRIBUTE_UNUSED
)
7178 unsigned char *start
= section
->start
;
7179 unsigned char *end
= start
+ section
->size
;
7181 introduce (section
, false);
7183 /* It does not matter if this load fails,
7184 we test for that later on. */
7185 load_debug_info (file
);
7189 unsigned char *hdrptr
;
7190 DWARF2_Internal_ARange arange
;
7191 unsigned char *addr_ranges
;
7194 unsigned long sec_off
;
7195 unsigned char address_size
;
7197 unsigned int offset_size
;
7198 unsigned char *end_ranges
;
7201 sec_off
= hdrptr
- section
->start
;
7203 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7204 if (arange
.ar_length
== 0xffffffff)
7206 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7212 if (arange
.ar_length
> (size_t) (end
- hdrptr
))
7214 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
7217 dwarf_vmatoa ("x", arange
.ar_length
));
7220 end_ranges
= hdrptr
+ arange
.ar_length
;
7222 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end_ranges
);
7223 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
,
7226 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7227 && num_debug_info_entries
> 0
7228 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7229 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
7230 (unsigned long) arange
.ar_info_offset
, section
->name
);
7232 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end_ranges
);
7233 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end_ranges
);
7235 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7237 /* PR 19872: A version number of 0 probably means that there is
7238 padding at the end of the .debug_aranges section. Gold puts
7239 it there when performing an incremental link, for example.
7240 So do not generate a warning in this case. */
7241 if (arange
.ar_version
)
7242 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7246 printf (_(" Length: %ld\n"),
7247 (long) arange
.ar_length
);
7248 printf (_(" Version: %d\n"), arange
.ar_version
);
7249 printf (_(" Offset into .debug_info: 0x%lx\n"),
7250 (unsigned long) arange
.ar_info_offset
);
7251 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7252 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7254 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7256 /* PR 17512: file: 001-108546-0.001:0.1. */
7257 if (address_size
== 0 || address_size
> 8)
7259 error (_("Invalid address size in %s section!\n"),
7264 /* The DWARF spec does not require that the address size be a power
7265 of two, but we do. This will have to change if we ever encounter
7266 an uneven architecture. */
7267 if ((address_size
& (address_size
- 1)) != 0)
7269 warn (_("Pointer size + Segment size is not a power of two.\n"));
7273 if (address_size
> 4)
7274 printf (_("\n Address Length\n"));
7276 printf (_("\n Address Length\n"));
7278 addr_ranges
= hdrptr
;
7280 /* Must pad to an alignment boundary that is twice the address size. */
7281 excess
= (hdrptr
- start
) % (2 * address_size
);
7283 addr_ranges
+= (2 * address_size
) - excess
;
7287 while (2 * address_size
<= (size_t) (start
- addr_ranges
))
7289 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, start
);
7290 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, start
);
7293 print_dwarf_vma (address
, address_size
);
7294 print_dwarf_vma (length
, address_size
);
7304 /* Comparison function for qsort. */
7306 comp_addr_base (const void * v0
, const void * v1
)
7308 debug_info
*info0
= *(debug_info
**) v0
;
7309 debug_info
*info1
= *(debug_info
**) v1
;
7310 return info0
->addr_base
- info1
->addr_base
;
7313 /* Display the debug_addr section. */
7315 display_debug_addr (struct dwarf_section
*section
,
7318 debug_info
**debug_addr_info
;
7319 unsigned char *entry
;
7323 unsigned char * header
;
7325 if (section
->size
== 0)
7327 printf (_("\nThe %s section is empty.\n"), section
->name
);
7331 if (load_debug_info (file
) == 0)
7333 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7338 introduce (section
, false);
7340 /* PR 17531: file: cf38d01b.
7341 We use xcalloc because a corrupt file may not have initialised all of the
7342 fields in the debug_info structure, which means that the sort below might
7343 try to move uninitialised data. */
7344 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7345 sizeof (debug_info
*));
7348 for (i
= 0; i
< num_debug_info_entries
; i
++)
7349 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7351 /* PR 17531: file: cf38d01b. */
7352 if (debug_information
[i
].addr_base
>= section
->size
)
7353 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
7354 (unsigned long) debug_information
[i
].addr_base
, i
);
7356 debug_addr_info
[count
++] = debug_information
+ i
;
7359 /* Add a sentinel to make iteration convenient. */
7360 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7361 debug_addr_info
[count
]->addr_base
= section
->size
;
7362 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7364 header
= section
->start
;
7365 for (i
= 0; i
< count
; i
++)
7368 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7370 printf (_(" For compilation unit at offset 0x%s:\n"),
7371 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
7373 printf (_("\tIndex\tAddress\n"));
7374 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7375 if (debug_addr_info
[i
]->dwarf_version
>= 5)
7377 size_t header_size
= entry
- header
;
7378 unsigned char * curr_header
= header
;
7381 int segment_selector_size
;
7383 if (header_size
!= 8 && header_size
!= 16)
7385 warn (_("Corrupt %s section: expecting header size of 8 or 16, but found %ld instead\n"),
7386 section
->name
, (long) header_size
);
7390 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 4, entry
);
7391 if (length
== 0xffffffff)
7392 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 8, entry
);
7393 end
= curr_header
+ length
;
7395 SAFE_BYTE_GET_AND_INC (version
, curr_header
, 2, entry
);
7397 warn (_("Corrupt %s section: expecting version number 5 in header but found %d instead\n"),
7398 section
->name
, version
);
7400 SAFE_BYTE_GET_AND_INC (address_size
, curr_header
, 1, entry
);
7401 SAFE_BYTE_GET_AND_INC (segment_selector_size
, curr_header
, 1, entry
);
7402 address_size
+= segment_selector_size
;
7405 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7410 dwarf_vma base
= byte_get (entry
, address_size
);
7411 printf (_("\t%d:\t"), idx
);
7412 print_dwarf_vma (base
, address_size
);
7414 entry
+= address_size
;
7420 free (debug_addr_info
);
7424 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7427 display_debug_str_offsets (struct dwarf_section
*section
,
7428 void *file ATTRIBUTE_UNUSED
)
7432 if (section
->size
== 0)
7434 printf (_("\nThe %s section is empty.\n"), section
->name
);
7438 unsigned char *start
= section
->start
;
7439 unsigned char *end
= start
+ section
->size
;
7440 unsigned char *curr
= start
;
7442 const char *suffix
= strrchr (section
->name
, '.');
7443 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
7446 load_debug_section_with_follow (str_dwo
, file
);
7448 load_debug_section_with_follow (str
, file
);
7450 introduce (section
, false);
7455 dwarf_vma entry_length
;
7457 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7458 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7459 if (length
== 0xffffffff)
7461 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
7467 unsigned char *entries_end
;
7470 /* This is probably an old style .debug_str_offset section which
7471 just contains offsets and no header (and the first offset is 0). */
7472 length
= section
->size
;
7473 curr
= section
->start
;
7476 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7477 printf (_(" Index Offset [String]\n"));
7481 if (length
<= (dwarf_vma
) (end
- curr
))
7482 entries_end
= curr
+ length
;
7485 warn (_("Section %s is too small %#lx\n"),
7486 section
->name
, (unsigned long) section
->size
);
7491 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, entries_end
);
7493 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7496 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, entries_end
);
7498 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
7500 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7501 printf (_(" Version: %#lx\n"), (unsigned long) version
);
7502 printf (_(" Index Offset [String]\n"));
7505 for (idx
= 0; curr
< entries_end
; idx
++)
7508 const unsigned char * string
;
7510 if ((dwarf_vma
) (entries_end
- curr
) < entry_length
)
7511 /* Not enough space to read one entry_length, give up. */
7514 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, entries_end
);
7516 string
= (const unsigned char *)
7517 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
7519 string
= fetch_indirect_string (offset
);
7521 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
7529 /* Each debug_information[x].range_lists[y] gets this representation for
7530 sorting purposes. */
7534 /* The debug_information[x].range_lists[y] value. */
7535 dwarf_vma ranges_offset
;
7537 /* Original debug_information to find parameters of the data. */
7538 debug_info
*debug_info_p
;
7541 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7544 range_entry_compar (const void *ap
, const void *bp
)
7546 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7547 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7548 const dwarf_vma a
= a_re
->ranges_offset
;
7549 const dwarf_vma b
= b_re
->ranges_offset
;
7551 return (a
> b
) - (b
> a
);
7555 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
7556 unsigned int pointer_size
, unsigned long offset
,
7557 unsigned long base_address
)
7559 while (start
< finish
)
7564 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7565 if (start
>= finish
)
7567 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7569 printf (" %8.8lx ", offset
);
7571 if (begin
== 0 && end
== 0)
7573 printf (_("<End of list>\n"));
7577 /* Check base address specifiers. */
7578 if (is_max_address (begin
, pointer_size
)
7579 && !is_max_address (end
, pointer_size
))
7582 print_dwarf_vma (begin
, pointer_size
);
7583 print_dwarf_vma (end
, pointer_size
);
7584 printf ("(base address)\n");
7588 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7589 print_dwarf_vma (end
+ base_address
, pointer_size
);
7592 fputs (_("(start == end)"), stdout
);
7593 else if (begin
> end
)
7594 fputs (_("(start > end)"), stdout
);
7601 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7602 unsigned int pointer_size
, unsigned long offset
,
7603 unsigned long base_address
)
7605 unsigned char *next
= start
;
7609 unsigned long off
= offset
+ (start
- next
);
7610 enum dwarf_range_list_entry rlet
;
7611 /* Initialize it due to a false compiler warning. */
7612 dwarf_vma begin
= -1, length
, end
= -1;
7614 if (start
>= finish
)
7616 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7621 printf (" %8.8lx ", off
);
7623 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7627 case DW_RLE_end_of_list
:
7628 printf (_("<End of list>\n"));
7630 case DW_RLE_base_address
:
7631 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7632 print_dwarf_vma (base_address
, pointer_size
);
7633 printf (_("(base address)\n"));
7635 case DW_RLE_start_length
:
7636 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7637 READ_ULEB (length
, start
, finish
);
7638 end
= begin
+ length
;
7640 case DW_RLE_offset_pair
:
7641 READ_ULEB (begin
, start
, finish
);
7642 READ_ULEB (end
, start
, finish
);
7644 case DW_RLE_start_end
:
7645 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7646 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7649 error (_("Invalid range list entry type %d\n"), rlet
);
7650 rlet
= DW_RLE_end_of_list
;
7653 if (rlet
== DW_RLE_end_of_list
)
7655 if (rlet
== DW_RLE_base_address
)
7658 /* Only a DW_RLE_offset_pair needs the base address added. */
7659 if (rlet
== DW_RLE_offset_pair
)
7661 begin
+= base_address
;
7662 end
+= base_address
;
7665 print_dwarf_vma (begin
, pointer_size
);
7666 print_dwarf_vma (end
, pointer_size
);
7669 fputs (_("(start == end)"), stdout
);
7670 else if (begin
> end
)
7671 fputs (_("(start > end)"), stdout
);
7678 display_debug_ranges (struct dwarf_section
*section
,
7679 void *file ATTRIBUTE_UNUSED
)
7681 unsigned char *start
= section
->start
;
7682 unsigned char *last_start
= start
;
7683 unsigned long bytes
= section
->size
;
7684 unsigned char *section_begin
= start
;
7685 unsigned char *finish
= start
+ bytes
;
7686 unsigned int num_range_list
, i
;
7687 struct range_entry
*range_entries
, *range_entry_fill
;
7688 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7689 /* Initialize it due to a false compiler warning. */
7690 unsigned char address_size
= 0;
7691 dwarf_vma last_offset
= 0;
7695 printf (_("\nThe %s section is empty.\n"), section
->name
);
7701 dwarf_vma initial_length
;
7702 unsigned char segment_selector_size
;
7703 unsigned int offset_size
, offset_entry_count
;
7704 unsigned short version
;
7706 /* Get and check the length of the block. */
7707 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7709 if (initial_length
== 0xffffffff)
7711 /* This section is 64-bit DWARF 3. */
7712 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7718 if (initial_length
> (size_t) (finish
- start
))
7720 /* If the length field has a relocation against it, then we should
7721 not complain if it is inaccurate (and probably negative).
7722 It is copied from .debug_line handling code. */
7723 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7725 initial_length
= finish
- start
;
7729 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7730 (long) initial_length
);
7734 finish
= start
+ initial_length
;
7736 /* Get and check the version number. */
7737 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7741 warn (_("Only DWARF version 5 debug_rnglists info "
7742 "is currently supported.\n"));
7746 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7748 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7749 if (segment_selector_size
!= 0)
7751 warn (_("The %s section contains "
7752 "unsupported segment selector size: %d.\n"),
7753 section
->name
, segment_selector_size
);
7757 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7758 if (offset_entry_count
!= 0)
7760 warn (_("The %s section contains "
7761 "unsupported offset entry count: %u.\n"),
7762 section
->name
, offset_entry_count
);
7767 if (load_debug_info (file
) == 0)
7769 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7775 for (i
= 0; i
< num_debug_info_entries
; i
++)
7777 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7778 /* Skip .debug_rnglists reference. */
7780 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7781 /* Skip .debug_range reference. */
7783 num_range_list
+= debug_information
[i
].num_range_lists
;
7786 if (num_range_list
== 0)
7788 /* This can happen when the file was compiled with -gsplit-debug
7789 which removes references to range lists from the primary .o file. */
7790 printf (_("No range lists in .debug_info section.\n"));
7794 range_entries
= (struct range_entry
*)
7795 xmalloc (sizeof (*range_entries
) * num_range_list
);
7796 range_entry_fill
= range_entries
;
7798 for (i
= 0; i
< num_debug_info_entries
; i
++)
7800 debug_info
*debug_info_p
= &debug_information
[i
];
7803 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7804 /* Skip .debug_rnglists reference. */
7806 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7807 /* Skip .debug_range reference. */
7810 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7812 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7813 range_entry_fill
->debug_info_p
= debug_info_p
;
7818 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7819 range_entry_compar
);
7821 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7822 warn (_("Range lists in %s section start at 0x%lx\n"),
7823 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7825 introduce (section
, false);
7827 printf (_(" Offset Begin End\n"));
7829 for (i
= 0; i
< num_range_list
; i
++)
7831 struct range_entry
*range_entry
= &range_entries
[i
];
7832 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7833 unsigned int pointer_size
;
7835 unsigned char *next
;
7836 dwarf_vma base_address
;
7838 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7839 offset
= range_entry
->ranges_offset
;
7840 base_address
= debug_info_p
->base_address
;
7842 /* PR 17512: file: 001-101485-0.001:0.1. */
7843 if (pointer_size
< 2 || pointer_size
> 8)
7845 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7846 pointer_size
, (unsigned long) offset
);
7850 if (offset
> (size_t) (finish
- section_begin
))
7852 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7853 (unsigned long) offset
, i
);
7856 next
= section_begin
+ offset
;
7858 /* If multiple DWARF entities reference the same range then we will
7859 have multiple entries in the `range_entries' list for the same
7860 offset. Thanks to the sort above these will all be consecutive in
7861 the `range_entries' list, so we can easily ignore duplicates
7863 if (i
> 0 && last_offset
== offset
)
7865 last_offset
= offset
;
7867 if (dwarf_check
!= 0 && i
> 0)
7870 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7871 (unsigned long) (start
- section_begin
),
7872 (unsigned long) (next
- section_begin
), section
->name
);
7873 else if (start
> next
)
7875 if (next
== last_start
)
7877 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7878 (unsigned long) (start
- section_begin
),
7879 (unsigned long) (next
- section_begin
), section
->name
);
7886 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7887 (start
, finish
, pointer_size
, offset
, base_address
);
7891 free (range_entries
);
7896 typedef struct Frame_Chunk
7898 struct Frame_Chunk
*next
;
7899 unsigned char *chunk_start
;
7901 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7902 short int *col_type
;
7905 unsigned int code_factor
;
7909 unsigned int cfa_reg
;
7910 dwarf_vma cfa_offset
;
7912 unsigned char fde_encoding
;
7913 unsigned char cfa_exp
;
7914 unsigned char ptr_size
;
7915 unsigned char segment_size
;
7919 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7920 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7921 static const char *const *dwarf_regnames
;
7922 static unsigned int dwarf_regnames_count
;
7925 /* A marker for a col_type that means this column was never referenced
7926 in the frame info. */
7927 #define DW_CFA_unreferenced (-1)
7929 /* Return 0 if no more space is needed, 1 if more space is needed,
7930 -1 for invalid reg. */
7933 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7935 unsigned int prev
= fc
->ncols
;
7937 if (reg
< (unsigned int) fc
->ncols
)
7940 if (dwarf_regnames_count
> 0
7941 && reg
> dwarf_regnames_count
)
7944 fc
->ncols
= reg
+ 1;
7945 /* PR 17512: file: 10450-2643-0.004.
7946 If reg == -1 then this can happen... */
7950 /* PR 17512: file: 2844a11d. */
7951 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7953 error (_("Unfeasibly large register number: %u\n"), reg
);
7955 /* FIXME: 1024 is an arbitrary limit. Increase it if
7956 we ever encounter a valid binary that exceeds it. */
7960 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7961 sizeof (short int));
7962 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7963 /* PR 17512: file:002-10025-0.005. */
7964 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7966 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7972 while (prev
< fc
->ncols
)
7974 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7975 fc
->col_offset
[prev
] = 0;
7981 static const char *const dwarf_regnames_i386
[] =
7983 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7984 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7985 "eip", "eflags", NULL
, /* 8 - 10 */
7986 "st0", "st1", "st2", "st3", /* 11 - 14 */
7987 "st4", "st5", "st6", "st7", /* 15 - 18 */
7988 NULL
, NULL
, /* 19 - 20 */
7989 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7990 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7991 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7992 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7993 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7994 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7995 "tr", "ldtr", /* 48 - 49 */
7996 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7997 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7998 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7999 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8000 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8001 NULL
, NULL
, NULL
, /* 90 - 92 */
8002 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
8005 static const char *const dwarf_regnames_iamcu
[] =
8007 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8008 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8009 "eip", "eflags", NULL
, /* 8 - 10 */
8010 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
8011 NULL
, NULL
, /* 19 - 20 */
8012 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
8013 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
8014 NULL
, NULL
, NULL
, /* 37 - 39 */
8015 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8016 "tr", "ldtr", /* 48 - 49 */
8017 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8018 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8019 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8020 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8021 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8022 NULL
, NULL
, NULL
, /* 90 - 92 */
8023 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
8027 init_dwarf_regnames_i386 (void)
8029 dwarf_regnames
= dwarf_regnames_i386
;
8030 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
8031 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8035 init_dwarf_regnames_iamcu (void)
8037 dwarf_regnames
= dwarf_regnames_iamcu
;
8038 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
8039 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8042 static const char *const dwarf_regnames_x86_64
[] =
8044 "rax", "rdx", "rcx", "rbx",
8045 "rsi", "rdi", "rbp", "rsp",
8046 "r8", "r9", "r10", "r11",
8047 "r12", "r13", "r14", "r15",
8049 "xmm0", "xmm1", "xmm2", "xmm3",
8050 "xmm4", "xmm5", "xmm6", "xmm7",
8051 "xmm8", "xmm9", "xmm10", "xmm11",
8052 "xmm12", "xmm13", "xmm14", "xmm15",
8053 "st0", "st1", "st2", "st3",
8054 "st4", "st5", "st6", "st7",
8055 "mm0", "mm1", "mm2", "mm3",
8056 "mm4", "mm5", "mm6", "mm7",
8058 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
8059 "fs.base", "gs.base", NULL
, NULL
,
8061 "mxcsr", "fcw", "fsw",
8062 "xmm16", "xmm17", "xmm18", "xmm19",
8063 "xmm20", "xmm21", "xmm22", "xmm23",
8064 "xmm24", "xmm25", "xmm26", "xmm27",
8065 "xmm28", "xmm29", "xmm30", "xmm31",
8066 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
8067 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
8068 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
8069 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
8070 NULL
, NULL
, NULL
, /* 115 - 117 */
8071 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
8075 init_dwarf_regnames_x86_64 (void)
8077 dwarf_regnames
= dwarf_regnames_x86_64
;
8078 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
8079 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8082 static const char *const dwarf_regnames_aarch64
[] =
8084 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
8085 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
8086 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
8087 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
8088 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8089 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
8090 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
8091 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
8092 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
8093 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
8094 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
8095 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
8096 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
8097 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
8098 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
8099 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
8103 init_dwarf_regnames_aarch64 (void)
8105 dwarf_regnames
= dwarf_regnames_aarch64
;
8106 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
8107 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8110 static const char *const dwarf_regnames_s390
[] =
8112 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
8113 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8114 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8115 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
8116 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
8117 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
8118 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
8119 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
8120 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
8123 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
8124 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
8128 init_dwarf_regnames_s390 (void)
8130 dwarf_regnames
= dwarf_regnames_s390
;
8131 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
8132 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8135 static const char *const dwarf_regnames_riscv
[] =
8137 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8138 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8139 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8140 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8141 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8142 "fs0", "fs1", /* 40 - 41 */
8143 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8144 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8145 "fs10", "fs11", /* 58 - 59 */
8146 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8149 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8150 the large number of CSRs. */
8153 regname_internal_riscv (unsigned int regno
)
8155 const char *name
= NULL
;
8157 /* Lookup in the table first, this covers GPR and FPR. */
8158 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8159 name
= dwarf_regnames_riscv
[regno
];
8160 else if (regno
>= 4096 && regno
<= 8191)
8162 /* This might be a CSR, these live in a sparse number space from 4096
8163 to 8191 These numbers are defined in the RISC-V ELF ABI
8167 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8168 case VALUE + 4096: name = #NAME; break;
8169 #include "opcode/riscv-opc.h"
8174 static char csr_name
[10];
8175 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8186 init_dwarf_regnames_riscv (void)
8188 dwarf_regnames
= NULL
;
8189 dwarf_regnames_count
= 8192;
8190 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8194 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8196 dwarf_regnames_lookup_func
= NULL
;
8201 init_dwarf_regnames_i386 ();
8205 init_dwarf_regnames_iamcu ();
8211 init_dwarf_regnames_x86_64 ();
8215 init_dwarf_regnames_aarch64 ();
8219 init_dwarf_regnames_s390 ();
8223 init_dwarf_regnames_riscv ();
8231 /* Initialize the DWARF register name lookup state based on the
8232 architecture and specific machine type of a BFD. */
8235 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8238 dwarf_regnames_lookup_func
= NULL
;
8245 case bfd_mach_x86_64
:
8246 case bfd_mach_x86_64_intel_syntax
:
8247 case bfd_mach_x64_32
:
8248 case bfd_mach_x64_32_intel_syntax
:
8249 init_dwarf_regnames_x86_64 ();
8253 init_dwarf_regnames_i386 ();
8258 case bfd_arch_iamcu
:
8259 init_dwarf_regnames_iamcu ();
8262 case bfd_arch_aarch64
:
8263 init_dwarf_regnames_aarch64();
8267 init_dwarf_regnames_s390 ();
8270 case bfd_arch_riscv
:
8271 init_dwarf_regnames_riscv ();
8280 regname_internal_by_table_only (unsigned int regno
)
8282 if (dwarf_regnames
!= NULL
8283 && regno
< dwarf_regnames_count
8284 && dwarf_regnames
[regno
] != NULL
)
8285 return dwarf_regnames
[regno
];
8291 regname (unsigned int regno
, int name_only_p
)
8293 static char reg
[64];
8295 const char *name
= NULL
;
8297 if (dwarf_regnames_lookup_func
!= NULL
)
8298 name
= dwarf_regnames_lookup_func (regno
);
8304 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8307 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8312 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8317 if (*max_regs
!= fc
->ncols
)
8318 *max_regs
= fc
->ncols
;
8320 if (*need_col_headers
)
8322 *need_col_headers
= 0;
8324 printf ("%-*s CFA ", eh_addr_size
* 2, " LOC");
8326 for (r
= 0; r
< *max_regs
; r
++)
8327 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8332 printf ("%-5s ", regname (r
, 1));
8338 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
8340 strcpy (tmp
, "exp");
8342 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8343 printf ("%-8s ", tmp
);
8345 for (r
= 0; r
< fc
->ncols
; r
++)
8347 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8349 switch (fc
->col_type
[r
])
8351 case DW_CFA_undefined
:
8354 case DW_CFA_same_value
:
8358 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8360 case DW_CFA_val_offset
:
8361 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8363 case DW_CFA_register
:
8364 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8366 case DW_CFA_expression
:
8367 strcpy (tmp
, "exp");
8369 case DW_CFA_val_expression
:
8370 strcpy (tmp
, "vexp");
8373 strcpy (tmp
, "n/a");
8376 printf ("%-5s ", tmp
);
8382 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8384 static unsigned char *
8385 read_cie (unsigned char *start
, unsigned char *end
,
8386 Frame_Chunk
**p_cie
, int *p_version
,
8387 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
8391 unsigned char *augmentation_data
= NULL
;
8392 bfd_size_type augmentation_data_len
= 0;
8395 /* PR 17512: file: 001-228113-0.004. */
8399 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8400 memset (fc
, 0, sizeof (Frame_Chunk
));
8402 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8403 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8407 fc
->augmentation
= (char *) start
;
8408 /* PR 17512: file: 001-228113-0.004.
8409 Skip past augmentation name, but avoid running off the end of the data. */
8411 if (* start
++ == '\0')
8415 warn (_("No terminator for augmentation name\n"));
8419 if (strcmp (fc
->augmentation
, "eh") == 0)
8421 if (eh_addr_size
> (size_t) (end
- start
))
8423 start
+= eh_addr_size
;
8428 if (2 > (size_t) (end
- start
))
8430 GET (fc
->ptr_size
, 1);
8431 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8433 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8437 GET (fc
->segment_size
, 1);
8438 /* PR 17512: file: e99d2804. */
8439 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8441 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8445 eh_addr_size
= fc
->ptr_size
;
8449 fc
->ptr_size
= eh_addr_size
;
8450 fc
->segment_size
= 0;
8453 READ_ULEB (fc
->code_factor
, start
, end
);
8454 READ_SLEB (fc
->data_factor
, start
, end
);
8465 READ_ULEB (fc
->ra
, start
, end
);
8468 if (fc
->augmentation
[0] == 'z')
8472 READ_ULEB (augmentation_data_len
, start
, end
);
8473 augmentation_data
= start
;
8474 /* PR 17512: file: 11042-2589-0.004. */
8475 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8477 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
8478 dwarf_vmatoa ("x", augmentation_data_len
),
8479 (unsigned long) (end
- start
));
8482 start
+= augmentation_data_len
;
8485 if (augmentation_data_len
)
8489 unsigned char *qend
;
8491 p
= (unsigned char *) fc
->augmentation
+ 1;
8492 q
= augmentation_data
;
8493 qend
= q
+ augmentation_data_len
;
8495 while (p
< end
&& q
< qend
)
8500 q
+= 1 + size_of_encoded_value (*q
);
8502 fc
->fde_encoding
= *q
++;
8511 /* Note - it is OK if this loop terminates with q < qend.
8512 Padding may have been inserted to align the end of the CIE. */
8517 *p_version
= version
;
8520 *p_aug_len
= augmentation_data_len
;
8521 *p_aug
= augmentation_data
;
8526 free (fc
->col_offset
);
8527 free (fc
->col_type
);
8532 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8533 If do_wide is not enabled, then formats the output to fit into 80 columns.
8534 PRINTED contains the number of characters already written to the current
8538 display_data (bfd_size_type printed
,
8539 const unsigned char * data
,
8540 const bfd_size_type len
)
8542 if (do_wide
|| len
< ((80 - printed
) / 3))
8543 for (printed
= 0; printed
< len
; ++printed
)
8544 printf (" %02x", data
[printed
]);
8547 for (printed
= 0; printed
< len
; ++printed
)
8549 if (printed
% (80 / 3) == 0)
8551 printf (" %02x", data
[printed
]);
8556 /* Prints out the contents on the augmentation data array.
8557 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8560 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
8564 i
= printf (_(" Augmentation data: "));
8565 display_data (i
, data
, len
);
8569 display_debug_frames (struct dwarf_section
*section
,
8570 void *file ATTRIBUTE_UNUSED
)
8572 unsigned char *start
= section
->start
;
8573 unsigned char *end
= start
+ section
->size
;
8574 unsigned char *section_start
= start
;
8575 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8576 Frame_Chunk
*remembered_state
= NULL
;
8578 bool is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8579 unsigned int max_regs
= 0;
8580 const char *bad_reg
= _("bad register: ");
8581 unsigned int saved_eh_addr_size
= eh_addr_size
;
8583 introduce (section
, false);
8587 unsigned char *saved_start
;
8588 unsigned char *block_end
;
8593 int need_col_headers
= 1;
8594 unsigned char *augmentation_data
= NULL
;
8595 bfd_size_type augmentation_data_len
= 0;
8596 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8597 unsigned int offset_size
;
8599 static Frame_Chunk fde_fc
;
8601 saved_start
= start
;
8603 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8607 printf ("\n%08lx ZERO terminator\n\n",
8608 (unsigned long)(saved_start
- section_start
));
8609 /* Skip any zero terminators that directly follow.
8610 A corrupt section size could have loaded a whole
8611 slew of zero filled memory bytes. eg
8612 PR 17512: file: 070-19381-0.004. */
8613 while (start
< end
&& * start
== 0)
8618 if (length
== 0xffffffff)
8620 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8626 if (length
> (size_t) (end
- start
))
8628 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8629 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8630 (unsigned long) (saved_start
- section_start
));
8634 block_end
= start
+ length
;
8636 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, block_end
);
8638 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8639 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8644 start
= read_cie (start
, block_end
, &cie
, &version
,
8645 &augmentation_data_len
, &augmentation_data
);
8646 /* PR 17512: file: 027-135133-0.005. */
8653 fc
->chunk_start
= saved_start
;
8654 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8657 if (frame_need_space (fc
, mreg
) < 0)
8659 if (fc
->fde_encoding
)
8660 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8662 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8663 print_dwarf_vma (length
, fc
->ptr_size
);
8664 print_dwarf_vma (cie_id
, offset_size
);
8666 if (do_debug_frames_interp
)
8668 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8669 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8674 printf (" Version: %d\n", version
);
8675 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8678 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8679 printf (" Segment Size: %u\n", fc
->segment_size
);
8681 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8682 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8683 printf (" Return address column: %d\n", fc
->ra
);
8685 if (augmentation_data_len
)
8686 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8693 unsigned char *look_for
;
8694 unsigned long segment_selector
;
8700 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8701 cie_off
= (cie_off
^ sign
) - sign
;
8702 cie_off
= start
- 4 - section_start
- cie_off
;
8705 look_for
= section_start
+ cie_off
;
8706 if (cie_off
<= (dwarf_vma
) (saved_start
- section_start
))
8708 for (cie
= chunks
; cie
; cie
= cie
->next
)
8709 if (cie
->chunk_start
== look_for
)
8712 else if (cie_off
>= section
->size
)
8716 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8717 if (cie
->chunk_start
== look_for
)
8721 unsigned int off_size
;
8722 unsigned char *cie_scan
;
8724 cie_scan
= look_for
;
8726 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8727 if (length
== 0xffffffff)
8729 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8732 if (length
!= 0 && length
<= (size_t) (end
- cie_scan
))
8735 unsigned char *cie_end
= cie_scan
+ length
;
8737 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
,
8741 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8742 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8747 read_cie (cie_scan
, cie_end
, &cie
, &version
,
8748 &augmentation_data_len
, &augmentation_data
);
8749 /* PR 17512: file: 3450-2098-0.004. */
8752 warn (_("Failed to read CIE information\n"));
8755 cie
->next
= forward_refs
;
8757 cie
->chunk_start
= look_for
;
8758 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8761 if (frame_need_space (cie
, mreg
) < 0)
8763 warn (_("Invalid max register\n"));
8766 if (cie
->fde_encoding
)
8768 = size_of_encoded_value (cie
->fde_encoding
);
8775 memset (fc
, 0, sizeof (Frame_Chunk
));
8779 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8780 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8781 (unsigned long) (saved_start
- section_start
));
8783 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8784 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8785 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8787 warn (_("Invalid max register\n"));
8791 fc
->augmentation
= "";
8792 fc
->fde_encoding
= 0;
8793 fc
->ptr_size
= eh_addr_size
;
8794 fc
->segment_size
= 0;
8798 fc
->ncols
= cie
->ncols
;
8799 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8800 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8801 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8802 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8803 fc
->augmentation
= cie
->augmentation
;
8804 fc
->ptr_size
= cie
->ptr_size
;
8805 eh_addr_size
= cie
->ptr_size
;
8806 fc
->segment_size
= cie
->segment_size
;
8807 fc
->code_factor
= cie
->code_factor
;
8808 fc
->data_factor
= cie
->data_factor
;
8809 fc
->cfa_reg
= cie
->cfa_reg
;
8810 fc
->cfa_offset
= cie
->cfa_offset
;
8812 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8814 warn (_("Invalid max register\n"));
8817 fc
->fde_encoding
= cie
->fde_encoding
;
8820 if (fc
->fde_encoding
)
8821 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8823 segment_selector
= 0;
8824 if (fc
->segment_size
)
8826 if (fc
->segment_size
> sizeof (segment_selector
))
8828 /* PR 17512: file: 9e196b3e. */
8829 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8830 fc
->segment_size
= 4;
8832 SAFE_BYTE_GET_AND_INC (segment_selector
, start
,
8833 fc
->segment_size
, block_end
);
8836 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
8839 /* FIXME: It appears that sometimes the final pc_range value is
8840 encoded in less than encoded_ptr_size bytes. See the x86_64
8841 run of the "objcopy on compressed debug sections" test for an
8843 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
,
8846 if (cie
->augmentation
[0] == 'z')
8848 READ_ULEB (augmentation_data_len
, start
, block_end
);
8849 augmentation_data
= start
;
8850 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8851 if (augmentation_data_len
> (bfd_size_type
) (block_end
- start
))
8853 warn (_("Augmentation data too long: 0x%s, "
8854 "expected at most %#lx\n"),
8855 dwarf_vmatoa ("x", augmentation_data_len
),
8856 (unsigned long) (block_end
- start
));
8858 augmentation_data
= NULL
;
8859 augmentation_data_len
= 0;
8861 start
+= augmentation_data_len
;
8864 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8865 (unsigned long)(saved_start
- section_start
),
8866 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8867 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8868 (unsigned long)(cie
->chunk_start
- section_start
));
8870 if (fc
->segment_size
)
8871 printf ("%04lx:", segment_selector
);
8874 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8875 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8877 if (! do_debug_frames_interp
&& augmentation_data_len
)
8879 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8884 /* At this point, fc is the current chunk, cie (if any) is set, and
8885 we're about to interpret instructions for the chunk. */
8886 /* ??? At present we need to do this always, since this sizes the
8887 fc->col_type and fc->col_offset arrays, which we write into always.
8888 We should probably split the interpreted and non-interpreted bits
8889 into two different routines, since there's so much that doesn't
8890 really overlap between them. */
8891 if (1 || do_debug_frames_interp
)
8893 /* Start by making a pass over the chunk, allocating storage
8894 and taking note of what registers are used. */
8895 unsigned char *tmp
= start
;
8897 while (start
< block_end
)
8899 unsigned int reg
, op
, opa
;
8907 /* Warning: if you add any more cases to this switch, be
8908 sure to add them to the corresponding switch below. */
8911 case DW_CFA_advance_loc
:
8914 SKIP_ULEB (start
, block_end
);
8915 if (frame_need_space (fc
, opa
) >= 0)
8916 fc
->col_type
[opa
] = DW_CFA_undefined
;
8918 case DW_CFA_restore
:
8919 if (frame_need_space (fc
, opa
) >= 0)
8920 fc
->col_type
[opa
] = DW_CFA_undefined
;
8922 case DW_CFA_set_loc
:
8923 if ((size_t) (block_end
- start
) < encoded_ptr_size
)
8926 start
+= encoded_ptr_size
;
8928 case DW_CFA_advance_loc1
:
8929 if ((size_t) (block_end
- start
) < 1)
8934 case DW_CFA_advance_loc2
:
8935 if ((size_t) (block_end
- start
) < 2)
8940 case DW_CFA_advance_loc4
:
8941 if ((size_t) (block_end
- start
) < 4)
8946 case DW_CFA_offset_extended
:
8947 case DW_CFA_val_offset
:
8948 READ_ULEB (reg
, start
, block_end
);
8949 SKIP_ULEB (start
, block_end
);
8950 if (frame_need_space (fc
, reg
) >= 0)
8951 fc
->col_type
[reg
] = DW_CFA_undefined
;
8953 case DW_CFA_restore_extended
:
8954 READ_ULEB (reg
, start
, block_end
);
8955 if (frame_need_space (fc
, reg
) >= 0)
8956 fc
->col_type
[reg
] = DW_CFA_undefined
;
8958 case DW_CFA_undefined
:
8959 READ_ULEB (reg
, start
, block_end
);
8960 if (frame_need_space (fc
, reg
) >= 0)
8961 fc
->col_type
[reg
] = DW_CFA_undefined
;
8963 case DW_CFA_same_value
:
8964 READ_ULEB (reg
, start
, block_end
);
8965 if (frame_need_space (fc
, reg
) >= 0)
8966 fc
->col_type
[reg
] = DW_CFA_undefined
;
8968 case DW_CFA_register
:
8969 READ_ULEB (reg
, start
, block_end
);
8970 SKIP_ULEB (start
, block_end
);
8971 if (frame_need_space (fc
, reg
) >= 0)
8972 fc
->col_type
[reg
] = DW_CFA_undefined
;
8974 case DW_CFA_def_cfa
:
8975 SKIP_ULEB (start
, block_end
);
8976 SKIP_ULEB (start
, block_end
);
8978 case DW_CFA_def_cfa_register
:
8979 SKIP_ULEB (start
, block_end
);
8981 case DW_CFA_def_cfa_offset
:
8982 SKIP_ULEB (start
, block_end
);
8984 case DW_CFA_def_cfa_expression
:
8985 READ_ULEB (temp
, start
, block_end
);
8986 if ((size_t) (block_end
- start
) < temp
)
8991 case DW_CFA_expression
:
8992 case DW_CFA_val_expression
:
8993 READ_ULEB (reg
, start
, block_end
);
8994 READ_ULEB (temp
, start
, block_end
);
8995 if ((size_t) (block_end
- start
) < temp
)
8999 if (frame_need_space (fc
, reg
) >= 0)
9000 fc
->col_type
[reg
] = DW_CFA_undefined
;
9002 case DW_CFA_offset_extended_sf
:
9003 case DW_CFA_val_offset_sf
:
9004 READ_ULEB (reg
, start
, block_end
);
9005 SKIP_SLEB (start
, block_end
);
9006 if (frame_need_space (fc
, reg
) >= 0)
9007 fc
->col_type
[reg
] = DW_CFA_undefined
;
9009 case DW_CFA_def_cfa_sf
:
9010 SKIP_ULEB (start
, block_end
);
9011 SKIP_SLEB (start
, block_end
);
9013 case DW_CFA_def_cfa_offset_sf
:
9014 SKIP_SLEB (start
, block_end
);
9016 case DW_CFA_MIPS_advance_loc8
:
9017 if ((size_t) (block_end
- start
) < 8)
9022 case DW_CFA_GNU_args_size
:
9023 SKIP_ULEB (start
, block_end
);
9025 case DW_CFA_GNU_negative_offset_extended
:
9026 READ_ULEB (reg
, start
, block_end
);
9027 SKIP_ULEB (start
, block_end
);
9028 if (frame_need_space (fc
, reg
) >= 0)
9029 fc
->col_type
[reg
] = DW_CFA_undefined
;
9040 /* Now we know what registers are used, make a second pass over
9041 the chunk, this time actually printing out the info. */
9043 while (start
< block_end
)
9046 unsigned long ul
, roffs
;
9047 /* Note: It is tempting to use an unsigned long for 'reg' but there
9048 are various functions, notably frame_space_needed() that assume that
9049 reg is an unsigned int. */
9054 const char *reg_prefix
= "";
9061 /* Make a note if something other than DW_CFA_nop happens. */
9062 if (op
!= DW_CFA_nop
)
9065 /* Warning: if you add any more cases to this switch, be
9066 sure to add them to the corresponding switch above. */
9069 case DW_CFA_advance_loc
:
9070 if (do_debug_frames_interp
)
9071 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9073 printf (" DW_CFA_advance_loc: %d to %s\n",
9074 opa
* fc
->code_factor
,
9075 dwarf_vmatoa_1 (NULL
,
9076 fc
->pc_begin
+ opa
* fc
->code_factor
,
9078 fc
->pc_begin
+= opa
* fc
->code_factor
;
9082 READ_ULEB (roffs
, start
, block_end
);
9083 if (opa
>= (unsigned int) fc
->ncols
)
9084 reg_prefix
= bad_reg
;
9085 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9086 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
9087 reg_prefix
, regname (opa
, 0),
9088 roffs
* fc
->data_factor
);
9089 if (*reg_prefix
== '\0')
9091 fc
->col_type
[opa
] = DW_CFA_offset
;
9092 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9096 case DW_CFA_restore
:
9097 if (opa
>= (unsigned int) fc
->ncols
)
9098 reg_prefix
= bad_reg
;
9099 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9100 printf (" DW_CFA_restore: %s%s\n",
9101 reg_prefix
, regname (opa
, 0));
9102 if (*reg_prefix
!= '\0')
9105 if (opa
>= (unsigned int) cie
->ncols
9106 || (do_debug_frames_interp
9107 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
9109 fc
->col_type
[opa
] = DW_CFA_undefined
;
9110 fc
->col_offset
[opa
] = 0;
9114 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9115 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9119 case DW_CFA_set_loc
:
9120 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9122 if (do_debug_frames_interp
)
9123 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9125 printf (" DW_CFA_set_loc: %s\n",
9126 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
9130 case DW_CFA_advance_loc1
:
9131 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, block_end
);
9132 if (do_debug_frames_interp
)
9133 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9135 printf (" DW_CFA_advance_loc1: %ld to %s\n",
9136 (unsigned long) (ofs
* fc
->code_factor
),
9137 dwarf_vmatoa_1 (NULL
,
9138 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9140 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9143 case DW_CFA_advance_loc2
:
9144 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
9145 if (do_debug_frames_interp
)
9146 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9148 printf (" DW_CFA_advance_loc2: %ld to %s\n",
9149 (unsigned long) (ofs
* fc
->code_factor
),
9150 dwarf_vmatoa_1 (NULL
,
9151 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9153 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9156 case DW_CFA_advance_loc4
:
9157 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9158 if (do_debug_frames_interp
)
9159 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9161 printf (" DW_CFA_advance_loc4: %ld to %s\n",
9162 (unsigned long) (ofs
* fc
->code_factor
),
9163 dwarf_vmatoa_1 (NULL
,
9164 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9166 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9169 case DW_CFA_offset_extended
:
9170 READ_ULEB (reg
, start
, block_end
);
9171 READ_ULEB (roffs
, start
, block_end
);
9172 if (reg
>= (unsigned int) fc
->ncols
)
9173 reg_prefix
= bad_reg
;
9174 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9175 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9176 reg_prefix
, regname (reg
, 0),
9177 roffs
* fc
->data_factor
);
9178 if (*reg_prefix
== '\0')
9180 fc
->col_type
[reg
] = DW_CFA_offset
;
9181 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9185 case DW_CFA_val_offset
:
9186 READ_ULEB (reg
, start
, block_end
);
9187 READ_ULEB (roffs
, start
, block_end
);
9188 if (reg
>= (unsigned int) fc
->ncols
)
9189 reg_prefix
= bad_reg
;
9190 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9191 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9192 reg_prefix
, regname (reg
, 0),
9193 roffs
* fc
->data_factor
);
9194 if (*reg_prefix
== '\0')
9196 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9197 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9201 case DW_CFA_restore_extended
:
9202 READ_ULEB (reg
, start
, block_end
);
9203 if (reg
>= (unsigned int) fc
->ncols
)
9204 reg_prefix
= bad_reg
;
9205 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9206 printf (" DW_CFA_restore_extended: %s%s\n",
9207 reg_prefix
, regname (reg
, 0));
9208 if (*reg_prefix
!= '\0')
9211 if (reg
>= (unsigned int) cie
->ncols
)
9213 fc
->col_type
[reg
] = DW_CFA_undefined
;
9214 fc
->col_offset
[reg
] = 0;
9218 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9219 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9223 case DW_CFA_undefined
:
9224 READ_ULEB (reg
, start
, block_end
);
9225 if (reg
>= (unsigned int) fc
->ncols
)
9226 reg_prefix
= bad_reg
;
9227 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9228 printf (" DW_CFA_undefined: %s%s\n",
9229 reg_prefix
, regname (reg
, 0));
9230 if (*reg_prefix
== '\0')
9232 fc
->col_type
[reg
] = DW_CFA_undefined
;
9233 fc
->col_offset
[reg
] = 0;
9237 case DW_CFA_same_value
:
9238 READ_ULEB (reg
, start
, block_end
);
9239 if (reg
>= (unsigned int) fc
->ncols
)
9240 reg_prefix
= bad_reg
;
9241 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9242 printf (" DW_CFA_same_value: %s%s\n",
9243 reg_prefix
, regname (reg
, 0));
9244 if (*reg_prefix
== '\0')
9246 fc
->col_type
[reg
] = DW_CFA_same_value
;
9247 fc
->col_offset
[reg
] = 0;
9251 case DW_CFA_register
:
9252 READ_ULEB (reg
, start
, block_end
);
9253 READ_ULEB (roffs
, start
, block_end
);
9254 if (reg
>= (unsigned int) fc
->ncols
)
9255 reg_prefix
= bad_reg
;
9256 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9258 printf (" DW_CFA_register: %s%s in ",
9259 reg_prefix
, regname (reg
, 0));
9260 puts (regname (roffs
, 0));
9262 if (*reg_prefix
== '\0')
9264 fc
->col_type
[reg
] = DW_CFA_register
;
9265 fc
->col_offset
[reg
] = roffs
;
9269 case DW_CFA_remember_state
:
9270 if (! do_debug_frames_interp
)
9271 printf (" DW_CFA_remember_state\n");
9272 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9273 rs
->cfa_offset
= fc
->cfa_offset
;
9274 rs
->cfa_reg
= fc
->cfa_reg
;
9276 rs
->cfa_exp
= fc
->cfa_exp
;
9277 rs
->ncols
= fc
->ncols
;
9278 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9279 sizeof (* rs
->col_type
));
9280 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9281 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9282 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9283 rs
->next
= remembered_state
;
9284 remembered_state
= rs
;
9287 case DW_CFA_restore_state
:
9288 if (! do_debug_frames_interp
)
9289 printf (" DW_CFA_restore_state\n");
9290 rs
= remembered_state
;
9293 remembered_state
= rs
->next
;
9294 fc
->cfa_offset
= rs
->cfa_offset
;
9295 fc
->cfa_reg
= rs
->cfa_reg
;
9297 fc
->cfa_exp
= rs
->cfa_exp
;
9298 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9300 warn (_("Invalid column number in saved frame state\n"));
9304 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9305 memcpy (fc
->col_offset
, rs
->col_offset
,
9306 rs
->ncols
* sizeof (* rs
->col_offset
));
9307 free (rs
->col_type
);
9308 free (rs
->col_offset
);
9311 else if (do_debug_frames_interp
)
9312 printf ("Mismatched DW_CFA_restore_state\n");
9315 case DW_CFA_def_cfa
:
9316 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9317 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9319 if (! do_debug_frames_interp
)
9320 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9321 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9324 case DW_CFA_def_cfa_register
:
9325 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9327 if (! do_debug_frames_interp
)
9328 printf (" DW_CFA_def_cfa_register: %s\n",
9329 regname (fc
->cfa_reg
, 0));
9332 case DW_CFA_def_cfa_offset
:
9333 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9334 if (! do_debug_frames_interp
)
9335 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9339 if (! do_debug_frames_interp
)
9340 printf (" DW_CFA_nop\n");
9343 case DW_CFA_def_cfa_expression
:
9344 READ_ULEB (ul
, start
, block_end
);
9345 if (ul
> (size_t) (block_end
- start
))
9347 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9350 if (! do_debug_frames_interp
)
9352 printf (" DW_CFA_def_cfa_expression (");
9353 decode_location_expression (start
, eh_addr_size
, 0, -1,
9361 case DW_CFA_expression
:
9362 READ_ULEB (reg
, start
, block_end
);
9363 READ_ULEB (ul
, start
, block_end
);
9364 if (reg
>= (unsigned int) fc
->ncols
)
9365 reg_prefix
= bad_reg
;
9366 /* PR 17512: file: 069-133014-0.006. */
9367 /* PR 17512: file: 98c02eb4. */
9368 if (ul
> (size_t) (block_end
- start
))
9370 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9373 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9375 printf (" DW_CFA_expression: %s%s (",
9376 reg_prefix
, regname (reg
, 0));
9377 decode_location_expression (start
, eh_addr_size
, 0, -1,
9381 if (*reg_prefix
== '\0')
9382 fc
->col_type
[reg
] = DW_CFA_expression
;
9386 case DW_CFA_val_expression
:
9387 READ_ULEB (reg
, start
, block_end
);
9388 READ_ULEB (ul
, start
, block_end
);
9389 if (reg
>= (unsigned int) fc
->ncols
)
9390 reg_prefix
= bad_reg
;
9391 if (ul
> (size_t) (block_end
- start
))
9393 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9396 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9398 printf (" DW_CFA_val_expression: %s%s (",
9399 reg_prefix
, regname (reg
, 0));
9400 decode_location_expression (start
, eh_addr_size
, 0, -1,
9404 if (*reg_prefix
== '\0')
9405 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9409 case DW_CFA_offset_extended_sf
:
9410 READ_ULEB (reg
, start
, block_end
);
9411 READ_SLEB (l
, start
, block_end
);
9412 if (frame_need_space (fc
, reg
) < 0)
9413 reg_prefix
= bad_reg
;
9414 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9415 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
9416 reg_prefix
, regname (reg
, 0),
9417 (long)(l
* fc
->data_factor
));
9418 if (*reg_prefix
== '\0')
9420 fc
->col_type
[reg
] = DW_CFA_offset
;
9421 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9425 case DW_CFA_val_offset_sf
:
9426 READ_ULEB (reg
, start
, block_end
);
9427 READ_SLEB (l
, start
, block_end
);
9428 if (frame_need_space (fc
, reg
) < 0)
9429 reg_prefix
= bad_reg
;
9430 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9431 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
9432 reg_prefix
, regname (reg
, 0),
9433 (long)(l
* fc
->data_factor
));
9434 if (*reg_prefix
== '\0')
9436 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9437 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9441 case DW_CFA_def_cfa_sf
:
9442 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9443 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9444 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
9446 if (! do_debug_frames_interp
)
9447 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
9448 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9451 case DW_CFA_def_cfa_offset_sf
:
9452 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9453 fc
->cfa_offset
*= fc
->data_factor
;
9454 if (! do_debug_frames_interp
)
9455 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
9458 case DW_CFA_MIPS_advance_loc8
:
9459 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9460 if (do_debug_frames_interp
)
9461 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9463 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
9464 (unsigned long) (ofs
* fc
->code_factor
),
9465 dwarf_vmatoa_1 (NULL
,
9466 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9468 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9471 case DW_CFA_GNU_window_save
:
9472 if (! do_debug_frames_interp
)
9473 printf (" DW_CFA_GNU_window_save\n");
9476 case DW_CFA_GNU_args_size
:
9477 READ_ULEB (ul
, start
, block_end
);
9478 if (! do_debug_frames_interp
)
9479 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9482 case DW_CFA_GNU_negative_offset_extended
:
9483 READ_ULEB (reg
, start
, block_end
);
9484 READ_SLEB (l
, start
, block_end
);
9486 if (frame_need_space (fc
, reg
) < 0)
9487 reg_prefix
= bad_reg
;
9488 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9489 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
9490 reg_prefix
, regname (reg
, 0),
9491 (long)(l
* fc
->data_factor
));
9492 if (*reg_prefix
== '\0')
9494 fc
->col_type
[reg
] = DW_CFA_offset
;
9495 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9500 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9501 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9503 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9508 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9509 if (do_debug_frames_interp
&& ! all_nops
)
9510 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9512 if (fde_fc
.col_type
!= NULL
)
9514 free (fde_fc
.col_type
);
9515 fde_fc
.col_type
= NULL
;
9517 if (fde_fc
.col_offset
!= NULL
)
9519 free (fde_fc
.col_offset
);
9520 fde_fc
.col_offset
= NULL
;
9524 eh_addr_size
= saved_eh_addr_size
;
9529 while (remembered_state
!= NULL
)
9531 rs
= remembered_state
;
9532 remembered_state
= rs
->next
;
9533 free (rs
->col_type
);
9534 free (rs
->col_offset
);
9535 rs
->next
= NULL
; /* Paranoia. */
9539 while (chunks
!= NULL
)
9543 free (rs
->col_type
);
9544 free (rs
->col_offset
);
9545 rs
->next
= NULL
; /* Paranoia. */
9549 while (forward_refs
!= NULL
)
9552 forward_refs
= rs
->next
;
9553 free (rs
->col_type
);
9554 free (rs
->col_offset
);
9555 rs
->next
= NULL
; /* Paranoia. */
9565 display_debug_names (struct dwarf_section
*section
, void *file
)
9567 unsigned char *hdrptr
= section
->start
;
9568 dwarf_vma unit_length
;
9569 unsigned char *unit_start
;
9570 const unsigned char *const section_end
= section
->start
+ section
->size
;
9571 unsigned char *unit_end
;
9573 introduce (section
, false);
9575 load_debug_section_with_follow (str
, file
);
9577 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9579 unsigned int offset_size
;
9580 uint16_t dwarf_version
, padding
;
9581 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9582 uint64_t bucket_count
, name_count
, abbrev_table_size
;
9583 uint32_t augmentation_string_size
;
9585 bool augmentation_printable
;
9586 const char *augmentation_string
;
9589 unit_start
= hdrptr
;
9591 /* Get and check the length of the block. */
9592 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9594 if (unit_length
== 0xffffffff)
9596 /* This section is 64-bit DWARF. */
9597 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9603 if (unit_length
> (size_t) (section_end
- hdrptr
)
9604 || unit_length
< 2 + 2 + 4 * 7)
9607 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9609 (unsigned long) (unit_start
- section
->start
),
9610 dwarf_vmatoa ("x", unit_length
));
9613 unit_end
= hdrptr
+ unit_length
;
9615 /* Get and check the version number. */
9616 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9617 printf (_("Version %ld\n"), (long) dwarf_version
);
9619 /* Prior versions did not exist, and future versions may not be
9620 backwards compatible. */
9621 if (dwarf_version
!= 5)
9623 warn (_("Only DWARF version 5 .debug_names "
9624 "is currently supported.\n"));
9628 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9630 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9633 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9634 if (comp_unit_count
== 0)
9635 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9637 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9638 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9639 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9640 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9641 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9643 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9644 if (augmentation_string_size
% 4 != 0)
9646 warn (_("Augmentation string length %u must be rounded up "
9647 "to a multiple of 4 in .debug_names.\n"),
9648 augmentation_string_size
);
9649 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9651 if (augmentation_string_size
> (size_t) (unit_end
- hdrptr
))
9654 printf (_("Augmentation string:"));
9656 augmentation_printable
= true;
9657 augmentation_string
= (const char *) hdrptr
;
9659 for (i
= 0; i
< augmentation_string_size
; i
++)
9663 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9664 printf (" %02x", uc
);
9666 if (uc
!= 0 && !ISPRINT (uc
))
9667 augmentation_printable
= false;
9670 if (augmentation_printable
)
9674 i
< augmentation_string_size
&& augmentation_string
[i
];
9676 putchar (augmentation_string
[i
]);
9681 printf (_("CU table:\n"));
9682 if (_mul_overflow (comp_unit_count
, offset_size
, &total
)
9683 || total
> (size_t) (unit_end
- hdrptr
))
9685 for (i
= 0; i
< comp_unit_count
; i
++)
9689 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9690 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9694 printf (_("TU table:\n"));
9695 if (_mul_overflow (local_type_unit_count
, offset_size
, &total
)
9696 || total
> (size_t) (unit_end
- hdrptr
))
9698 for (i
= 0; i
< local_type_unit_count
; i
++)
9702 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9703 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9707 printf (_("Foreign TU table:\n"));
9708 if (_mul_overflow (foreign_type_unit_count
, 8, &total
)
9709 || total
> (size_t) (unit_end
- hdrptr
))
9711 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9715 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9716 printf (_("[%3u] "), i
);
9717 print_dwarf_vma (signature
, 8);
9722 uint64_t xtra
= (bucket_count
* sizeof (uint32_t)
9723 + name_count
* (sizeof (uint32_t) + 2 * offset_size
)
9724 + abbrev_table_size
);
9725 if (xtra
> (size_t) (unit_end
- hdrptr
))
9727 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9728 "for unit 0x%lx in the debug_names\n"),
9730 (long) (unit_end
- unit_start
),
9731 (long) (unit_start
- section
->start
));
9734 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9735 hdrptr
+= bucket_count
* sizeof (uint32_t);
9736 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9737 hdrptr
+= name_count
* sizeof (uint32_t);
9738 unsigned char *const name_table_string_offsets
= hdrptr
;
9739 hdrptr
+= name_count
* offset_size
;
9740 unsigned char *const name_table_entry_offsets
= hdrptr
;
9741 hdrptr
+= name_count
* offset_size
;
9742 unsigned char *const abbrev_table
= hdrptr
;
9743 hdrptr
+= abbrev_table_size
;
9744 const unsigned char *const abbrev_table_end
= hdrptr
;
9745 unsigned char *const entry_pool
= hdrptr
;
9747 size_t buckets_filled
= 0;
9749 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9751 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9756 printf (ngettext ("Used %zu of %lu bucket.\n",
9757 "Used %zu of %lu buckets.\n",
9759 buckets_filled
, (unsigned long) bucket_count
);
9761 uint32_t hash_prev
= 0;
9762 size_t hash_clash_count
= 0;
9763 size_t longest_clash
= 0;
9764 size_t this_length
= 0;
9766 for (hashi
= 0; hashi
< name_count
; hashi
++)
9768 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9772 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9776 longest_clash
= MAX (longest_clash
, this_length
);
9781 hash_prev
= hash_this
;
9783 printf (_("Out of %lu items there are %zu bucket clashes"
9784 " (longest of %zu entries).\n"),
9785 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9786 assert (name_count
== buckets_filled
+ hash_clash_count
);
9788 struct abbrev_lookup_entry
9790 dwarf_vma abbrev_tag
;
9791 unsigned char *abbrev_lookup_ptr
;
9793 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9794 size_t abbrev_lookup_used
= 0;
9795 size_t abbrev_lookup_allocated
= 0;
9797 unsigned char *abbrevptr
= abbrev_table
;
9800 dwarf_vma abbrev_tag
;
9802 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9803 if (abbrev_tag
== 0)
9805 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9807 abbrev_lookup_allocated
= MAX (0x100,
9808 abbrev_lookup_allocated
* 2);
9809 abbrev_lookup
= xrealloc (abbrev_lookup
,
9810 (abbrev_lookup_allocated
9811 * sizeof (*abbrev_lookup
)));
9813 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9814 struct abbrev_lookup_entry
*entry
;
9815 for (entry
= abbrev_lookup
;
9816 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9818 if (entry
->abbrev_tag
== abbrev_tag
)
9820 warn (_("Duplicate abbreviation tag %lu "
9821 "in unit 0x%lx in the debug_names\n"),
9822 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9825 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9826 entry
->abbrev_tag
= abbrev_tag
;
9827 entry
->abbrev_lookup_ptr
= abbrevptr
;
9829 /* Skip DWARF tag. */
9830 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9833 dwarf_vma xindex
, form
;
9835 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9836 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9837 if (xindex
== 0 && form
== 0)
9842 printf (_("\nSymbol table:\n"));
9844 for (namei
= 0; namei
< name_count
; ++namei
)
9846 uint64_t string_offset
, entry_offset
;
9849 p
= name_table_string_offsets
+ namei
* offset_size
;
9850 SAFE_BYTE_GET (string_offset
, p
, offset_size
, unit_end
);
9851 p
= name_table_entry_offsets
+ namei
* offset_size
;
9852 SAFE_BYTE_GET (entry_offset
, p
, offset_size
, unit_end
);
9854 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9855 fetch_indirect_string (string_offset
));
9857 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9859 /* We need to scan first whether there is a single or multiple
9860 entries. TAGNO is -2 for the first entry, it is -1 for the
9861 initial tag read of the second entry, then it becomes 0 for the
9862 first entry for real printing etc. */
9864 /* Initialize it due to a false compiler warning. */
9865 dwarf_vma second_abbrev_tag
= -1;
9868 dwarf_vma abbrev_tag
;
9869 dwarf_vma dwarf_tag
;
9870 const struct abbrev_lookup_entry
*entry
;
9872 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9875 second_abbrev_tag
= abbrev_tag
;
9877 entryptr
= entry_pool
+ entry_offset
;
9880 if (abbrev_tag
== 0)
9884 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9885 (unsigned long) abbrev_tag
);
9887 for (entry
= abbrev_lookup
;
9888 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9890 if (entry
->abbrev_tag
== abbrev_tag
)
9892 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9894 warn (_("Undefined abbreviation tag %lu "
9895 "in unit 0x%lx in the debug_names\n"),
9897 (long) (unit_start
- section
->start
));
9900 abbrevptr
= entry
->abbrev_lookup_ptr
;
9901 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9903 printf (" %s", get_TAG_name (dwarf_tag
));
9906 dwarf_vma xindex
, form
;
9908 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9909 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9910 if (xindex
== 0 && form
== 0)
9914 printf (" %s", get_IDX_name (xindex
));
9915 entryptr
= read_and_display_attr_value (0, form
, 0,
9916 unit_start
, entryptr
, unit_end
,
9918 dwarf_version
, NULL
,
9925 printf (_(" <no entries>"));
9929 free (abbrev_lookup
);
9936 display_debug_links (struct dwarf_section
* section
,
9937 void * file ATTRIBUTE_UNUSED
)
9939 const unsigned char * filename
;
9940 unsigned int filelen
;
9942 introduce (section
, false);
9944 /* The .gnu_debuglink section is formatted as:
9945 (c-string) Filename.
9946 (padding) If needed to reach a 4 byte boundary.
9947 (uint32_t) CRC32 value.
9949 The .gun_debugaltlink section is formatted as:
9950 (c-string) Filename.
9951 (binary) Build-ID. */
9953 filename
= section
->start
;
9954 filelen
= strnlen ((const char *) filename
, section
->size
);
9955 if (filelen
== section
->size
)
9957 warn (_("The debuglink filename is corrupt/missing\n"));
9961 printf (_(" Separate debug info file: %s\n"), filename
);
9963 if (startswith (section
->name
, ".gnu_debuglink"))
9966 unsigned int crc_offset
;
9968 crc_offset
= filelen
+ 1;
9969 crc_offset
= (crc_offset
+ 3) & ~3;
9970 if (crc_offset
+ 4 > section
->size
)
9972 warn (_("CRC offset missing/truncated\n"));
9976 crc32
= byte_get (filename
+ crc_offset
, 4);
9978 printf (_(" CRC value: %#x\n"), crc32
);
9980 if (crc_offset
+ 4 < section
->size
)
9982 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9983 (long)(section
->size
- (crc_offset
+ 4)));
9987 else /* startswith (section->name, ".gnu_debugaltlink") */
9989 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9990 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9991 bfd_size_type printed
;
9993 /* FIXME: Should we support smaller build-id notes ? */
9994 if (build_id_len
< 0x14)
9996 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
10000 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
10001 display_data (printed
, build_id
, build_id_len
);
10010 display_gdb_index (struct dwarf_section
*section
,
10011 void *file ATTRIBUTE_UNUSED
)
10013 unsigned char *start
= section
->start
;
10015 uint32_t cu_list_offset
, tu_list_offset
;
10016 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
10017 unsigned int cu_list_elements
, tu_list_elements
;
10018 unsigned int address_table_size
, symbol_table_slots
;
10019 unsigned char *cu_list
, *tu_list
;
10020 unsigned char *address_table
, *symbol_table
, *constant_pool
;
10023 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
10025 introduce (section
, false);
10027 if (section
->size
< 6 * sizeof (uint32_t))
10029 warn (_("Truncated header in the %s section.\n"), section
->name
);
10033 version
= byte_get_little_endian (start
, 4);
10034 printf (_("Version %ld\n"), (long) version
);
10036 /* Prior versions are obsolete, and future versions may not be
10037 backwards compatible. */
10038 if (version
< 3 || version
> 8)
10040 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
10044 warn (_("The address table data in version 3 may be wrong.\n"));
10046 warn (_("Version 4 does not support case insensitive lookups.\n"));
10048 warn (_("Version 5 does not include inlined functions.\n"));
10050 warn (_("Version 6 does not include symbol attributes.\n"));
10051 /* Version 7 indices generated by Gold have bad type unit references,
10052 PR binutils/15021. But we don't know if the index was generated by
10053 Gold or not, so to avoid worrying users with gdb-generated indices
10054 we say nothing for version 7 here. */
10056 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
10057 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
10058 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
10059 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
10060 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
10062 if (cu_list_offset
> section
->size
10063 || tu_list_offset
> section
->size
10064 || address_table_offset
> section
->size
10065 || symbol_table_offset
> section
->size
10066 || constant_pool_offset
> section
->size
)
10068 warn (_("Corrupt header in the %s section.\n"), section
->name
);
10072 /* PR 17531: file: 418d0a8a. */
10073 if (tu_list_offset
< cu_list_offset
)
10075 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
10076 tu_list_offset
, cu_list_offset
);
10080 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
10082 if (address_table_offset
< tu_list_offset
)
10084 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
10085 address_table_offset
, tu_list_offset
);
10089 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
10091 /* PR 17531: file: 18a47d3d. */
10092 if (symbol_table_offset
< address_table_offset
)
10094 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
10095 symbol_table_offset
, address_table_offset
);
10099 address_table_size
= symbol_table_offset
- address_table_offset
;
10101 if (constant_pool_offset
< symbol_table_offset
)
10103 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
10104 constant_pool_offset
, symbol_table_offset
);
10108 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
10110 cu_list
= start
+ cu_list_offset
;
10111 tu_list
= start
+ tu_list_offset
;
10112 address_table
= start
+ address_table_offset
;
10113 symbol_table
= start
+ symbol_table_offset
;
10114 constant_pool
= start
+ constant_pool_offset
;
10116 if (address_table_offset
+ address_table_size
> section
->size
)
10118 warn (_("Address table extends beyond end of section.\n"));
10122 printf (_("\nCU table:\n"));
10123 for (i
= 0; i
< cu_list_elements
; i
+= 2)
10125 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
10126 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
10128 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
10129 (unsigned long) cu_offset
,
10130 (unsigned long) (cu_offset
+ cu_length
- 1));
10133 printf (_("\nTU table:\n"));
10134 for (i
= 0; i
< tu_list_elements
; i
+= 3)
10136 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
10137 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
10138 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
10140 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
10141 (unsigned long) tu_offset
,
10142 (unsigned long) type_offset
);
10143 print_dwarf_vma (signature
, 8);
10147 printf (_("\nAddress table:\n"));
10148 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
10151 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
10152 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
10153 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
10155 print_dwarf_vma (low
, 8);
10156 print_dwarf_vma (high
, 8);
10157 printf (_("%lu\n"), (unsigned long) cu_index
);
10160 printf (_("\nSymbol table:\n"));
10161 for (i
= 0; i
< symbol_table_slots
; ++i
)
10163 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10164 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10165 uint32_t num_cus
, cu
;
10167 if (name_offset
!= 0
10168 || cu_vector_offset
!= 0)
10172 /* PR 17531: file: 5b7b07ad. */
10173 if (name_offset
>= section
->size
- constant_pool_offset
)
10175 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10176 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10180 printf ("[%3u] %.*s:", i
,
10181 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10182 constant_pool
+ name_offset
);
10184 if (section
->size
- constant_pool_offset
< 4
10185 || cu_vector_offset
> section
->size
- constant_pool_offset
- 4)
10187 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10188 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10189 cu_vector_offset
, i
);
10193 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
10195 if ((uint64_t) num_cus
* 4 > section
->size
- (constant_pool_offset
10196 + cu_vector_offset
+ 4))
10198 printf ("<invalid number of CUs: %d>\n", num_cus
);
10199 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10207 for (j
= 0; j
< num_cus
; ++j
)
10210 gdb_index_symbol_kind kind
;
10212 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10213 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10214 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10215 cu
= GDB_INDEX_CU_VALUE (cu
);
10216 /* Convert to TU number if it's for a type unit. */
10217 if (cu
>= cu_list_elements
/ 2)
10218 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10219 (unsigned long) (cu
- cu_list_elements
/ 2));
10221 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10223 printf (" [%s, %s]",
10224 is_static
? _("static") : _("global"),
10225 get_gdb_index_symbol_kind_name (kind
));
10237 /* Pre-allocate enough space for the CU/TU sets needed. */
10240 prealloc_cu_tu_list (unsigned int nshndx
)
10242 if (shndx_pool
== NULL
)
10244 shndx_pool_size
= nshndx
;
10245 shndx_pool_used
= 0;
10246 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10247 sizeof (unsigned int));
10251 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10252 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10253 sizeof (unsigned int));
10258 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10260 if (shndx_pool_used
>= shndx_pool_size
)
10262 error (_("Internal error: out of space in the shndx pool.\n"));
10265 shndx_pool
[shndx_pool_used
++] = shndx
;
10269 end_cu_tu_entry (void)
10271 if (shndx_pool_used
>= shndx_pool_size
)
10273 error (_("Internal error: out of space in the shndx pool.\n"));
10276 shndx_pool
[shndx_pool_used
++] = 0;
10279 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10281 static const char *
10282 get_DW_SECT_short_name (unsigned int dw_sect
)
10284 static char buf
[16];
10290 case DW_SECT_TYPES
:
10292 case DW_SECT_ABBREV
:
10298 case DW_SECT_STR_OFFSETS
:
10300 case DW_SECT_MACINFO
:
10302 case DW_SECT_MACRO
:
10308 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10312 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10313 These sections are extensions for Fission.
10314 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10317 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10319 unsigned char *phdr
= section
->start
;
10320 unsigned char *limit
= phdr
+ section
->size
;
10321 unsigned char *phash
;
10322 unsigned char *pindex
;
10323 unsigned char *ppool
;
10324 unsigned int version
;
10325 unsigned int ncols
= 0;
10326 unsigned int nused
;
10327 unsigned int nslots
;
10330 dwarf_vma signature
;
10333 /* PR 17512: file: 002-168123-0.004. */
10336 warn (_("Section %s is empty\n"), section
->name
);
10339 /* PR 17512: file: 002-376-0.004. */
10340 if (section
->size
< 24)
10342 warn (_("Section %s is too small to contain a CU/TU header\n"),
10348 SAFE_BYTE_GET_AND_INC (version
, phash
, 4, limit
);
10350 SAFE_BYTE_GET_AND_INC (ncols
, phash
, 4, limit
);
10351 SAFE_BYTE_GET_AND_INC (nused
, phash
, 4, limit
);
10352 SAFE_BYTE_GET_AND_INC (nslots
, phash
, 4, limit
);
10354 pindex
= phash
+ (size_t) nslots
* 8;
10355 ppool
= pindex
+ (size_t) nslots
* 4;
10359 introduce (section
, false);
10361 printf (_(" Version: %u\n"), version
);
10363 printf (_(" Number of columns: %u\n"), ncols
);
10364 printf (_(" Number of used entries: %u\n"), nused
);
10365 printf (_(" Number of slots: %u\n\n"), nslots
);
10368 /* PR 17531: file: 45d69832. */
10369 if (_mul_overflow ((size_t) nslots
, 12, &total
)
10370 || total
> (size_t) (limit
- phash
))
10372 warn (ngettext ("Section %s is too small for %u slot\n",
10373 "Section %s is too small for %u slots\n",
10375 section
->name
, nslots
);
10382 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10383 for (i
= 0; i
< nslots
; i
++)
10385 unsigned char *shndx_list
;
10386 unsigned int shndx
;
10388 SAFE_BYTE_GET (signature
, phash
, 8, limit
);
10389 if (signature
!= 0)
10391 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10392 shndx_list
= ppool
+ j
* 4;
10393 /* PR 17531: file: 705e010d. */
10394 if (shndx_list
< ppool
)
10396 warn (_("Section index pool located before start of section\n"));
10401 printf (_(" [%3d] Signature: 0x%s Sections: "),
10402 i
, dwarf_vmatoa ("x", signature
));
10405 if (shndx_list
>= limit
)
10407 warn (_("Section %s too small for shndx pool\n"),
10411 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10415 printf (" %d", shndx
);
10417 add_shndx_to_cu_tu_entry (shndx
);
10423 end_cu_tu_entry ();
10429 else if (version
== 2)
10432 unsigned int dw_sect
;
10433 unsigned char *ph
= phash
;
10434 unsigned char *pi
= pindex
;
10435 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10436 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10438 struct cu_tu_set
*this_set
= NULL
;
10440 unsigned char *prow
;
10443 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10445 /* PR 17531: file: 0dd159bf.
10446 Check for integer overflow (can occur when size_t is 32-bit)
10447 with overlarge ncols or nused values. */
10449 || _mul_overflow ((size_t) ncols
, 4, &temp
)
10450 || _mul_overflow ((size_t) nused
+ 1, temp
, &total
)
10451 || total
> (size_t) (limit
- ppool
))
10453 warn (_("Section %s too small for offset and size tables\n"),
10460 printf (_(" Offset table\n"));
10461 printf (" slot %-16s ",
10462 is_tu_index
? _("signature") : _("dwo_id"));
10469 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10470 this_set
= tu_sets
;
10475 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10476 this_set
= cu_sets
;
10482 for (j
= 0; j
< ncols
; j
++)
10484 unsigned char *p
= ppool
+ j
* 4;
10485 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10486 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10491 for (i
= 0; i
< nslots
; i
++)
10493 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10495 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10498 /* PR 17531: file: a05f6ab3. */
10501 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10508 size_t num_copy
= sizeof (uint64_t);
10510 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10513 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10515 printf (_(" [%3d] 0x%s"),
10516 i
, dwarf_vmatoa ("x", signature
));
10517 for (j
= 0; j
< ncols
; j
++)
10519 unsigned char *p
= prow
+ j
* 4;
10520 SAFE_BYTE_GET (val
, p
, 4, limit
);
10522 printf (" %8d", val
);
10526 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10528 /* PR 17531: file: 10796eb3. */
10529 if (dw_sect
>= DW_SECT_MAX
)
10530 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10532 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10548 printf (_(" Size table\n"));
10549 printf (" slot %-16s ",
10550 is_tu_index
? _("signature") : _("dwo_id"));
10553 for (j
= 0; j
< ncols
; j
++)
10555 unsigned char *p
= ppool
+ j
* 4;
10556 SAFE_BYTE_GET (val
, p
, 4, limit
);
10558 printf (" %8s", get_DW_SECT_short_name (val
));
10564 for (i
= 0; i
< nslots
; i
++)
10566 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10568 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10571 prow
= psizes
+ (row
- 1) * ncols
* 4;
10574 printf (_(" [%3d] 0x%s"),
10575 i
, dwarf_vmatoa ("x", signature
));
10577 for (j
= 0; j
< ncols
; j
++)
10579 unsigned char *p
= prow
+ j
* 4;
10580 SAFE_BYTE_GET (val
, p
, 4, limit
);
10582 printf (" %8d", val
);
10586 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10587 if (dw_sect
>= DW_SECT_MAX
)
10588 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10590 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10602 else if (do_display
)
10603 printf (_(" Unsupported version (%d)\n"), version
);
10611 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10613 /* Load the CU and TU indexes if present. This will build a list of
10614 section sets that we can use to associate a .debug_info.dwo section
10615 with its associated .debug_abbrev.dwo section in a .dwp file. */
10618 load_cu_tu_indexes (void *file
)
10620 /* If we have already loaded (or tried to load) the CU and TU indexes
10621 then do not bother to repeat the task. */
10622 if (cu_tu_indexes_read
== -1)
10624 cu_tu_indexes_read
= true;
10626 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10627 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10628 cu_tu_indexes_read
= false;
10630 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10631 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10632 cu_tu_indexes_read
= false;
10635 return (bool) cu_tu_indexes_read
;
10638 /* Find the set of sections that includes section SHNDX. */
10641 find_cu_tu_set (void *file
, unsigned int shndx
)
10645 if (! load_cu_tu_indexes (file
))
10648 /* Find SHNDX in the shndx pool. */
10649 for (i
= 0; i
< shndx_pool_used
; i
++)
10650 if (shndx_pool
[i
] == shndx
)
10653 if (i
>= shndx_pool_used
)
10656 /* Now backup to find the first entry in the set. */
10657 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10660 return shndx_pool
+ i
;
10663 /* Display a .debug_cu_index or .debug_tu_index section. */
10666 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10668 return process_cu_tu_index (section
, 1);
10672 display_debug_not_supported (struct dwarf_section
*section
,
10673 void *file ATTRIBUTE_UNUSED
)
10675 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10681 /* Like malloc, but takes two parameters like calloc.
10682 Verifies that the first parameter is not too large.
10683 Note: does *not* initialise the allocated memory to zero. */
10686 cmalloc (size_t nmemb
, size_t size
)
10688 /* Check for overflow. */
10689 if (nmemb
>= ~(size_t) 0 / size
)
10692 return xmalloc (nmemb
* size
);
10695 /* Like xmalloc, but takes two parameters like calloc.
10696 Verifies that the first parameter is not too large.
10697 Note: does *not* initialise the allocated memory to zero. */
10700 xcmalloc (size_t nmemb
, size_t size
)
10702 /* Check for overflow. */
10703 if (nmemb
>= ~(size_t) 0 / size
)
10706 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10711 return xmalloc (nmemb
* size
);
10714 /* Like xrealloc, but takes three parameters.
10715 Verifies that the second parameter is not too large.
10716 Note: does *not* initialise any new memory to zero. */
10719 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10721 /* Check for overflow. */
10722 if (nmemb
>= ~(size_t) 0 / size
)
10724 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10729 return xrealloc (ptr
, nmemb
* size
);
10732 /* Like xcalloc, but verifies that the first parameter is not too large. */
10735 xcalloc2 (size_t nmemb
, size_t size
)
10737 /* Check for overflow. */
10738 if (nmemb
>= ~(size_t) 0 / size
)
10740 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10745 return xcalloc (nmemb
, size
);
10748 static unsigned long
10749 calc_gnu_debuglink_crc32 (unsigned long crc
,
10750 const unsigned char * buf
,
10753 static const unsigned long crc32_table
[256] =
10755 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10756 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10757 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10758 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10759 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10760 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10761 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10762 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10763 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10764 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10765 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10766 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10767 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10768 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10769 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10770 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10771 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10772 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10773 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10774 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10775 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10776 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10777 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10778 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10779 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10780 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10781 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10782 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10783 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10784 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10785 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10786 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10787 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10788 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10789 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10790 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10791 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10792 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10793 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10794 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10795 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10796 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10797 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10798 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10799 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10800 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10801 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10802 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10803 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10804 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10805 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10808 const unsigned char *end
;
10810 crc
= ~crc
& 0xffffffff;
10811 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10812 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10813 return ~crc
& 0xffffffff;
10816 typedef bool (*check_func_type
) (const char *, void *);
10817 typedef const char *(* parse_func_type
) (struct dwarf_section
*, void *);
10820 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10822 static unsigned char buffer
[8 * 1024];
10824 bfd_size_type count
;
10825 unsigned long crc
= 0;
10828 sep_data
= open_debug_file (pathname
);
10829 if (sep_data
== NULL
)
10832 /* Yes - we are opening the file twice... */
10833 f
= fopen (pathname
, "rb");
10836 /* Paranoia: This should never happen. */
10837 close_debug_file (sep_data
);
10838 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10842 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10843 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10847 if (crc
!= * (unsigned long *) crc_pointer
)
10849 close_debug_file (sep_data
);
10850 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10858 static const char *
10859 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10862 unsigned int crc_offset
;
10863 unsigned long * crc32
= (unsigned long *) data
;
10865 /* The name is first.
10866 The CRC value is stored after the filename, aligned up to 4 bytes. */
10867 name
= (const char *) section
->start
;
10869 crc_offset
= strnlen (name
, section
->size
) + 1;
10870 if (crc_offset
== 1)
10872 crc_offset
= (crc_offset
+ 3) & ~3;
10873 if (crc_offset
+ 4 > section
->size
)
10876 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10881 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10883 void * sep_data
= open_debug_file (filename
);
10885 if (sep_data
== NULL
)
10888 /* FIXME: We should now extract the build-id in the separate file
10894 typedef struct build_id_data
10897 const unsigned char * data
;
10900 static const char *
10901 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10904 bfd_size_type namelen
;
10905 bfd_size_type id_len
;
10906 Build_id_data
* build_id_data
;
10908 /* The name is first.
10909 The build-id follows immediately, with no padding, up to the section's end. */
10911 name
= (const char *) section
->start
;
10912 namelen
= strnlen (name
, section
->size
) + 1;
10915 if (namelen
>= section
->size
)
10918 id_len
= section
->size
- namelen
;
10922 build_id_data
= (Build_id_data
*) data
;
10923 build_id_data
->len
= id_len
;
10924 build_id_data
->data
= section
->start
+ namelen
;
10930 add_separate_debug_file (const char * filename
, void * handle
)
10932 separate_info
* i
= xmalloc (sizeof * i
);
10934 i
->filename
= filename
;
10935 i
->handle
= handle
;
10936 i
->next
= first_separate_info
;
10937 first_separate_info
= i
;
10940 #if HAVE_LIBDEBUGINFOD
10941 /* Query debuginfod servers for the target debuglink or debugaltlink
10942 file. If successful, store the path of the file in filename and
10943 return TRUE, otherwise return FALSE. */
10946 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10950 size_t build_id_len
;
10951 unsigned char * build_id
;
10953 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10955 /* Get the build-id of file. */
10956 build_id
= get_build_id (file
);
10959 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10961 /* Get the build-id of the debugaltlink file. */
10962 unsigned int filelen
;
10964 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10965 if (filelen
== section
->size
)
10966 /* Corrupt debugaltlink. */
10969 build_id
= section
->start
+ filelen
+ 1;
10970 build_id_len
= section
->size
- (filelen
+ 1);
10972 if (build_id_len
== 0)
10981 debuginfod_client
* client
;
10983 client
= debuginfod_begin ();
10984 if (client
== NULL
)
10987 /* Query debuginfod servers for the target file. If found its path
10988 will be stored in filename. */
10989 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10990 debuginfod_end (client
);
10992 /* Only free build_id if we allocated space for a hex string
10993 in get_build_id (). */
10994 if (build_id_len
== 0)
10999 /* File successfully retrieved. Close fd since we want to
11000 use open_debug_file () on filename instead. */
11011 load_separate_debug_info (const char * main_filename
,
11012 struct dwarf_section
* xlink
,
11013 parse_func_type parse_func
,
11014 check_func_type check_func
,
11016 void * file ATTRIBUTE_UNUSED
)
11018 const char * separate_filename
;
11019 char * debug_filename
;
11021 size_t canon_dirlen
;
11024 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
11026 warn (_("Corrupt debuglink section: %s\n"),
11027 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
11031 /* Attempt to locate the separate file.
11032 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
11034 canon_dir
= lrealpath (main_filename
);
11036 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
11037 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
11039 canon_dir
[canon_dirlen
] = '\0';
11042 #define DEBUGDIR "/lib/debug"
11044 #ifndef EXTRA_DEBUG_ROOT1
11045 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
11047 #ifndef EXTRA_DEBUG_ROOT2
11048 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
11051 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
11053 + strlen (".debug/")
11054 #ifdef EXTRA_DEBUG_ROOT1
11055 + strlen (EXTRA_DEBUG_ROOT1
)
11057 #ifdef EXTRA_DEBUG_ROOT2
11058 + strlen (EXTRA_DEBUG_ROOT2
)
11060 + strlen (separate_filename
)
11062 if (debug_filename
== NULL
)
11064 warn (_("Out of memory"));
11069 /* First try in the current directory. */
11070 sprintf (debug_filename
, "%s", separate_filename
);
11071 if (check_func (debug_filename
, func_data
))
11074 /* Then try in a subdirectory called .debug. */
11075 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11076 if (check_func (debug_filename
, func_data
))
11079 /* Then try in the same directory as the original file. */
11080 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11081 if (check_func (debug_filename
, func_data
))
11084 /* And the .debug subdirectory of that directory. */
11085 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11086 if (check_func (debug_filename
, func_data
))
11089 #ifdef EXTRA_DEBUG_ROOT1
11090 /* Try the first extra debug file root. */
11091 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11092 if (check_func (debug_filename
, func_data
))
11095 /* Try the first extra debug file root. */
11096 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
11097 if (check_func (debug_filename
, func_data
))
11101 #ifdef EXTRA_DEBUG_ROOT2
11102 /* Try the second extra debug file root. */
11103 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
11104 if (check_func (debug_filename
, func_data
))
11108 /* Then try in the global debug_filename directory. */
11109 strcpy (debug_filename
, DEBUGDIR
);
11110 dirlen
= strlen (DEBUGDIR
) - 1;
11111 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
11112 strcat (debug_filename
, "/");
11113 strcat (debug_filename
, (const char *) separate_filename
);
11115 if (check_func (debug_filename
, func_data
))
11118 #if HAVE_LIBDEBUGINFOD
11120 char * tmp_filename
;
11122 if (debuginfod_fetch_separate_debug_info (xlink
,
11126 /* File successfully downloaded from server, replace
11127 debug_filename with the file's path. */
11128 free (debug_filename
);
11129 debug_filename
= tmp_filename
;
11135 if (do_debug_links
)
11137 /* Failed to find the file. */
11138 warn (_("could not find separate debug file '%s'\n"),
11139 separate_filename
);
11140 warn (_("tried: %s\n"), debug_filename
);
11142 #ifdef EXTRA_DEBUG_ROOT2
11143 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
,
11144 separate_filename
);
11145 warn (_("tried: %s\n"), debug_filename
);
11148 #ifdef EXTRA_DEBUG_ROOT1
11149 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
,
11150 canon_dir
, separate_filename
);
11151 warn (_("tried: %s\n"), debug_filename
);
11153 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
,
11154 separate_filename
);
11155 warn (_("tried: %s\n"), debug_filename
);
11158 sprintf (debug_filename
, "%s.debug/%s", canon_dir
,
11159 separate_filename
);
11160 warn (_("tried: %s\n"), debug_filename
);
11162 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11163 warn (_("tried: %s\n"), debug_filename
);
11165 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11166 warn (_("tried: %s\n"), debug_filename
);
11168 sprintf (debug_filename
, "%s", separate_filename
);
11169 warn (_("tried: %s\n"), debug_filename
);
11171 #if HAVE_LIBDEBUGINFOD
11173 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11177 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11183 free (debug_filename
);
11189 void * debug_handle
;
11191 /* Now open the file.... */
11192 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11194 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11195 free (debug_filename
);
11199 /* FIXME: We do not check to see if there are any other separate debug info
11200 files that would also match. */
11202 if (do_debug_links
)
11203 printf (_("\n%s: Found separate debug info file: %s\n"), main_filename
, debug_filename
);
11204 add_separate_debug_file (debug_filename
, debug_handle
);
11206 /* Do not free debug_filename - it might be referenced inside
11207 the structure returned by open_debug_file(). */
11208 return debug_handle
;
11211 /* Attempt to load a separate dwarf object file. */
11214 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11216 char * separate_filename
;
11217 void * separate_handle
;
11219 if (IS_ABSOLUTE_PATH (name
))
11220 separate_filename
= strdup (name
);
11222 /* FIXME: Skip adding / if dwo_dir ends in /. */
11223 separate_filename
= concat (dir
, "/", name
, NULL
);
11224 if (separate_filename
== NULL
)
11226 warn (_("Out of memory allocating dwo filename\n"));
11230 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11232 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11233 free (separate_filename
);
11237 /* FIXME: We should check the dwo_id. */
11239 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11241 add_separate_debug_file (separate_filename
, separate_handle
);
11242 /* Note - separate_filename will be freed in free_debug_memory(). */
11243 return separate_handle
;
11247 load_debug_sup_file (const char * main_filename
, void * file
)
11249 if (! load_debug_section (debug_sup
, file
))
11250 return; /* No .debug_sup section. */
11252 struct dwarf_section
* section
;
11253 section
= & debug_displays
[debug_sup
].section
;
11254 assert (section
!= NULL
);
11256 if (section
->start
== NULL
|| section
->size
< 5)
11258 warn (_(".debug_sup section is corrupt/empty\n"));
11262 if (section
->start
[2] != 0)
11263 return; /* This is a supplementary file. */
11265 const char * filename
= (const char *) section
->start
+ 3;
11266 if (strnlen (filename
, section
->size
- 3) == section
->size
- 3)
11268 warn (_("filename in .debug_sup section is corrupt\n"));
11272 if (filename
[0] != '/' && strchr (main_filename
, '/'))
11277 new_len
= asprintf (& new_name
, "%.*s/%s",
11278 (int) (strrchr (main_filename
, '/') - main_filename
),
11283 warn (_("unable to construct path for supplementary debug file"));
11288 filename
= new_name
;
11292 /* PR 27796: Make sure that we pass a filename that can be free'd to
11293 add_separate_debug_file(). */
11294 filename
= strdup (filename
);
11295 if (filename
== NULL
)
11297 warn (_("out of memory constructing filename for .debug_sup link\n"));
11302 void * handle
= open_debug_file (filename
);
11303 if (handle
== NULL
)
11305 warn (_("unable to open file '%s' referenced from .debug_sup section\n"), filename
);
11306 free ((void *) filename
);
11310 printf (_("%s: Found supplementary debug file: %s\n\n"), main_filename
, filename
);
11312 /* FIXME: Compare the checksums, if present. */
11313 add_separate_debug_file (filename
, handle
);
11316 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11317 Recursively check the loaded files for more of these sections.
11318 Also follow any links in .debug_sup sections.
11319 FIXME: Should also check for DWO_* entries in the newly loaded files. */
11322 check_for_and_load_links (void * file
, const char * filename
)
11324 void * handle
= NULL
;
11326 if (load_debug_section (gnu_debugaltlink
, file
))
11328 Build_id_data build_id_data
;
11330 handle
= load_separate_debug_info (filename
,
11331 & debug_displays
[gnu_debugaltlink
].section
,
11332 parse_gnu_debugaltlink
,
11333 check_gnu_debugaltlink
,
11338 assert (handle
== first_separate_info
->handle
);
11339 check_for_and_load_links (first_separate_info
->handle
,
11340 first_separate_info
->filename
);
11344 if (load_debug_section (gnu_debuglink
, file
))
11346 unsigned long crc32
;
11348 handle
= load_separate_debug_info (filename
,
11349 & debug_displays
[gnu_debuglink
].section
,
11350 parse_gnu_debuglink
,
11351 check_gnu_debuglink
,
11356 assert (handle
== first_separate_info
->handle
);
11357 check_for_and_load_links (first_separate_info
->handle
,
11358 first_separate_info
->filename
);
11362 load_debug_sup_file (filename
, file
);
11365 /* Load the separate debug info file(s) attached to FILE, if any exist.
11366 Returns TRUE if any were found, FALSE otherwise.
11367 If TRUE is returned then the linked list starting at first_separate_info
11368 will be populated with open file handles. */
11371 load_separate_debug_files (void * file
, const char * filename
)
11373 /* Skip this operation if we are not interested in debug links. */
11374 if (! do_follow_links
&& ! do_debug_links
)
11377 /* See if there are any dwo links. */
11378 if (load_debug_section (str
, file
)
11379 && load_debug_section (abbrev
, file
)
11380 && load_debug_section (info
, file
))
11384 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
,
11387 bool introduced
= false;
11389 const char *dir
= NULL
;
11390 const char *id
= NULL
;
11391 const char *name
= NULL
;
11393 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11395 /* Accumulate NAME, DIR and ID fields. */
11396 switch (dwinfo
->type
)
11400 warn (_("Multiple DWO_NAMEs encountered for the same CU\n"));
11401 name
= dwinfo
->value
;
11405 /* There can be multiple DW_AT_comp_dir entries in a CU,
11406 so do not complain. */
11407 dir
= dwinfo
->value
;
11412 warn (_("multiple DWO_IDs encountered for the same CU\n"));
11413 id
= dwinfo
->value
;
11417 error (_("Unexpected DWO INFO type"));
11421 /* If we have reached the end of our list, or we are changing
11422 CUs, then display the information that we have accumulated
11425 && (dwinfo
->next
== NULL
11426 || dwinfo
->next
->cu_offset
!= dwinfo
->cu_offset
))
11428 if (do_debug_links
)
11432 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11433 debug_displays
[info
].section
.uncompressed_name
);
11437 printf (_(" Name: %s\n"), name
);
11438 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11440 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11442 printf (_(" ID: <not specified>\n"));
11446 if (do_follow_links
)
11447 load_dwo_file (filename
, name
, dir
, id
);
11449 name
= dir
= id
= NULL
;
11455 if (! do_follow_links
)
11456 /* The other debug links will be displayed by display_debug_links()
11457 so we do not need to do any further processing here. */
11460 /* FIXME: We do not check for the presence of both link sections in the same file. */
11461 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11462 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11464 check_for_and_load_links (file
, filename
);
11465 if (first_separate_info
!= NULL
)
11468 do_follow_links
= 0;
11473 free_debug_memory (void)
11477 free_all_abbrevs ();
11479 free (cu_abbrev_map
);
11480 cu_abbrev_map
= NULL
;
11481 next_free_abbrev_map_entry
= 0;
11485 shndx_pool_size
= 0;
11486 shndx_pool_used
= 0;
11494 memset (level_type_signed
, 0, sizeof level_type_signed
);
11495 cu_tu_indexes_read
= -1;
11497 for (i
= 0; i
< max
; i
++)
11498 free_debug_section ((enum dwarf_section_display_enum
) i
);
11500 if (debug_information
!= NULL
)
11502 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
11504 if (debug_information
[i
].max_loc_offsets
)
11506 free (debug_information
[i
].loc_offsets
);
11507 free (debug_information
[i
].have_frame_base
);
11509 if (debug_information
[i
].max_range_lists
)
11510 free (debug_information
[i
].range_lists
);
11512 free (debug_information
);
11513 debug_information
= NULL
;
11514 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
11518 separate_info
* next
;
11520 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
11522 close_debug_file (d
->handle
);
11523 free ((void *) d
->filename
);
11527 first_separate_info
= NULL
;
11533 dwarf_select_sections_by_names (const char *names
)
11537 const char * option
;
11541 debug_dump_long_opts
;
11543 static const debug_dump_long_opts opts_table
[] =
11545 /* Please keep this table alpha- sorted. */
11546 { "Ranges", & do_debug_ranges
, 1 },
11547 { "abbrev", & do_debug_abbrevs
, 1 },
11548 { "addr", & do_debug_addr
, 1 },
11549 { "aranges", & do_debug_aranges
, 1 },
11550 { "cu_index", & do_debug_cu_index
, 1 },
11551 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
11552 { "follow-links", & do_follow_links
, 1 },
11553 { "frames", & do_debug_frames
, 1 },
11554 { "frames-interp", & do_debug_frames_interp
, 1 },
11555 /* The special .gdb_index section. */
11556 { "gdb_index", & do_gdb_index
, 1 },
11557 { "info", & do_debug_info
, 1 },
11558 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
11559 { "links", & do_debug_links
, 1 },
11560 { "loc", & do_debug_loc
, 1 },
11561 { "macro", & do_debug_macinfo
, 1 },
11562 { "no-follow-links", & do_follow_links
, 0 },
11563 { "pubnames", & do_debug_pubnames
, 1 },
11564 { "pubtypes", & do_debug_pubtypes
, 1 },
11565 /* This entry is for compatibility
11566 with earlier versions of readelf. */
11567 { "ranges", & do_debug_aranges
, 1 },
11568 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
11569 { "str", & do_debug_str
, 1 },
11570 { "str-offsets", & do_debug_str_offsets
, 1 },
11571 /* These trace_* sections are used by Itanium VMS. */
11572 { "trace_abbrev", & do_trace_abbrevs
, 1 },
11573 { "trace_aranges", & do_trace_aranges
, 1 },
11574 { "trace_info", & do_trace_info
, 1 },
11583 const debug_dump_long_opts
* entry
;
11585 for (entry
= opts_table
; entry
->option
; entry
++)
11587 size_t len
= strlen (entry
->option
);
11589 if (strncmp (p
, entry
->option
, len
) == 0
11590 && (p
[len
] == ',' || p
[len
] == '\0'))
11592 * entry
->variable
= entry
->val
;
11594 /* The --debug-dump=frames-interp option also
11595 enables the --debug-dump=frames option. */
11596 if (do_debug_frames_interp
)
11597 do_debug_frames
= 1;
11604 if (entry
->option
== NULL
)
11606 warn (_("Unrecognized debug option '%s'\n"), p
);
11607 p
= strchr (p
, ',');
11618 dwarf_select_sections_by_letters (const char *letters
)
11620 unsigned int lindex
= 0;
11622 while (letters
[lindex
])
11623 switch (letters
[lindex
++])
11625 case 'A': do_debug_addr
= 1; break;
11626 case 'a': do_debug_abbrevs
= 1; break;
11627 case 'c': do_debug_cu_index
= 1; break;
11628 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
11629 case 'f': do_debug_frames
= 1; break;
11630 case 'g': do_gdb_index
= 1; break;
11631 case 'i': do_debug_info
= 1; break;
11632 case 'K': do_follow_links
= 1; break;
11633 case 'N': do_follow_links
= 0; break;
11634 case 'k': do_debug_links
= 1; break;
11635 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
11636 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
11637 case 'm': do_debug_macinfo
= 1; break;
11638 case 'O': do_debug_str_offsets
= 1; break;
11639 case 'o': do_debug_loc
= 1; break;
11640 case 'p': do_debug_pubnames
= 1; break;
11641 case 'R': do_debug_ranges
= 1; break;
11642 case 'r': do_debug_aranges
= 1; break;
11643 case 's': do_debug_str
= 1; break;
11644 case 'T': do_trace_aranges
= 1; break;
11645 case 't': do_debug_pubtypes
= 1; break;
11646 case 'U': do_trace_info
= 1; break;
11647 case 'u': do_trace_abbrevs
= 1; break;
11650 warn (_("Unrecognized debug option '%s'\n"), letters
);
11656 dwarf_select_sections_all (void)
11659 do_debug_abbrevs
= 1;
11660 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
11661 do_debug_pubnames
= 1;
11662 do_debug_pubtypes
= 1;
11663 do_debug_aranges
= 1;
11664 do_debug_ranges
= 1;
11665 do_debug_frames
= 1;
11666 do_debug_macinfo
= 1;
11671 do_trace_abbrevs
= 1;
11672 do_trace_aranges
= 1;
11674 do_debug_cu_index
= 1;
11675 do_follow_links
= 1;
11676 do_debug_links
= 1;
11677 do_debug_str_offsets
= 1;
11680 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0
11681 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0
11683 /* N.B. The order here must match the order in section_display_enum. */
11685 struct dwarf_section_display debug_displays
[] =
11687 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11688 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, true },
11689 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11690 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, true },
11691 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11692 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, false },
11693 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, false },
11694 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11695 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11696 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11697 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11698 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11699 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11700 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11701 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, false },
11702 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, false },
11703 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11704 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11705 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11706 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11707 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, true },
11708 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11709 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, false },
11710 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, false },
11711 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, true },
11712 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, false },
11713 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, false },
11714 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, true },
11715 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11716 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, true },
11717 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11718 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11719 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11720 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11721 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, true },
11722 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11723 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11724 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, true },
11725 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11726 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11727 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11728 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11729 { { ".debug_sup", "", NO_ABBREVS
}, display_debug_sup
, &do_debug_links
, false },
11730 /* Separate debug info files can containt their own .debug_str section,
11731 and this might be in *addition* to a .debug_str section already present
11732 in the main file. Hence we need to have two entries for .debug_str. */
11733 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11736 /* A static assertion. */
11737 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];