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 dwarf_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 dwarf_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 dwarf_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", (int) (end
- orig_data
), 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
);
2521 case DW_FORM_implicit_const
:
2522 uvalue
= implicit_const
;
2528 case DW_FORM_ref_addr
:
2530 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2533 case DW_FORM_GNU_ref_alt
:
2537 /* We have already printed the form name. */
2538 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2540 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2542 /* FIXME: Follow the reference... */
2548 case DW_FORM_ref_sup4
:
2549 case DW_FORM_ref_udata
:
2551 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2556 case DW_FORM_sec_offset
:
2558 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2561 case DW_FORM_flag_present
:
2568 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2571 case DW_FORM_implicit_const
:
2573 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2576 case DW_FORM_ref_sup8
:
2581 dwarf_vma utmp
= uvalue
;
2582 if (form
== DW_FORM_ref8
)
2584 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", utmp
));
2588 case DW_FORM_data16
:
2591 uvalue_hi
== 0 ? "" : dwarf_vmatoa ("x", uvalue_hi
),
2592 dwarf_vmatoa_1 ("x", uvalue
, uvalue_hi
== 0 ? 0 : 8));
2595 case DW_FORM_string
:
2597 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2598 data
+= strnlen ((char *) data
, end
- data
);
2604 case DW_FORM_exprloc
:
2605 READ_ULEB (uvalue
, data
, end
);
2608 if (block_start
>= end
)
2610 warn (_("Block ends prematurely\n"));
2615 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2618 data
= block_start
+ uvalue
;
2620 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2623 case DW_FORM_block1
:
2624 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2627 case DW_FORM_block2
:
2628 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2631 case DW_FORM_block4
:
2632 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2639 /* We have already displayed the form name. */
2640 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2641 dwarf_vmatoa ("x", uvalue
),
2642 fetch_indirect_string (uvalue
));
2644 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2645 dwarf_vmatoa ("x", uvalue
),
2646 fetch_indirect_string (uvalue
));
2650 case DW_FORM_line_strp
:
2654 /* We have already displayed the form name. */
2655 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2656 dwarf_vmatoa ("x", uvalue
),
2657 fetch_indirect_line_string (uvalue
));
2659 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2660 dwarf_vmatoa ("x", uvalue
),
2661 fetch_indirect_line_string (uvalue
));
2665 case DW_FORM_GNU_str_index
:
2673 const char *suffix
= strrchr (section
->name
, '.');
2674 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
2677 /* We have already displayed the form name. */
2678 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2679 dwarf_vmatoa ("x", uvalue
),
2680 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2682 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2683 dwarf_vmatoa ("x", uvalue
),
2684 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2688 case DW_FORM_GNU_strp_alt
:
2692 /* We have already displayed the form name. */
2693 printf (_("%c(offset: 0x%s) %s"), delimiter
,
2694 dwarf_vmatoa ("x", uvalue
),
2695 fetch_alt_indirect_string (uvalue
));
2697 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2698 dwarf_vmatoa ("x", uvalue
),
2699 fetch_alt_indirect_string (uvalue
));
2703 case DW_FORM_indirect
:
2704 /* Handled above. */
2707 case DW_FORM_ref_sig8
:
2709 printf ("%c%s: 0x%s", delimiter
, do_wide
? "" : "signature",
2710 dwarf_vmatoa ("x", uvalue
));
2713 case DW_FORM_GNU_addr_index
:
2715 case DW_FORM_addrx1
:
2716 case DW_FORM_addrx2
:
2717 case DW_FORM_addrx3
:
2718 case DW_FORM_addrx4
:
2724 if (debug_info_p
== NULL
)
2726 else if (debug_info_p
->addr_base
== DEBUG_INFO_UNAVAILABLE
)
2729 base
= debug_info_p
->addr_base
;
2731 offset
= base
+ uvalue
* pointer_size
;
2734 /* We have already displayed the form name. */
2735 printf (_("%c(index: 0x%s): %s"), delimiter
,
2736 dwarf_vmatoa ("x", uvalue
),
2737 fetch_indexed_value (offset
, pointer_size
));
2739 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2740 dwarf_vmatoa ("x", uvalue
),
2741 fetch_indexed_value (offset
, pointer_size
));
2745 case DW_FORM_strp_sup
:
2747 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2751 warn (_("Unrecognized form: 0x%lx\n"), form
);
2755 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2756 && num_debug_info_entries
== 0
2757 && debug_info_p
!= NULL
)
2761 case DW_AT_frame_base
:
2762 have_frame_base
= 1;
2764 case DW_AT_location
:
2765 case DW_AT_GNU_locviews
:
2766 case DW_AT_string_length
:
2767 case DW_AT_return_addr
:
2768 case DW_AT_data_member_location
:
2769 case DW_AT_vtable_elem_location
:
2771 case DW_AT_static_link
:
2772 case DW_AT_use_location
:
2773 case DW_AT_call_value
:
2774 case DW_AT_GNU_call_site_value
:
2775 case DW_AT_call_data_value
:
2776 case DW_AT_GNU_call_site_data_value
:
2777 case DW_AT_call_target
:
2778 case DW_AT_GNU_call_site_target
:
2779 case DW_AT_call_target_clobbered
:
2780 case DW_AT_GNU_call_site_target_clobbered
:
2781 if ((dwarf_version
< 4
2782 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2783 || form
== DW_FORM_sec_offset
)
2785 /* Process location list. */
2786 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2787 unsigned int num
= debug_info_p
->num_loc_offsets
;
2789 if (lmax
== 0 || num
>= lmax
)
2792 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2793 xcrealloc (debug_info_p
->loc_offsets
,
2794 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2795 debug_info_p
->loc_views
= (dwarf_vma
*)
2796 xcrealloc (debug_info_p
->loc_views
,
2797 lmax
, sizeof (*debug_info_p
->loc_views
));
2798 debug_info_p
->have_frame_base
= (int *)
2799 xcrealloc (debug_info_p
->have_frame_base
,
2800 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2801 debug_info_p
->max_loc_offsets
= lmax
;
2803 if (this_set
!= NULL
)
2804 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2805 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2806 if (attribute
!= DW_AT_GNU_locviews
)
2808 /* Corrupt DWARF info can produce more offsets than views.
2809 See PR 23062 for an example. */
2810 if (debug_info_p
->num_loc_offsets
2811 > debug_info_p
->num_loc_views
)
2812 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2815 debug_info_p
->loc_offsets
[num
] = uvalue
;
2816 debug_info_p
->num_loc_offsets
++;
2821 assert (debug_info_p
->num_loc_views
<= num
);
2822 num
= debug_info_p
->num_loc_views
;
2823 if (num
> debug_info_p
->num_loc_offsets
)
2824 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2827 debug_info_p
->loc_views
[num
] = uvalue
;
2828 debug_info_p
->num_loc_views
++;
2835 if (need_base_address
)
2836 debug_info_p
->base_address
= uvalue
;
2839 case DW_AT_GNU_addr_base
:
2840 case DW_AT_addr_base
:
2841 debug_info_p
->addr_base
= uvalue
;
2844 case DW_AT_GNU_ranges_base
:
2845 debug_info_p
->ranges_base
= uvalue
;
2849 if ((dwarf_version
< 4
2850 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2851 || form
== DW_FORM_sec_offset
)
2853 /* Process range list. */
2854 unsigned int lmax
= debug_info_p
->max_range_lists
;
2855 unsigned int num
= debug_info_p
->num_range_lists
;
2857 if (lmax
== 0 || num
>= lmax
)
2860 debug_info_p
->range_lists
= (dwarf_vma
*)
2861 xcrealloc (debug_info_p
->range_lists
,
2862 lmax
, sizeof (*debug_info_p
->range_lists
));
2863 debug_info_p
->max_range_lists
= lmax
;
2865 debug_info_p
->range_lists
[num
] = uvalue
;
2866 debug_info_p
->num_range_lists
++;
2870 case DW_AT_GNU_dwo_name
:
2871 case DW_AT_dwo_name
:
2876 add_dwo_name ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2878 case DW_FORM_GNU_strp_alt
:
2879 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
), cu_offset
);
2881 case DW_FORM_GNU_str_index
:
2887 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2889 case DW_FORM_string
:
2890 add_dwo_name ((const char *) orig_data
, cu_offset
);
2893 warn (_("Unsupported form (%s) for attribute %s\n"),
2894 get_FORM_name (form
), get_AT_name (attribute
));
2899 case DW_AT_comp_dir
:
2900 /* FIXME: Also extract a build-id in a CU/TU. */
2905 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2907 case DW_FORM_GNU_strp_alt
:
2908 add_dwo_dir (fetch_alt_indirect_string (uvalue
), cu_offset
);
2910 case DW_FORM_line_strp
:
2911 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
), cu_offset
);
2913 case DW_FORM_GNU_str_index
:
2919 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2921 case DW_FORM_string
:
2922 add_dwo_dir ((const char *) orig_data
, cu_offset
);
2925 warn (_("Unsupported form (%s) for attribute %s\n"),
2926 get_FORM_name (form
), get_AT_name (attribute
));
2931 case DW_AT_GNU_dwo_id
:
2936 /* FIXME: Record the length of the ID as well ? */
2937 add_dwo_id ((const char *) (data
- 8), cu_offset
);
2940 warn (_("Unsupported form (%s) for attribute %s\n"),
2941 get_FORM_name (form
), get_AT_name (attribute
));
2951 if (do_loc
|| attribute
== 0)
2954 /* For some attributes we can display further information. */
2958 if (level
>= 0 && level
< MAX_CU_NESTING
2959 && uvalue
< (size_t) (end
- start
))
2961 bool is_signed
= false;
2962 abbrev_entry
*type_abbrev
;
2963 unsigned char *type_data
;
2966 type_abbrev
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
2967 section
, NULL
, &type_data
, &map
);
2968 if (type_abbrev
!= NULL
)
2970 get_type_signedness (type_abbrev
, section
, type_data
,
2971 map
? section
->start
+ map
->end
: end
,
2972 map
? map
->start
: cu_offset
,
2973 pointer_size
, offset_size
, dwarf_version
,
2976 level_type_signed
[level
] = is_signed
;
2984 case DW_INL_not_inlined
:
2985 printf (_("(not inlined)"));
2987 case DW_INL_inlined
:
2988 printf (_("(inlined)"));
2990 case DW_INL_declared_not_inlined
:
2991 printf (_("(declared as inline but ignored)"));
2993 case DW_INL_declared_inlined
:
2994 printf (_("(declared as inline and inlined)"));
2997 printf (_(" (Unknown inline attribute value: %s)"),
2998 dwarf_vmatoa ("x", uvalue
));
3003 case DW_AT_language
:
3007 /* Ordered by the numeric value of these constants. */
3008 case DW_LANG_C89
: printf ("(ANSI C)"); break;
3009 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
3010 case DW_LANG_Ada83
: printf ("(Ada)"); break;
3011 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
3012 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
3013 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
3014 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
3015 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
3016 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
3017 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
3018 /* DWARF 2.1 values. */
3019 case DW_LANG_Java
: printf ("(Java)"); break;
3020 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
3021 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
3022 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
3023 /* DWARF 3 values. */
3024 case DW_LANG_PLI
: printf ("(PLI)"); break;
3025 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
3026 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
3027 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
3028 case DW_LANG_D
: printf ("(D)"); break;
3029 /* DWARF 4 values. */
3030 case DW_LANG_Python
: printf ("(Python)"); break;
3031 /* DWARF 5 values. */
3032 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
3033 case DW_LANG_Go
: printf ("(Go)"); break;
3034 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
3035 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
3036 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
3037 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
3038 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
3039 case DW_LANG_Rust
: printf ("(Rust)"); break;
3040 case DW_LANG_C11
: printf ("(C11)"); break;
3041 case DW_LANG_Swift
: printf ("(Swift)"); break;
3042 case DW_LANG_Julia
: printf ("(Julia)"); break;
3043 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
3044 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
3045 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
3046 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
3047 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
3048 /* MIPS extension. */
3049 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
3050 /* UPC extension. */
3051 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
3053 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
3054 printf (_("(implementation defined: %s)"),
3055 dwarf_vmatoa ("x", uvalue
));
3057 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
3062 case DW_AT_encoding
:
3066 case DW_ATE_void
: printf ("(void)"); break;
3067 case DW_ATE_address
: printf ("(machine address)"); break;
3068 case DW_ATE_boolean
: printf ("(boolean)"); break;
3069 case DW_ATE_complex_float
: printf ("(complex float)"); break;
3070 case DW_ATE_float
: printf ("(float)"); break;
3071 case DW_ATE_signed
: printf ("(signed)"); break;
3072 case DW_ATE_signed_char
: printf ("(signed char)"); break;
3073 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
3074 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
3075 /* DWARF 2.1 values: */
3076 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
3077 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
3078 /* DWARF 3 values: */
3079 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
3080 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
3081 case DW_ATE_edited
: printf ("(edited)"); break;
3082 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
3083 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
3084 /* DWARF 4 values: */
3085 case DW_ATE_UTF
: printf ("(unicode string)"); break;
3086 /* DWARF 5 values: */
3087 case DW_ATE_UCS
: printf ("(UCS)"); break;
3088 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
3090 /* HP extensions: */
3091 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
3092 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
3093 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
3094 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
3095 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
3096 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
3097 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
3100 if (uvalue
>= DW_ATE_lo_user
3101 && uvalue
<= DW_ATE_hi_user
)
3102 printf (_("(user defined type)"));
3104 printf (_("(unknown type)"));
3109 case DW_AT_accessibility
:
3113 case DW_ACCESS_public
: printf ("(public)"); break;
3114 case DW_ACCESS_protected
: printf ("(protected)"); break;
3115 case DW_ACCESS_private
: printf ("(private)"); break;
3117 printf (_("(unknown accessibility)"));
3122 case DW_AT_visibility
:
3126 case DW_VIS_local
: printf ("(local)"); break;
3127 case DW_VIS_exported
: printf ("(exported)"); break;
3128 case DW_VIS_qualified
: printf ("(qualified)"); break;
3129 default: printf (_("(unknown visibility)")); break;
3133 case DW_AT_endianity
:
3137 case DW_END_default
: printf ("(default)"); break;
3138 case DW_END_big
: printf ("(big)"); break;
3139 case DW_END_little
: printf ("(little)"); break;
3141 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
3142 printf (_("(user specified)"));
3144 printf (_("(unknown endianity)"));
3149 case DW_AT_virtuality
:
3153 case DW_VIRTUALITY_none
: printf ("(none)"); break;
3154 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
3155 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
3156 default: printf (_("(unknown virtuality)")); break;
3160 case DW_AT_identifier_case
:
3164 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
3165 case DW_ID_up_case
: printf ("(up_case)"); break;
3166 case DW_ID_down_case
: printf ("(down_case)"); break;
3167 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
3168 default: printf (_("(unknown case)")); break;
3172 case DW_AT_calling_convention
:
3176 case DW_CC_normal
: printf ("(normal)"); break;
3177 case DW_CC_program
: printf ("(program)"); break;
3178 case DW_CC_nocall
: printf ("(nocall)"); break;
3179 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
3180 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
3181 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
3182 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
3184 if (uvalue
>= DW_CC_lo_user
3185 && uvalue
<= DW_CC_hi_user
)
3186 printf (_("(user defined)"));
3188 printf (_("(unknown convention)"));
3192 case DW_AT_ordering
:
3197 case -1: printf (_("(undefined)")); break;
3198 case 0: printf ("(row major)"); break;
3199 case 1: printf ("(column major)"); break;
3203 case DW_AT_decimal_sign
:
3207 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
3208 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
3209 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
3210 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
3211 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
3212 default: printf (_("(unrecognised)")); break;
3216 case DW_AT_defaulted
:
3220 case DW_DEFAULTED_no
: printf (_("(no)")); break;
3221 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
3222 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
3223 default: printf (_("(unrecognised)")); break;
3227 case DW_AT_discr_list
:
3229 display_discr_list (form
, uvalue
, data
, end
, level
);
3232 case DW_AT_frame_base
:
3233 have_frame_base
= 1;
3235 case DW_AT_location
:
3236 case DW_AT_string_length
:
3237 case DW_AT_return_addr
:
3238 case DW_AT_data_member_location
:
3239 case DW_AT_vtable_elem_location
:
3241 case DW_AT_static_link
:
3242 case DW_AT_use_location
:
3243 case DW_AT_call_value
:
3244 case DW_AT_GNU_call_site_value
:
3245 case DW_AT_call_data_value
:
3246 case DW_AT_GNU_call_site_data_value
:
3247 case DW_AT_call_target
:
3248 case DW_AT_GNU_call_site_target
:
3249 case DW_AT_call_target_clobbered
:
3250 case DW_AT_GNU_call_site_target_clobbered
:
3251 if ((dwarf_version
< 4
3252 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3253 || form
== DW_FORM_sec_offset
)
3254 printf (_(" (location list)"));
3256 case DW_AT_allocated
:
3257 case DW_AT_associated
:
3258 case DW_AT_data_location
:
3260 case DW_AT_upper_bound
:
3261 case DW_AT_lower_bound
:
3264 int need_frame_base
;
3267 need_frame_base
= decode_location_expression (block_start
,
3272 cu_offset
, section
);
3274 if (need_frame_base
&& !have_frame_base
)
3275 printf (_(" [without DW_AT_frame_base]"));
3279 case DW_AT_data_bit_offset
:
3280 case DW_AT_byte_size
:
3281 case DW_AT_bit_size
:
3282 case DW_AT_string_length_byte_size
:
3283 case DW_AT_string_length_bit_size
:
3284 case DW_AT_bit_stride
:
3285 if (form
== DW_FORM_exprloc
)
3288 (void) decode_location_expression (block_start
, pointer_size
,
3289 offset_size
, dwarf_version
,
3290 uvalue
, cu_offset
, section
);
3297 unsigned long abbrev_number
;
3298 abbrev_entry
*entry
;
3300 entry
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
3301 section
, & abbrev_number
, NULL
, NULL
);
3304 if (form
!= DW_FORM_GNU_ref_alt
)
3305 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
3306 dwarf_vmatoa ("x", uvalue
),
3307 (unsigned long) (orig_data
- section
->start
));
3311 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3312 printf (" (%s)", get_TAG_name (entry
->tag
));
3325 static unsigned char *
3326 read_and_display_attr (unsigned long attribute
,
3328 dwarf_signed_vma implicit_const
,
3329 unsigned char * start
,
3330 unsigned char * data
,
3331 unsigned char * end
,
3332 dwarf_vma cu_offset
,
3333 dwarf_vma pointer_size
,
3334 dwarf_vma offset_size
,
3336 debug_info
* debug_info_p
,
3338 struct dwarf_section
* section
,
3339 struct cu_tu_set
* this_set
,
3343 printf (" %-18s:", get_AT_name (attribute
));
3344 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3346 cu_offset
, pointer_size
, offset_size
,
3347 dwarf_version
, debug_info_p
,
3348 do_loc
, section
, this_set
, ' ', level
);
3354 /* Like load_debug_section, but if the ordinary call fails, and we are
3355 following debug links, then attempt to load the requested section
3356 from one of the separate debug info files. */
3359 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3362 if (load_debug_section (sec_enum
, handle
))
3364 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3366 /* See if we can associate a filename with this section. */
3369 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3370 if (i
->handle
== handle
)
3372 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3380 if (do_follow_links
)
3384 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3386 if (load_debug_section (sec_enum
, i
->handle
))
3388 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3390 /* FIXME: We should check to see if any of the remaining debug info
3391 files also contain this section, and, umm, do something about it. */
3401 introduce (struct dwarf_section
* section
, bool raw
)
3405 if (do_follow_links
&& section
->filename
)
3406 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3407 section
->name
, section
->filename
);
3409 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3413 if (do_follow_links
&& section
->filename
)
3414 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3415 section
->name
, section
->filename
);
3417 printf (_("Contents of the %s section:\n\n"), section
->name
);
3421 /* Process the contents of a .debug_info section.
3422 If do_loc is TRUE then we are scanning for location lists and dwo tags
3423 and we do not want to display anything to the user.
3424 If do_types is TRUE, we are processing a .debug_types section instead of
3425 a .debug_info section.
3426 The information displayed is restricted by the values in DWARF_START_DIE
3427 and DWARF_CUTOFF_LEVEL.
3428 Returns TRUE upon success. Otherwise an error or warning message is
3429 printed and FALSE is returned. */
3432 process_debug_info (struct dwarf_section
* section
,
3434 enum dwarf_section_display_enum abbrev_sec
,
3438 unsigned char *start
= section
->start
;
3439 unsigned char *end
= start
+ section
->size
;
3440 unsigned char *section_begin
;
3442 unsigned int num_units
= 0;
3444 /* First scan the section to get the number of comp units.
3445 Length sanity checks are done here. */
3446 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3451 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3452 will be the length. For a 64-bit DWARF section, it'll be
3453 the escape code 0xffffffff followed by an 8 byte length. */
3454 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 4, end
);
3456 if (length
== 0xffffffff)
3457 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 8, end
);
3458 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3460 warn (_("Reserved length value (0x%s) found in section %s\n"),
3461 dwarf_vmatoa ("x", length
), section
->name
);
3465 /* Negative values are illegal, they may even cause infinite
3466 looping. This can happen if we can't accurately apply
3467 relocations to an object file, or if the file is corrupt. */
3468 if (length
> (size_t) (end
- section_begin
))
3470 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3471 dwarf_vmatoa ("x", length
), section
->name
);
3474 section_begin
+= length
;
3479 error (_("No comp units in %s section ?\n"), section
->name
);
3483 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3484 && num_debug_info_entries
== 0
3488 /* Then allocate an array to hold the information. */
3489 debug_information
= (debug_info
*) cmalloc (num_units
,
3490 sizeof (* debug_information
));
3491 if (debug_information
== NULL
)
3493 error (_("Not enough memory for a debug info array of %u entries\n"),
3495 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3499 /* PR 17531: file: 92ca3797.
3500 We cannot rely upon the debug_information array being initialised
3501 before it is used. A corrupt file could easily contain references
3502 to a unit for which information has not been made available. So
3503 we ensure that the array is zeroed here. */
3504 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3506 alloc_num_debug_info_entries
= num_units
;
3511 load_debug_section_with_follow (str
, file
);
3512 load_debug_section_with_follow (line_str
, file
);
3513 load_debug_section_with_follow (str_dwo
, file
);
3514 load_debug_section_with_follow (str_index
, file
);
3515 load_debug_section_with_follow (str_index_dwo
, file
);
3516 load_debug_section_with_follow (debug_addr
, file
);
3519 load_debug_section_with_follow (abbrev_sec
, file
);
3520 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3522 warn (_("Unable to locate %s section!\n"),
3523 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3527 if (!do_loc
&& dwarf_start_die
== 0)
3528 introduce (section
, false);
3530 free_all_abbrevs ();
3531 free (cu_abbrev_map
);
3532 cu_abbrev_map
= NULL
;
3533 next_free_abbrev_map_entry
= 0;
3535 /* In order to be able to resolve DW_FORM_ref_attr forms we need
3536 to load *all* of the abbrevs for all CUs in this .debug_info
3537 section. This does effectively mean that we (partially) read
3538 every CU header twice. */
3539 for (section_begin
= start
; start
< end
;)
3541 DWARF2_Internal_CompUnit compunit
;
3542 unsigned char * hdrptr
;
3543 dwarf_vma abbrev_base
;
3545 dwarf_vma cu_offset
;
3546 unsigned int offset_size
;
3547 struct cu_tu_set
* this_set
;
3549 unsigned char *end_cu
;
3552 cu_offset
= start
- section_begin
;
3554 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3556 if (compunit
.cu_length
== 0xffffffff)
3558 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3563 end_cu
= hdrptr
+ compunit
.cu_length
;
3565 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3567 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3569 if (compunit
.cu_version
< 5)
3571 compunit
.cu_unit_type
= DW_UT_compile
;
3572 /* Initialize it due to a false compiler warning. */
3573 compunit
.cu_pointer_size
= -1;
3577 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3578 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3580 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3583 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
,
3586 if (compunit
.cu_unit_type
== DW_UT_split_compile
3587 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3590 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3593 if (this_set
== NULL
)
3596 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3600 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3601 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3604 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3605 compunit
.cu_abbrev_offset
);
3608 unsigned char * next
;
3610 list
= new_abbrev_list (abbrev_base
,
3611 compunit
.cu_abbrev_offset
);
3612 next
= process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3613 abbrev_base
, abbrev_size
,
3614 compunit
.cu_abbrev_offset
, list
);
3615 list
->start_of_next_abbrevs
= next
;
3619 record_abbrev_list_for_cu (cu_offset
, start
- section_begin
, list
);
3622 for (start
= section_begin
, unit
= 0; start
< end
; unit
++)
3624 DWARF2_Internal_CompUnit compunit
;
3625 unsigned char *hdrptr
;
3626 unsigned char *tags
;
3627 int level
, last_level
, saved_level
;
3628 dwarf_vma cu_offset
;
3629 unsigned int offset_size
;
3630 dwarf_vma signature
= 0;
3631 dwarf_vma type_offset
= 0;
3632 struct cu_tu_set
*this_set
;
3633 dwarf_vma abbrev_base
;
3635 abbrev_list
* list
= NULL
;
3636 unsigned char *end_cu
;
3639 cu_offset
= start
- section_begin
;
3641 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3643 if (compunit
.cu_length
== 0xffffffff)
3645 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3650 end_cu
= hdrptr
+ compunit
.cu_length
;
3652 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3654 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3656 if (compunit
.cu_version
< 5)
3658 compunit
.cu_unit_type
= DW_UT_compile
;
3659 /* Initialize it due to a false compiler warning. */
3660 compunit
.cu_pointer_size
= -1;
3664 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3665 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3667 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3670 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end_cu
);
3672 if (this_set
== NULL
)
3675 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3679 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3680 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3683 if (compunit
.cu_version
< 5)
3684 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3686 bool do_dwo_id
= false;
3687 uint64_t dwo_id
= 0;
3688 if (compunit
.cu_unit_type
== DW_UT_split_compile
3689 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3691 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3695 /* PR 17512: file: 001-108546-0.001:0.1. */
3696 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3698 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3699 compunit
.cu_pointer_size
, offset_size
);
3700 compunit
.cu_pointer_size
= offset_size
;
3705 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, end_cu
);
3706 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end_cu
);
3709 if (dwarf_start_die
>= (size_t) (end_cu
- section_begin
))
3715 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3716 && num_debug_info_entries
== 0
3717 && alloc_num_debug_info_entries
> unit
3720 debug_information
[unit
].cu_offset
= cu_offset
;
3721 debug_information
[unit
].pointer_size
3722 = compunit
.cu_pointer_size
;
3723 debug_information
[unit
].offset_size
= offset_size
;
3724 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3725 debug_information
[unit
].base_address
= 0;
3726 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3727 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3728 debug_information
[unit
].loc_offsets
= NULL
;
3729 debug_information
[unit
].have_frame_base
= NULL
;
3730 debug_information
[unit
].max_loc_offsets
= 0;
3731 debug_information
[unit
].num_loc_offsets
= 0;
3732 debug_information
[unit
].range_lists
= NULL
;
3733 debug_information
[unit
].max_range_lists
= 0;
3734 debug_information
[unit
].num_range_lists
= 0;
3737 if (!do_loc
&& dwarf_start_die
== 0)
3739 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3740 dwarf_vmatoa ("x", cu_offset
));
3741 printf (_(" Length: 0x%s (%s)\n"),
3742 dwarf_vmatoa ("x", compunit
.cu_length
),
3743 offset_size
== 8 ? "64-bit" : "32-bit");
3744 printf (_(" Version: %d\n"), compunit
.cu_version
);
3745 if (compunit
.cu_version
>= 5)
3747 const char *name
= get_DW_UT_name (compunit
.cu_unit_type
);
3749 printf (_(" Unit Type: %s (%x)\n"),
3750 name
? name
: "???",
3751 compunit
.cu_unit_type
);
3753 printf (_(" Abbrev Offset: 0x%s\n"),
3754 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3755 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3758 printf (_(" Signature: 0x%s\n"),
3759 dwarf_vmatoa ("x", signature
));
3760 printf (_(" Type Offset: 0x%s\n"),
3761 dwarf_vmatoa ("x", type_offset
));
3764 printf (_(" DWO ID: 0x%s\n"), dwarf_vmatoa ("x", dwo_id
));
3765 if (this_set
!= NULL
)
3767 dwarf_vma
*offsets
= this_set
->section_offsets
;
3768 size_t *sizes
= this_set
->section_sizes
;
3770 printf (_(" Section contributions:\n"));
3771 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3772 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3773 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3774 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3775 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3776 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3777 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3778 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3779 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3780 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3781 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3782 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3789 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3791 warn (_("CU at offset %s contains corrupt or "
3792 "unsupported version number: %d.\n"),
3793 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3797 if (compunit
.cu_unit_type
!= DW_UT_compile
3798 && compunit
.cu_unit_type
!= DW_UT_partial
3799 && compunit
.cu_unit_type
!= DW_UT_type
3800 && compunit
.cu_unit_type
!= DW_UT_split_compile
3801 && compunit
.cu_unit_type
!= DW_UT_skeleton
)
3803 warn (_("CU at offset %s contains corrupt or "
3804 "unsupported unit type: %d.\n"),
3805 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3809 /* Process the abbrevs used by this compilation unit. */
3810 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3811 compunit
.cu_abbrev_offset
);
3814 unsigned char *next
;
3816 list
= new_abbrev_list (abbrev_base
,
3817 compunit
.cu_abbrev_offset
);
3818 next
= process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3819 abbrev_base
, abbrev_size
,
3820 compunit
.cu_abbrev_offset
, list
);
3821 list
->start_of_next_abbrevs
= next
;
3827 while (tags
< start
)
3829 unsigned long abbrev_number
;
3830 unsigned long die_offset
;
3831 abbrev_entry
*entry
;
3833 int do_printing
= 1;
3835 die_offset
= tags
- section_begin
;
3837 READ_ULEB (abbrev_number
, tags
, start
);
3839 /* A null DIE marks the end of a list of siblings or it may also be
3840 a section padding. */
3841 if (abbrev_number
== 0)
3843 /* Check if it can be a section padding for the last CU. */
3844 if (level
== 0 && start
== end
)
3848 for (chk
= tags
; chk
< start
; chk
++)
3855 if (!do_loc
&& die_offset
>= dwarf_start_die
3856 && (dwarf_cutoff_level
== -1
3857 || level
< dwarf_cutoff_level
))
3858 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3864 static unsigned num_bogus_warns
= 0;
3866 if (num_bogus_warns
< 3)
3868 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3869 die_offset
, section
->name
);
3871 if (num_bogus_warns
== 3)
3872 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3875 if (dwarf_start_die
!= 0 && level
< saved_level
)
3882 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3886 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3887 saved_level
= level
;
3888 do_printing
= (dwarf_cutoff_level
== -1
3889 || level
< dwarf_cutoff_level
);
3891 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3892 level
, die_offset
, abbrev_number
);
3893 else if (dwarf_cutoff_level
== -1
3894 || last_level
< dwarf_cutoff_level
)
3895 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3900 /* Scan through the abbreviation list until we reach the
3905 for (entry
= list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
3906 if (entry
->number
== abbrev_number
)
3911 if (!do_loc
&& do_printing
)
3916 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3917 die_offset
, abbrev_number
);
3921 if (!do_loc
&& do_printing
)
3922 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3927 need_base_address
= 0;
3929 case DW_TAG_compile_unit
:
3930 need_base_address
= 1;
3931 need_dwo_info
= do_loc
;
3933 case DW_TAG_entry_point
:
3934 case DW_TAG_subprogram
:
3935 need_base_address
= 0;
3936 /* Assuming that there is no DW_AT_frame_base. */
3937 have_frame_base
= 0;
3941 debug_info
*debug_info_p
=
3942 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3943 ? debug_information
+ unit
: NULL
;
3945 assert (!debug_info_p
3946 || (debug_info_p
->num_loc_offsets
3947 == debug_info_p
->num_loc_views
));
3949 for (attr
= entry
->first_attr
;
3950 attr
&& attr
->attribute
;
3953 if (! do_loc
&& do_printing
)
3954 /* Show the offset from where the tag was extracted. */
3955 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3956 tags
= read_and_display_attr (attr
->attribute
,
3958 attr
->implicit_const
,
3963 compunit
.cu_pointer_size
,
3965 compunit
.cu_version
,
3967 do_loc
|| ! do_printing
,
3973 /* If a locview attribute appears before a location one,
3974 make sure we don't associate it with an earlier
3977 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3980 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3981 debug_info_p
->num_loc_views
++;
3982 assert (debug_info_p
->num_loc_views
3983 == debug_info_p
->num_loc_offsets
);
3990 warn(_("DIE has locviews without loclist\n"));
3991 debug_info_p
->num_loc_views
--;
3998 if (entry
->children
)
4003 /* Set num_debug_info_entries here so that it can be used to check if
4004 we need to process .debug_loc and .debug_ranges sections. */
4005 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
4006 && num_debug_info_entries
== 0
4009 if (num_units
> alloc_num_debug_info_entries
)
4010 num_debug_info_entries
= alloc_num_debug_info_entries
;
4012 num_debug_info_entries
= num_units
;
4021 /* Locate and scan the .debug_info section in the file and record the pointer
4022 sizes and offsets for the compilation units in it. Usually an executable
4023 will have just one pointer size, but this is not guaranteed, and so we try
4024 not to make any assumptions. Returns zero upon failure, or the number of
4025 compilation units upon success. */
4028 load_debug_info (void * file
)
4030 /* If we have already tried and failed to load the .debug_info
4031 section then do not bother to repeat the task. */
4032 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4035 /* If we already have the information there is nothing else to do. */
4036 if (num_debug_info_entries
> 0)
4037 return num_debug_info_entries
;
4039 /* If this is a DWARF package file, load the CU and TU indexes. */
4040 (void) load_cu_tu_indexes (file
);
4042 if (load_debug_section_with_follow (info
, file
)
4043 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, true, false))
4044 return num_debug_info_entries
;
4046 if (load_debug_section_with_follow (info_dwo
, file
)
4047 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
4048 abbrev_dwo
, true, false))
4049 return num_debug_info_entries
;
4051 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
4055 /* Read a DWARF .debug_line section header starting at DATA.
4056 Upon success returns an updated DATA pointer and the LINFO
4057 structure and the END_OF_SEQUENCE pointer will be filled in.
4058 Otherwise returns NULL. */
4060 static unsigned char *
4061 read_debug_line_header (struct dwarf_section
* section
,
4062 unsigned char * data
,
4063 unsigned char * end
,
4064 DWARF2_Internal_LineInfo
* linfo
,
4065 unsigned char ** end_of_sequence
)
4067 unsigned char *hdrptr
;
4069 /* Extract information from the Line Number Program Header.
4070 (section 6.2.4 in the Dwarf3 doc). */
4073 /* Get and check the length of the block. */
4074 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
4076 if (linfo
->li_length
== 0xffffffff)
4078 /* This section is 64-bit DWARF 3. */
4079 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
4080 linfo
->li_offset_size
= 8;
4083 linfo
->li_offset_size
= 4;
4085 if (linfo
->li_length
> (size_t) (end
- hdrptr
))
4087 /* If the length field has a relocation against it, then we should
4088 not complain if it is inaccurate (and probably negative). This
4089 happens in object files when the .debug_line section is actually
4090 comprised of several different .debug_line.* sections, (some of
4091 which may be removed by linker garbage collection), and a relocation
4092 is used to compute the correct length once that is done. */
4093 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
4095 linfo
->li_length
= end
- hdrptr
;
4099 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
4100 (long) linfo
->li_length
);
4104 end
= hdrptr
+ linfo
->li_length
;
4106 /* Get and check the version number. */
4107 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
4109 if (linfo
->li_version
!= 2
4110 && linfo
->li_version
!= 3
4111 && linfo
->li_version
!= 4
4112 && linfo
->li_version
!= 5)
4114 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
4115 "is currently supported.\n"));
4119 if (linfo
->li_version
>= 5)
4121 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
4123 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
4124 if (linfo
->li_segment_size
!= 0)
4126 warn (_("The %s section contains "
4127 "unsupported segment selector size: %d.\n"),
4128 section
->name
, linfo
->li_segment_size
);
4133 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
4134 linfo
->li_offset_size
, end
);
4135 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
4137 if (linfo
->li_version
>= 4)
4139 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
4141 if (linfo
->li_max_ops_per_insn
== 0)
4143 warn (_("Invalid maximum operations per insn.\n"));
4148 linfo
->li_max_ops_per_insn
= 1;
4150 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
4151 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
4152 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
4153 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
4155 *end_of_sequence
= end
;
4159 static unsigned char *
4160 display_formatted_table (unsigned char *data
,
4161 unsigned char *start
,
4163 const DWARF2_Internal_LineInfo
*linfo
,
4164 struct dwarf_section
*section
,
4167 unsigned char *format_start
, format_count
, *format
, formati
;
4168 dwarf_vma data_count
, datai
;
4169 unsigned int namepass
, last_entry
= 0;
4170 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
4172 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4173 if (do_checks
&& format_count
> 5)
4174 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
4175 table_name
, format_count
);
4177 format_start
= data
;
4178 for (formati
= 0; formati
< format_count
; formati
++)
4180 SKIP_ULEB (data
, end
);
4181 SKIP_ULEB (data
, end
);
4184 warn (_("%s: Corrupt format description entry\n"), table_name
);
4189 READ_ULEB (data_count
, data
, end
);
4190 if (data_count
== 0)
4192 printf (_("\n The %s is empty.\n"), table_name
);
4195 else if (data
>= end
)
4197 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
4198 table_name
, dwarf_vmatoa ("x", data_count
));
4202 else if (format_count
== 0)
4204 warn (_("%s: format count is zero, but the table is not empty\n"),
4209 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
4210 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
4213 printf (_(" Entry"));
4214 /* Delay displaying name as the last entry for better screen layout. */
4215 for (namepass
= 0; namepass
< 2; namepass
++)
4217 format
= format_start
;
4218 for (formati
= 0; formati
< format_count
; formati
++)
4220 dwarf_vma content_type
;
4222 READ_ULEB (content_type
, format
, end
);
4223 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
4224 switch (content_type
)
4227 printf (_("\tName"));
4229 case DW_LNCT_directory_index
:
4230 printf (_("\tDir"));
4232 case DW_LNCT_timestamp
:
4233 printf (_("\tTime"));
4236 printf (_("\tSize"));
4239 printf (_("\tMD5\t\t\t"));
4242 printf (_("\t(Unknown format content type %s)"),
4243 dwarf_vmatoa ("u", content_type
));
4245 SKIP_ULEB (format
, end
);
4250 for (datai
= 0; datai
< data_count
; datai
++)
4252 unsigned char *datapass
= data
;
4254 printf (" %d", last_entry
++);
4255 /* Delay displaying name as the last entry for better screen layout. */
4256 for (namepass
= 0; namepass
< 2; namepass
++)
4258 format
= format_start
;
4260 for (formati
= 0; formati
< format_count
; formati
++)
4262 dwarf_vma content_type
, form
;
4264 READ_ULEB (content_type
, format
, end
);
4265 READ_ULEB (form
, format
, end
);
4266 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4267 0, 0, linfo
->li_offset_size
,
4268 linfo
->li_version
, NULL
,
4269 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
4270 section
, NULL
, '\t', -1);
4274 if (data
>= end
&& (datai
< data_count
- 1))
4276 warn (_("\n%s: Corrupt entries list\n"), table_name
);
4285 display_debug_sup (struct dwarf_section
* section
,
4286 void * file ATTRIBUTE_UNUSED
)
4288 unsigned char * start
= section
->start
;
4289 unsigned char * end
= section
->start
+ section
->size
;
4290 unsigned int version
;
4291 char is_supplementary
;
4292 const unsigned char * sup_filename
;
4293 size_t sup_filename_len
;
4294 unsigned int num_read
;
4296 dwarf_vma checksum_len
;
4299 introduce (section
, true);
4300 if (section
->size
< 4)
4302 error (_("corrupt .debug_sup section: size is too small\n"));
4306 /* Read the data. */
4307 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
4309 warn (_("corrupt .debug_sup section: version < 5"));
4311 SAFE_BYTE_GET_AND_INC (is_supplementary
, start
, 1, end
);
4312 if (is_supplementary
!= 0 && is_supplementary
!= 1)
4313 warn (_("corrupt .debug_sup section: is_supplementary not 0 or 1\n"));
4315 sup_filename
= start
;
4316 if (is_supplementary
&& sup_filename
[0] != 0)
4317 warn (_("corrupt .debug_sup section: filename not empty in supplementary section\n"));
4319 sup_filename_len
= strnlen ((const char *) start
, end
- start
);
4320 if (sup_filename_len
== (size_t) (end
- start
))
4322 error (_("corrupt .debug_sup section: filename is not NUL terminated\n"));
4325 start
+= sup_filename_len
+ 1;
4327 checksum_len
= read_leb128 (start
, end
, false /* unsigned */, & num_read
, & status
);
4330 error (_("corrupt .debug_sup section: bad LEB128 field for checksum length\n"));
4334 if (checksum_len
> (dwarf_vma
) (end
- start
))
4336 error (_("corrupt .debug_sup section: checksum length is longer than the remaining section length\n"));
4337 checksum_len
= end
- start
;
4339 else if (checksum_len
< (dwarf_vma
) (end
- start
))
4341 warn (_("corrupt .debug_sup section: there are 0x%lx extra, unused bytes at the end of the section\n"),
4342 (long) ((end
- start
) - checksum_len
));
4345 printf (_(" Version: %u\n"), version
);
4346 printf (_(" Is Supp: %u\n"), is_supplementary
);
4347 printf (_(" Filename: %s\n"), sup_filename
);
4348 printf (_(" Checksum Len: %lu\n"), (long) checksum_len
);
4349 if (checksum_len
> 0)
4351 printf (_(" Checksum: "));
4352 while (checksum_len
--)
4353 printf ("0x%x ", * start
++ );
4360 display_debug_lines_raw (struct dwarf_section
* section
,
4361 unsigned char * data
,
4362 unsigned char * end
,
4365 unsigned char *start
= section
->start
;
4366 int verbose_view
= 0;
4368 introduce (section
, true);
4372 static DWARF2_Internal_LineInfo saved_linfo
;
4373 DWARF2_Internal_LineInfo linfo
;
4374 unsigned char *standard_opcodes
;
4375 unsigned char *end_of_sequence
;
4378 if (startswith (section
->name
, ".debug_line.")
4379 /* Note: the following does not apply to .debug_line.dwo sections.
4380 These are full debug_line sections. */
4381 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4383 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4384 section containing just the Line Number Statements. They are
4385 created by the assembler and intended to be used alongside gcc's
4386 -ffunction-sections command line option. When the linker's
4387 garbage collection decides to discard a .text.<foo> section it
4388 can then also discard the line number information in .debug_line.<foo>.
4390 Since the section is a fragment it does not have the details
4391 needed to fill out a LineInfo structure, so instead we use the
4392 details from the last full debug_line section that we processed. */
4393 end_of_sequence
= end
;
4394 standard_opcodes
= NULL
;
4395 linfo
= saved_linfo
;
4396 /* PR 17531: file: 0522b371. */
4397 if (linfo
.li_line_range
== 0)
4399 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4402 reset_state_machine (linfo
.li_default_is_stmt
);
4406 unsigned char * hdrptr
;
4408 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4409 & end_of_sequence
)) == NULL
)
4412 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
4413 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
4414 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4415 if (linfo
.li_version
>= 5)
4417 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
4418 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
4420 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4421 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4422 if (linfo
.li_version
>= 4)
4423 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4424 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4425 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4426 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4427 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4429 /* PR 17512: file: 1665-6428-0.004. */
4430 if (linfo
.li_line_range
== 0)
4432 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4433 linfo
.li_line_range
= 1;
4436 reset_state_machine (linfo
.li_default_is_stmt
);
4438 /* Display the contents of the Opcodes table. */
4439 standard_opcodes
= hdrptr
;
4441 /* PR 17512: file: 002-417945-0.004. */
4442 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4444 warn (_("Line Base extends beyond end of section\n"));
4448 printf (_("\n Opcodes:\n"));
4450 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4451 printf (ngettext (" Opcode %d has %d arg\n",
4452 " Opcode %d has %d args\n",
4453 standard_opcodes
[i
- 1]),
4454 i
, standard_opcodes
[i
- 1]);
4456 /* Display the contents of the Directory table. */
4457 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4459 if (linfo
.li_version
>= 5)
4461 load_debug_section_with_follow (line_str
, file
);
4463 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4465 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4471 printf (_("\n The Directory Table is empty.\n"));
4474 unsigned int last_dir_entry
= 0;
4476 printf (_("\n The Directory Table (offset 0x%lx):\n"),
4477 (long)(data
- start
));
4479 while (data
< end
&& *data
!= 0)
4481 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4483 data
+= strnlen ((char *) data
, end
- data
);
4488 /* PR 17512: file: 002-132094-0.004. */
4489 if (data
>= end
- 1)
4493 /* Skip the NUL at the end of the table. */
4497 /* Display the contents of the File Name table. */
4498 if (data
>= end
|| *data
== 0)
4499 printf (_("\n The File Name Table is empty.\n"));
4502 printf (_("\n The File Name Table (offset 0x%lx):\n"),
4503 (long)(data
- start
));
4504 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4506 while (data
< end
&& *data
!= 0)
4508 unsigned char *name
;
4511 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4513 data
+= strnlen ((char *) data
, end
- data
);
4517 READ_ULEB (val
, data
, end
);
4518 printf ("%s\t", dwarf_vmatoa ("u", val
));
4519 READ_ULEB (val
, data
, end
);
4520 printf ("%s\t", dwarf_vmatoa ("u", val
));
4521 READ_ULEB (val
, data
, end
);
4522 printf ("%s\t", dwarf_vmatoa ("u", val
));
4523 printf ("%.*s\n", (int)(end
- name
), name
);
4527 warn (_("Corrupt file name table entry\n"));
4533 /* Skip the NUL at the end of the table. */
4539 saved_linfo
= linfo
;
4542 /* Now display the statements. */
4543 if (data
>= end_of_sequence
)
4544 printf (_(" No Line Number Statements.\n"));
4547 printf (_(" Line Number Statements:\n"));
4549 while (data
< end_of_sequence
)
4551 unsigned char op_code
;
4552 dwarf_signed_vma adv
;
4555 printf (" [0x%08lx]", (long)(data
- start
));
4559 if (op_code
>= linfo
.li_opcode_base
)
4561 op_code
-= linfo
.li_opcode_base
;
4562 uladv
= (op_code
/ linfo
.li_line_range
);
4563 if (linfo
.li_max_ops_per_insn
== 1)
4565 uladv
*= linfo
.li_min_insn_length
;
4566 state_machine_regs
.address
+= uladv
;
4568 state_machine_regs
.view
= 0;
4569 printf (_(" Special opcode %d: "
4570 "advance Address by %s to 0x%s%s"),
4571 op_code
, dwarf_vmatoa ("u", uladv
),
4572 dwarf_vmatoa ("x", state_machine_regs
.address
),
4573 verbose_view
&& uladv
4574 ? _(" (reset view)") : "");
4579 = ((state_machine_regs
.op_index
+ uladv
)
4580 / linfo
.li_max_ops_per_insn
)
4581 * linfo
.li_min_insn_length
;
4583 state_machine_regs
.address
+= addrdelta
;
4584 state_machine_regs
.op_index
4585 = (state_machine_regs
.op_index
+ uladv
)
4586 % linfo
.li_max_ops_per_insn
;
4588 state_machine_regs
.view
= 0;
4589 printf (_(" Special opcode %d: "
4590 "advance Address by %s to 0x%s[%d]%s"),
4591 op_code
, dwarf_vmatoa ("u", uladv
),
4592 dwarf_vmatoa ("x", state_machine_regs
.address
),
4593 state_machine_regs
.op_index
,
4594 verbose_view
&& addrdelta
4595 ? _(" (reset view)") : "");
4597 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4598 state_machine_regs
.line
+= adv
;
4599 printf (_(" and Line by %s to %d"),
4600 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4601 if (verbose_view
|| state_machine_regs
.view
)
4602 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4605 state_machine_regs
.view
++;
4610 case DW_LNS_extended_op
:
4611 data
+= process_extended_line_op (data
,
4612 linfo
.li_default_is_stmt
,
4617 printf (_(" Copy"));
4618 if (verbose_view
|| state_machine_regs
.view
)
4619 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4622 state_machine_regs
.view
++;
4625 case DW_LNS_advance_pc
:
4626 READ_ULEB (uladv
, data
, end
);
4627 if (linfo
.li_max_ops_per_insn
== 1)
4629 uladv
*= linfo
.li_min_insn_length
;
4630 state_machine_regs
.address
+= uladv
;
4632 state_machine_regs
.view
= 0;
4633 printf (_(" Advance PC by %s to 0x%s%s\n"),
4634 dwarf_vmatoa ("u", uladv
),
4635 dwarf_vmatoa ("x", state_machine_regs
.address
),
4636 verbose_view
&& uladv
4637 ? _(" (reset view)") : "");
4642 = ((state_machine_regs
.op_index
+ uladv
)
4643 / linfo
.li_max_ops_per_insn
)
4644 * linfo
.li_min_insn_length
;
4645 state_machine_regs
.address
4647 state_machine_regs
.op_index
4648 = (state_machine_regs
.op_index
+ uladv
)
4649 % linfo
.li_max_ops_per_insn
;
4651 state_machine_regs
.view
= 0;
4652 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4653 dwarf_vmatoa ("u", uladv
),
4654 dwarf_vmatoa ("x", state_machine_regs
.address
),
4655 state_machine_regs
.op_index
,
4656 verbose_view
&& addrdelta
4657 ? _(" (reset view)") : "");
4661 case DW_LNS_advance_line
:
4662 READ_SLEB (adv
, data
, end
);
4663 state_machine_regs
.line
+= adv
;
4664 printf (_(" Advance Line by %s to %d\n"),
4665 dwarf_vmatoa ("d", adv
),
4666 state_machine_regs
.line
);
4669 case DW_LNS_set_file
:
4670 READ_ULEB (uladv
, data
, end
);
4671 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4672 dwarf_vmatoa ("u", uladv
));
4673 state_machine_regs
.file
= uladv
;
4676 case DW_LNS_set_column
:
4677 READ_ULEB (uladv
, data
, end
);
4678 printf (_(" Set column to %s\n"),
4679 dwarf_vmatoa ("u", uladv
));
4680 state_machine_regs
.column
= uladv
;
4683 case DW_LNS_negate_stmt
:
4684 adv
= state_machine_regs
.is_stmt
;
4686 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4687 state_machine_regs
.is_stmt
= adv
;
4690 case DW_LNS_set_basic_block
:
4691 printf (_(" Set basic block\n"));
4692 state_machine_regs
.basic_block
= 1;
4695 case DW_LNS_const_add_pc
:
4696 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4697 if (linfo
.li_max_ops_per_insn
)
4699 uladv
*= linfo
.li_min_insn_length
;
4700 state_machine_regs
.address
+= uladv
;
4702 state_machine_regs
.view
= 0;
4703 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4704 dwarf_vmatoa ("u", uladv
),
4705 dwarf_vmatoa ("x", state_machine_regs
.address
),
4706 verbose_view
&& uladv
4707 ? _(" (reset view)") : "");
4712 = ((state_machine_regs
.op_index
+ uladv
)
4713 / linfo
.li_max_ops_per_insn
)
4714 * linfo
.li_min_insn_length
;
4715 state_machine_regs
.address
4717 state_machine_regs
.op_index
4718 = (state_machine_regs
.op_index
+ uladv
)
4719 % linfo
.li_max_ops_per_insn
;
4721 state_machine_regs
.view
= 0;
4722 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4723 dwarf_vmatoa ("u", uladv
),
4724 dwarf_vmatoa ("x", state_machine_regs
.address
),
4725 state_machine_regs
.op_index
,
4726 verbose_view
&& addrdelta
4727 ? _(" (reset view)") : "");
4731 case DW_LNS_fixed_advance_pc
:
4732 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4733 state_machine_regs
.address
+= uladv
;
4734 state_machine_regs
.op_index
= 0;
4735 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4736 dwarf_vmatoa ("u", uladv
),
4737 dwarf_vmatoa ("x", state_machine_regs
.address
));
4738 /* Do NOT reset view. */
4741 case DW_LNS_set_prologue_end
:
4742 printf (_(" Set prologue_end to true\n"));
4745 case DW_LNS_set_epilogue_begin
:
4746 printf (_(" Set epilogue_begin to true\n"));
4749 case DW_LNS_set_isa
:
4750 READ_ULEB (uladv
, data
, end
);
4751 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4755 printf (_(" Unknown opcode %d with operands: "), op_code
);
4757 if (standard_opcodes
!= NULL
)
4758 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4760 READ_ULEB (uladv
, data
, end
);
4761 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4762 i
== 1 ? "" : ", ");
4777 unsigned char *name
;
4778 unsigned int directory_index
;
4779 unsigned int modification_date
;
4780 unsigned int length
;
4783 /* Output a decoded representation of the .debug_line section. */
4786 display_debug_lines_decoded (struct dwarf_section
* section
,
4787 unsigned char * start
,
4788 unsigned char * data
,
4789 unsigned char * end
,
4792 static DWARF2_Internal_LineInfo saved_linfo
;
4794 introduce (section
, false);
4798 /* This loop amounts to one iteration per compilation unit. */
4799 DWARF2_Internal_LineInfo linfo
;
4800 unsigned char *standard_opcodes
;
4801 unsigned char *end_of_sequence
;
4803 File_Entry
*file_table
= NULL
;
4804 unsigned int n_files
= 0;
4805 unsigned char **directory_table
= NULL
;
4806 dwarf_vma n_directories
= 0;
4808 if (startswith (section
->name
, ".debug_line.")
4809 /* Note: the following does not apply to .debug_line.dwo sections.
4810 These are full debug_line sections. */
4811 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4813 /* See comment in display_debug_lines_raw(). */
4814 end_of_sequence
= end
;
4815 standard_opcodes
= NULL
;
4816 linfo
= saved_linfo
;
4817 /* PR 17531: file: 0522b371. */
4818 if (linfo
.li_line_range
== 0)
4820 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4823 reset_state_machine (linfo
.li_default_is_stmt
);
4827 unsigned char *hdrptr
;
4829 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4830 & end_of_sequence
)) == NULL
)
4833 /* PR 17531: file: 0522b371. */
4834 if (linfo
.li_line_range
== 0)
4836 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4837 linfo
.li_line_range
= 1;
4839 reset_state_machine (linfo
.li_default_is_stmt
);
4841 /* Save a pointer to the contents of the Opcodes table. */
4842 standard_opcodes
= hdrptr
;
4844 /* Traverse the Directory table just to count entries. */
4845 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4849 warn (_("opcode base of %d extends beyond end of section\n"),
4850 linfo
.li_opcode_base
);
4854 if (linfo
.li_version
>= 5)
4856 unsigned char *format_start
, format_count
, *format
;
4857 dwarf_vma formati
, entryi
;
4859 load_debug_section_with_follow (line_str
, fileptr
);
4861 /* Skip directories format. */
4862 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4863 if (do_checks
&& format_count
> 1)
4864 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4866 format_start
= data
;
4867 for (formati
= 0; formati
< format_count
; formati
++)
4869 SKIP_ULEB (data
, end
);
4870 SKIP_ULEB (data
, end
);
4873 READ_ULEB (n_directories
, data
, end
);
4876 warn (_("Corrupt directories list\n"));
4880 if (n_directories
== 0)
4881 directory_table
= NULL
;
4883 directory_table
= (unsigned char **)
4884 xmalloc (n_directories
* sizeof (unsigned char *));
4886 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4888 unsigned char **pathp
= &directory_table
[entryi
];
4890 format
= format_start
;
4891 for (formati
= 0; formati
< format_count
; formati
++)
4893 dwarf_vma content_type
, form
;
4896 READ_ULEB (content_type
, format
, end
);
4897 READ_ULEB (form
, format
, end
);
4900 warn (_("Corrupt directories list\n"));
4903 switch (content_type
)
4908 case DW_FORM_string
:
4911 case DW_FORM_line_strp
:
4912 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4914 /* Remove const by the cast. */
4915 *pathp
= (unsigned char *)
4916 fetch_indirect_line_string (uvalue
);
4921 data
= read_and_display_attr_value (0, form
, 0, start
,
4923 linfo
.li_offset_size
,
4930 warn (_("Corrupt directories list\n"));
4935 /* Skip files format. */
4936 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4937 if (do_checks
&& format_count
> 5)
4938 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
4940 format_start
= data
;
4941 for (formati
= 0; formati
< format_count
; formati
++)
4943 SKIP_ULEB (data
, end
);
4944 SKIP_ULEB (data
, end
);
4947 READ_ULEB (n_files
, data
, end
);
4948 if (data
>= end
&& n_files
> 0)
4950 warn (_("Corrupt file name list\n"));
4957 file_table
= (File_Entry
*) xcalloc (1, n_files
4958 * sizeof (File_Entry
));
4960 for (entryi
= 0; entryi
< n_files
; entryi
++)
4962 File_Entry
*file
= &file_table
[entryi
];
4964 format
= format_start
;
4965 for (formati
= 0; formati
< format_count
; formati
++)
4967 dwarf_vma content_type
, form
;
4971 READ_ULEB (content_type
, format
, end
);
4972 READ_ULEB (form
, format
, end
);
4975 warn (_("Corrupt file name list\n"));
4978 switch (content_type
)
4983 case DW_FORM_string
:
4986 case DW_FORM_line_strp
:
4987 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4989 /* Remove const by the cast. */
4990 file
->name
= (unsigned char *)
4991 fetch_indirect_line_string (uvalue
);
4995 case DW_LNCT_directory_index
:
4999 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
5003 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
5008 READ_ULEB (file
->directory_index
, tmp
, end
);
5013 data
= read_and_display_attr_value (0, form
, 0, start
,
5015 linfo
.li_offset_size
,
5022 warn (_("Corrupt file name list\n"));
5031 unsigned char *ptr_directory_table
= data
;
5033 while (data
< end
&& *data
!= 0)
5035 data
+= strnlen ((char *) data
, end
- data
);
5044 warn (_("directory table ends unexpectedly\n"));
5049 /* Go through the directory table again to save the directories. */
5050 directory_table
= (unsigned char **)
5051 xmalloc (n_directories
* sizeof (unsigned char *));
5054 while (*ptr_directory_table
!= 0)
5056 directory_table
[i
] = ptr_directory_table
;
5058 += strlen ((char *) ptr_directory_table
) + 1;
5062 /* Skip the NUL at the end of the table. */
5065 /* Traverse the File Name table just to count the entries. */
5066 if (data
< end
&& *data
!= 0)
5068 unsigned char *ptr_file_name_table
= data
;
5070 while (data
< end
&& *data
!= 0)
5072 /* Skip Name, directory index, last modification
5073 time and length of file. */
5074 data
+= strnlen ((char *) data
, end
- data
);
5077 SKIP_ULEB (data
, end
);
5078 SKIP_ULEB (data
, end
);
5079 SKIP_ULEB (data
, end
);
5085 warn (_("file table ends unexpectedly\n"));
5090 /* Go through the file table again to save the strings. */
5091 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
5094 while (*ptr_file_name_table
!= 0)
5096 file_table
[i
].name
= ptr_file_name_table
;
5098 += strlen ((char *) ptr_file_name_table
) + 1;
5100 /* We are not interested in directory, time or size. */
5101 READ_ULEB (file_table
[i
].directory_index
,
5102 ptr_file_name_table
, end
);
5103 READ_ULEB (file_table
[i
].modification_date
,
5104 ptr_file_name_table
, end
);
5105 READ_ULEB (file_table
[i
].length
,
5106 ptr_file_name_table
, end
);
5112 /* Skip the NUL at the end of the table. */
5116 /* Print the Compilation Unit's name and a header. */
5117 if (file_table
== NULL
)
5118 printf (_("CU: No directory table\n"));
5119 else if (directory_table
== NULL
)
5120 printf (_("CU: %s:\n"), file_table
[0].name
);
5123 unsigned int ix
= file_table
[0].directory_index
;
5124 const char *directory
;
5129 else if (n_directories
== 0)
5130 directory
= _("<unknown>");
5131 else if (ix
> n_directories
)
5133 warn (_("directory index %u > number of directories %s\n"),
5134 ix
, dwarf_vmatoa ("u", n_directories
));
5135 directory
= _("<corrupt>");
5138 directory
= (char *) directory_table
[ix
- 1];
5140 if (do_wide
|| strlen (directory
) < 76)
5141 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
5143 printf ("%s:\n", file_table
[0].name
);
5147 printf (_("File name Line number Starting address View Stmt\n"));
5149 printf (_("CU: Empty file name table\n"));
5150 saved_linfo
= linfo
;
5153 /* This loop iterates through the Dwarf Line Number Program. */
5154 while (data
< end_of_sequence
)
5156 unsigned char op_code
;
5159 unsigned long int uladv
;
5160 int is_special_opcode
= 0;
5165 if (op_code
>= linfo
.li_opcode_base
)
5167 op_code
-= linfo
.li_opcode_base
;
5168 uladv
= (op_code
/ linfo
.li_line_range
);
5169 if (linfo
.li_max_ops_per_insn
== 1)
5171 uladv
*= linfo
.li_min_insn_length
;
5172 state_machine_regs
.address
+= uladv
;
5174 state_machine_regs
.view
= 0;
5179 = ((state_machine_regs
.op_index
+ uladv
)
5180 / linfo
.li_max_ops_per_insn
)
5181 * linfo
.li_min_insn_length
;
5182 state_machine_regs
.address
5184 state_machine_regs
.op_index
5185 = (state_machine_regs
.op_index
+ uladv
)
5186 % linfo
.li_max_ops_per_insn
;
5188 state_machine_regs
.view
= 0;
5191 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
5192 state_machine_regs
.line
+= adv
;
5193 is_special_opcode
= 1;
5194 /* Increment view after printing this row. */
5199 case DW_LNS_extended_op
:
5201 unsigned int ext_op_code_len
;
5202 unsigned char ext_op_code
;
5203 unsigned char *op_code_end
;
5204 unsigned char *op_code_data
= data
;
5206 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
5207 op_code_end
= op_code_data
+ ext_op_code_len
;
5208 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
5210 warn (_("Badly formed extended line op encountered!\n"));
5213 ext_op_code
= *op_code_data
++;
5217 switch (ext_op_code
)
5219 case DW_LNE_end_sequence
:
5220 /* Reset stuff after printing this row. */
5222 case DW_LNE_set_address
:
5223 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
5225 op_code_end
- op_code_data
,
5227 state_machine_regs
.op_index
= 0;
5228 state_machine_regs
.view
= 0;
5230 case DW_LNE_define_file
:
5231 file_table
= (File_Entry
*) xrealloc
5232 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
5234 ++state_machine_regs
.last_file_entry
;
5235 /* Source file name. */
5236 file_table
[n_files
].name
= op_code_data
;
5237 op_code_data
+= strlen ((char *) op_code_data
) + 1;
5238 /* Directory index. */
5239 READ_ULEB (file_table
[n_files
].directory_index
,
5240 op_code_data
, op_code_end
);
5241 /* Last modification time. */
5242 READ_ULEB (file_table
[n_files
].modification_date
,
5243 op_code_data
, op_code_end
);
5245 READ_ULEB (file_table
[n_files
].length
,
5246 op_code_data
, op_code_end
);
5250 case DW_LNE_set_discriminator
:
5251 case DW_LNE_HP_set_sequence
:
5252 /* Simply ignored. */
5256 printf (_("UNKNOWN (%u): length %ld\n"),
5257 ext_op_code
, (long int) (op_code_data
- data
));
5264 /* Increment view after printing this row. */
5267 case DW_LNS_advance_pc
:
5268 READ_ULEB (uladv
, data
, end
);
5269 if (linfo
.li_max_ops_per_insn
== 1)
5271 uladv
*= linfo
.li_min_insn_length
;
5272 state_machine_regs
.address
+= uladv
;
5274 state_machine_regs
.view
= 0;
5279 = ((state_machine_regs
.op_index
+ uladv
)
5280 / linfo
.li_max_ops_per_insn
)
5281 * linfo
.li_min_insn_length
;
5282 state_machine_regs
.address
5284 state_machine_regs
.op_index
5285 = (state_machine_regs
.op_index
+ uladv
)
5286 % linfo
.li_max_ops_per_insn
;
5288 state_machine_regs
.view
= 0;
5292 case DW_LNS_advance_line
:
5293 READ_SLEB (adv
, data
, end
);
5294 state_machine_regs
.line
+= adv
;
5297 case DW_LNS_set_file
:
5298 READ_ULEB (uladv
, data
, end
);
5299 state_machine_regs
.file
= uladv
;
5302 unsigned file
= state_machine_regs
.file
- 1;
5305 if (file_table
== NULL
|| n_files
== 0)
5306 printf (_("\n [Use file table entry %d]\n"), file
);
5308 else if (file
>= n_files
)
5310 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
5311 printf (_("\n <over large file table index %u>"), file
);
5313 else if ((dir
= file_table
[file
].directory_index
) == 0)
5314 /* If directory index is 0, that means current directory. */
5315 printf ("\n./%s:[++]\n", file_table
[file
].name
);
5316 else if (directory_table
== NULL
|| n_directories
== 0)
5317 printf (_("\n [Use file %s in directory table entry %d]\n"),
5318 file_table
[file
].name
, dir
);
5320 else if (dir
> n_directories
)
5322 warn (_("directory index %u > number of directories %s\n"),
5323 dir
, dwarf_vmatoa ("u", n_directories
));
5324 printf (_("\n <over large directory table entry %u>\n"), dir
);
5327 printf ("\n%s/%s:\n",
5328 /* The directory index starts counting at 1. */
5329 directory_table
[dir
- 1], file_table
[file
].name
);
5333 case DW_LNS_set_column
:
5334 READ_ULEB (uladv
, data
, end
);
5335 state_machine_regs
.column
= uladv
;
5338 case DW_LNS_negate_stmt
:
5339 adv
= state_machine_regs
.is_stmt
;
5341 state_machine_regs
.is_stmt
= adv
;
5344 case DW_LNS_set_basic_block
:
5345 state_machine_regs
.basic_block
= 1;
5348 case DW_LNS_const_add_pc
:
5349 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5350 if (linfo
.li_max_ops_per_insn
== 1)
5352 uladv
*= linfo
.li_min_insn_length
;
5353 state_machine_regs
.address
+= uladv
;
5355 state_machine_regs
.view
= 0;
5360 = ((state_machine_regs
.op_index
+ uladv
)
5361 / linfo
.li_max_ops_per_insn
)
5362 * linfo
.li_min_insn_length
;
5363 state_machine_regs
.address
5365 state_machine_regs
.op_index
5366 = (state_machine_regs
.op_index
+ uladv
)
5367 % linfo
.li_max_ops_per_insn
;
5369 state_machine_regs
.view
= 0;
5373 case DW_LNS_fixed_advance_pc
:
5374 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5375 state_machine_regs
.address
+= uladv
;
5376 state_machine_regs
.op_index
= 0;
5377 /* Do NOT reset view. */
5380 case DW_LNS_set_prologue_end
:
5383 case DW_LNS_set_epilogue_begin
:
5386 case DW_LNS_set_isa
:
5387 READ_ULEB (uladv
, data
, end
);
5388 printf (_(" Set ISA to %lu\n"), uladv
);
5392 printf (_(" Unknown opcode %d with operands: "), op_code
);
5394 if (standard_opcodes
!= NULL
)
5395 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5399 READ_ULEB (val
, data
, end
);
5400 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
5401 i
== 1 ? "" : ", ");
5407 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5408 to the DWARF address/line matrix. */
5409 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5410 || (xop
== DW_LNS_copy
))
5412 const unsigned int MAX_FILENAME_LENGTH
= 35;
5414 char *newFileName
= NULL
;
5415 size_t fileNameLength
;
5419 unsigned indx
= state_machine_regs
.file
- 1;
5421 if (indx
>= n_files
)
5423 warn (_("corrupt file index %u encountered\n"), indx
);
5424 fileName
= _("<corrupt>");
5427 fileName
= (char *) file_table
[indx
].name
;
5430 fileName
= _("<unknown>");
5432 fileNameLength
= strlen (fileName
);
5433 newFileName
= fileName
;
5434 if (fileNameLength
> MAX_FILENAME_LENGTH
&& !do_wide
)
5436 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5437 /* Truncate file name */
5438 memcpy (newFileName
,
5439 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5440 MAX_FILENAME_LENGTH
);
5441 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5444 /* A row with end_seq set to true has a meaningful address, but
5445 the other information in the same row is not significant.
5446 In such a row, print line as "-", and don't print
5448 if (!do_wide
|| fileNameLength
<= MAX_FILENAME_LENGTH
)
5450 if (linfo
.li_max_ops_per_insn
== 1)
5452 if (xop
== -DW_LNE_end_sequence
)
5453 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x",
5455 state_machine_regs
.address
);
5457 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
5458 newFileName
, state_machine_regs
.line
,
5459 state_machine_regs
.address
);
5463 if (xop
== -DW_LNE_end_sequence
)
5464 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5466 state_machine_regs
.address
,
5467 state_machine_regs
.op_index
);
5469 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5470 newFileName
, state_machine_regs
.line
,
5471 state_machine_regs
.address
,
5472 state_machine_regs
.op_index
);
5477 if (linfo
.li_max_ops_per_insn
== 1)
5479 if (xop
== -DW_LNE_end_sequence
)
5480 printf ("%s %11s %#18" DWARF_VMA_FMT
"x",
5482 state_machine_regs
.address
);
5484 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5485 newFileName
, state_machine_regs
.line
,
5486 state_machine_regs
.address
);
5490 if (xop
== -DW_LNE_end_sequence
)
5491 printf ("%s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5493 state_machine_regs
.address
,
5494 state_machine_regs
.op_index
);
5496 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5497 newFileName
, state_machine_regs
.line
,
5498 state_machine_regs
.address
,
5499 state_machine_regs
.op_index
);
5503 if (xop
!= -DW_LNE_end_sequence
)
5505 if (state_machine_regs
.view
)
5506 printf (" %6u", state_machine_regs
.view
);
5510 if (state_machine_regs
.is_stmt
)
5515 state_machine_regs
.view
++;
5517 if (xop
== -DW_LNE_end_sequence
)
5519 reset_state_machine (linfo
.li_default_is_stmt
);
5523 if (newFileName
!= fileName
)
5535 if (directory_table
)
5537 free (directory_table
);
5538 directory_table
= NULL
;
5549 display_debug_lines (struct dwarf_section
*section
, void *file
)
5551 unsigned char *data
= section
->start
;
5552 unsigned char *end
= data
+ section
->size
;
5554 int retValDecoded
= 1;
5556 if (do_debug_lines
== 0)
5557 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5559 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5560 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5562 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5563 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5565 if (!retValRaw
|| !retValDecoded
)
5572 find_debug_info_for_offset (unsigned long offset
)
5576 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5579 for (i
= 0; i
< num_debug_info_entries
; i
++)
5580 if (debug_information
[i
].cu_offset
== offset
)
5581 return debug_information
+ i
;
5587 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5589 /* See gdb/gdb-index.h. */
5590 static const char * const kinds
[] =
5602 return _ (kinds
[kind
]);
5606 display_debug_pubnames_worker (struct dwarf_section
*section
,
5607 void *file ATTRIBUTE_UNUSED
,
5610 DWARF2_Internal_PubNames names
;
5611 unsigned char *start
= section
->start
;
5612 unsigned char *end
= start
+ section
->size
;
5614 /* It does not matter if this load fails,
5615 we test for that later on. */
5616 load_debug_info (file
);
5618 introduce (section
, false);
5622 unsigned char *data
;
5623 unsigned long sec_off
= start
- section
->start
;
5624 unsigned int offset_size
;
5626 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5627 if (names
.pn_length
== 0xffffffff)
5629 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5635 if (names
.pn_length
> (size_t) (end
- start
))
5637 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5640 dwarf_vmatoa ("x", names
.pn_length
));
5645 start
+= names
.pn_length
;
5647 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, start
);
5648 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, start
);
5650 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5651 && num_debug_info_entries
> 0
5652 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5653 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5654 (unsigned long) names
.pn_offset
, section
->name
);
5656 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, start
);
5658 printf (_(" Length: %ld\n"),
5659 (long) names
.pn_length
);
5660 printf (_(" Version: %d\n"),
5662 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5663 (unsigned long) names
.pn_offset
);
5664 printf (_(" Size of area in .debug_info section: %ld\n"),
5665 (long) names
.pn_size
);
5667 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5669 static int warned
= 0;
5673 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5681 printf (_("\n Offset Kind Name\n"));
5683 printf (_("\n Offset\tName\n"));
5687 bfd_size_type maxprint
;
5690 SAFE_BYTE_GET_AND_INC (offset
, data
, offset_size
, start
);
5697 maxprint
= (start
- data
) - 1;
5701 unsigned int kind_data
;
5702 gdb_index_symbol_kind kind
;
5703 const char *kind_name
;
5706 SAFE_BYTE_GET_AND_INC (kind_data
, data
, 1, start
);
5708 /* GCC computes the kind as the upper byte in the CU index
5709 word, and then right shifts it by the CU index size.
5710 Left shift KIND to where the gdb-index.h accessor macros
5712 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5713 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5714 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5715 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5716 printf (" %-6lx %s,%-10s %.*s\n",
5717 (unsigned long) offset
, is_static
? _("s") : _("g"),
5718 kind_name
, (int) maxprint
, data
);
5721 printf (" %-6lx\t%.*s\n",
5722 (unsigned long) offset
, (int) maxprint
, data
);
5724 data
+= strnlen ((char *) data
, maxprint
);
5737 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5739 return display_debug_pubnames_worker (section
, file
, 0);
5743 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5745 return display_debug_pubnames_worker (section
, file
, 1);
5749 display_debug_macinfo (struct dwarf_section
*section
,
5750 void *file ATTRIBUTE_UNUSED
)
5752 unsigned char *start
= section
->start
;
5753 unsigned char *end
= start
+ section
->size
;
5754 unsigned char *curr
= start
;
5755 enum dwarf_macinfo_record_type op
;
5757 introduce (section
, false);
5761 unsigned int lineno
;
5762 const unsigned char *string
;
5764 op
= (enum dwarf_macinfo_record_type
) *curr
;
5769 case DW_MACINFO_start_file
:
5771 unsigned int filenum
;
5773 READ_ULEB (lineno
, curr
, end
);
5774 READ_ULEB (filenum
, curr
, end
);
5775 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5780 case DW_MACINFO_end_file
:
5781 printf (_(" DW_MACINFO_end_file\n"));
5784 case DW_MACINFO_define
:
5785 READ_ULEB (lineno
, curr
, end
);
5787 curr
+= strnlen ((char *) string
, end
- string
);
5788 printf (_(" DW_MACINFO_define - lineno : %d macro : %*s\n"),
5789 lineno
, (int) (curr
- string
), string
);
5794 case DW_MACINFO_undef
:
5795 READ_ULEB (lineno
, curr
, end
);
5797 curr
+= strnlen ((char *) string
, end
- string
);
5798 printf (_(" DW_MACINFO_undef - lineno : %d macro : %*s\n"),
5799 lineno
, (int) (curr
- string
), string
);
5804 case DW_MACINFO_vendor_ext
:
5806 unsigned int constant
;
5808 READ_ULEB (constant
, curr
, end
);
5810 curr
+= strnlen ((char *) string
, end
- string
);
5811 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %*s\n"),
5812 constant
, (int) (curr
- string
), string
);
5823 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5824 filename and dirname corresponding to file name table entry with index
5825 FILEIDX. Return NULL on failure. */
5827 static unsigned char *
5828 get_line_filename_and_dirname (dwarf_vma line_offset
,
5830 unsigned char **dir_name
)
5832 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5833 unsigned char *hdrptr
, *dirtable
, *file_name
;
5834 unsigned int offset_size
;
5835 unsigned int version
, opcode_base
;
5836 dwarf_vma length
, diridx
;
5837 const unsigned char * end
;
5840 if (section
->start
== NULL
5841 || line_offset
>= section
->size
5845 hdrptr
= section
->start
+ line_offset
;
5846 end
= section
->start
+ section
->size
;
5848 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5849 if (length
== 0xffffffff)
5851 /* This section is 64-bit DWARF 3. */
5852 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5858 if (length
> (size_t) (end
- hdrptr
)
5859 || length
< 2 + offset_size
+ 1 + 3 + 1)
5861 end
= hdrptr
+ length
;
5863 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5864 if (version
!= 2 && version
!= 3 && version
!= 4)
5866 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5868 hdrptr
++; /* Skip max_ops_per_insn. */
5869 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5871 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5872 if (opcode_base
== 0
5873 || opcode_base
- 1 >= (size_t) (end
- hdrptr
))
5876 hdrptr
+= opcode_base
- 1;
5879 /* Skip over dirname table. */
5880 while (*hdrptr
!= '\0')
5882 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5888 hdrptr
++; /* Skip the NUL at the end of the table. */
5890 /* Now skip over preceding filename table entries. */
5891 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5893 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5896 SKIP_ULEB (hdrptr
, end
);
5897 SKIP_ULEB (hdrptr
, end
);
5898 SKIP_ULEB (hdrptr
, end
);
5900 if (hdrptr
>= end
|| *hdrptr
== '\0')
5904 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5909 READ_ULEB (diridx
, hdrptr
, end
);
5912 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5914 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
);
5918 if (dirtable
>= end
|| *dirtable
== '\0')
5920 *dir_name
= dirtable
;
5925 display_debug_macro (struct dwarf_section
*section
,
5928 unsigned char *start
= section
->start
;
5929 unsigned char *end
= start
+ section
->size
;
5930 unsigned char *curr
= start
;
5931 unsigned char *extended_op_buf
[256];
5932 bool is_dwo
= false;
5933 const char *suffix
= strrchr (section
->name
, '.');
5935 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
5938 load_debug_section_with_follow (str
, file
);
5939 load_debug_section_with_follow (line
, file
);
5940 load_debug_section_with_follow (str_index
, file
);
5942 introduce (section
, false);
5946 unsigned int lineno
, version
, flags
;
5947 unsigned int offset_size
;
5948 const unsigned char *string
;
5949 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5950 unsigned char **extended_ops
= NULL
;
5952 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5953 if (version
!= 4 && version
!= 5)
5955 error (_("Expected to find a version number of 4 or 5 in section %s but found %d instead\n"),
5956 section
->name
, version
);
5960 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5961 offset_size
= (flags
& 1) ? 8 : 4;
5962 printf (_(" Offset: 0x%lx\n"),
5963 (unsigned long) sec_offset
);
5964 printf (_(" Version: %d\n"), version
);
5965 printf (_(" Offset size: %d\n"), offset_size
);
5968 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5969 printf (_(" Offset into .debug_line: 0x%lx\n"),
5970 (unsigned long) line_offset
);
5974 unsigned int i
, count
, op
;
5977 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5979 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5980 extended_ops
= extended_op_buf
;
5983 printf (_(" Extension opcode arguments:\n"));
5984 for (i
= 0; i
< count
; i
++)
5986 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5987 extended_ops
[op
] = curr
;
5988 READ_ULEB (nargs
, curr
, end
);
5990 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5993 printf (_(" DW_MACRO_%02x arguments: "), op
);
5994 for (n
= 0; n
< nargs
; n
++)
5998 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5999 printf ("%s%s", get_FORM_name (form
),
6000 n
== nargs
- 1 ? "\n" : ", ");
6010 case DW_FORM_block1
:
6011 case DW_FORM_block2
:
6012 case DW_FORM_block4
:
6014 case DW_FORM_string
:
6016 case DW_FORM_sec_offset
:
6019 error (_("Invalid extension opcode form %s\n"),
6020 get_FORM_name (form
));
6036 error (_(".debug_macro section not zero terminated\n"));
6040 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6046 case DW_MACRO_define
:
6047 READ_ULEB (lineno
, curr
, end
);
6049 curr
+= strnlen ((char *) string
, end
- string
);
6050 printf (_(" DW_MACRO_define - lineno : %d macro : %*s\n"),
6051 lineno
, (int) (curr
- string
), string
);
6056 case DW_MACRO_undef
:
6057 READ_ULEB (lineno
, curr
, end
);
6059 curr
+= strnlen ((char *) string
, end
- string
);
6060 printf (_(" DW_MACRO_undef - lineno : %d macro : %*s\n"),
6061 lineno
, (int) (curr
- string
), string
);
6066 case DW_MACRO_start_file
:
6068 unsigned int filenum
;
6069 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6071 READ_ULEB (lineno
, curr
, end
);
6072 READ_ULEB (filenum
, curr
, end
);
6074 if ((flags
& 2) == 0)
6075 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6078 = get_line_filename_and_dirname (line_offset
, filenum
,
6080 if (file_name
== NULL
)
6081 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6084 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6086 dir_name
!= NULL
? (const char *) dir_name
: "",
6087 dir_name
!= NULL
? "/" : "", file_name
);
6091 case DW_MACRO_end_file
:
6092 printf (_(" DW_MACRO_end_file\n"));
6095 case DW_MACRO_define_strp
:
6096 READ_ULEB (lineno
, curr
, end
);
6097 if (version
== 4 && is_dwo
)
6098 READ_ULEB (offset
, curr
, end
);
6100 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6101 string
= fetch_indirect_string (offset
);
6102 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6106 case DW_MACRO_undef_strp
:
6107 READ_ULEB (lineno
, curr
, end
);
6108 if (version
== 4 && is_dwo
)
6109 READ_ULEB (offset
, curr
, end
);
6111 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6112 string
= fetch_indirect_string (offset
);
6113 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6117 case DW_MACRO_import
:
6118 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6119 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
6120 (unsigned long) offset
);
6123 case DW_MACRO_define_sup
:
6124 READ_ULEB (lineno
, curr
, end
);
6125 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6126 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
6127 lineno
, (unsigned long) offset
);
6130 case DW_MACRO_undef_sup
:
6131 READ_ULEB (lineno
, curr
, end
);
6132 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6133 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
6134 lineno
, (unsigned long) offset
);
6137 case DW_MACRO_import_sup
:
6138 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6139 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
6140 (unsigned long) offset
);
6143 case DW_MACRO_define_strx
:
6144 case DW_MACRO_undef_strx
:
6145 READ_ULEB (lineno
, curr
, end
);
6146 READ_ULEB (offset
, curr
, end
);
6147 string
= (const unsigned char *)
6148 fetch_indexed_string (offset
, NULL
, offset_size
, false);
6149 if (op
== DW_MACRO_define_strx
)
6150 printf (" DW_MACRO_define_strx ");
6152 printf (" DW_MACRO_undef_strx ");
6154 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
6155 printf (_("lineno : %d macro : %s\n"),
6160 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6162 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6166 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6168 error (_(" Unknown macro opcode %02x seen\n"), op
);
6173 /* Skip over unhandled opcodes. */
6175 unsigned char *desc
= extended_ops
[op
];
6176 READ_ULEB (nargs
, desc
, end
);
6179 printf (_(" DW_MACRO_%02x\n"), op
);
6182 printf (_(" DW_MACRO_%02x -"), op
);
6183 for (n
= 0; n
< nargs
; n
++)
6187 /* DW_FORM_implicit_const is not expected here. */
6188 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6190 = read_and_display_attr_value (0, val
, 0,
6191 start
, curr
, end
, 0, 0, offset_size
,
6192 version
, NULL
, 0, NULL
,
6210 display_debug_abbrev (struct dwarf_section
*section
,
6211 void *file ATTRIBUTE_UNUSED
)
6213 abbrev_entry
*entry
;
6214 unsigned char *start
= section
->start
;
6216 introduce (section
, false);
6223 offset
= start
- section
->start
;
6224 list
= find_abbrev_list_by_abbrev_offset (0, offset
);
6227 list
= new_abbrev_list (0, offset
);
6228 start
= process_abbrev_set (section
, 0, section
->size
, offset
, list
);
6229 list
->start_of_next_abbrevs
= start
;
6232 start
= list
->start_of_next_abbrevs
;
6234 if (list
->first_abbrev
== NULL
)
6237 printf (_(" Number TAG (0x%lx)\n"), (long) offset
);
6239 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6243 printf (" %ld %s [%s]\n",
6245 get_TAG_name (entry
->tag
),
6246 entry
->children
? _("has children") : _("no children"));
6248 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6250 printf (" %-18s %s",
6251 get_AT_name (attr
->attribute
),
6252 get_FORM_name (attr
->form
));
6253 if (attr
->form
== DW_FORM_implicit_const
)
6254 printf (": %s", dwarf_vmatoa ("d", attr
->implicit_const
));
6266 /* Return true when ADDR is the maximum address, when addresses are
6267 POINTER_SIZE bytes long. */
6270 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
6272 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
6273 return ((addr
& mask
) == mask
);
6276 /* Display a view pair list starting at *VSTART_PTR and ending at
6277 VLISTEND within SECTION. */
6280 display_view_pair_list (struct dwarf_section
*section
,
6281 unsigned char **vstart_ptr
,
6282 unsigned int debug_info_entry
,
6283 unsigned char *vlistend
)
6285 unsigned char *vstart
= *vstart_ptr
;
6286 unsigned char *section_end
= section
->start
+ section
->size
;
6287 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6289 if (vlistend
< section_end
)
6290 section_end
= vlistend
;
6294 while (vstart
< section_end
)
6296 dwarf_vma off
= vstart
- section
->start
;
6297 dwarf_vma vbegin
, vend
;
6299 READ_ULEB (vbegin
, vstart
, section_end
);
6300 if (vstart
== section_end
)
6303 READ_ULEB (vend
, vstart
, section_end
);
6304 printf (" %8.8lx ", (unsigned long) off
);
6306 print_dwarf_view (vbegin
, pointer_size
, 1);
6307 print_dwarf_view (vend
, pointer_size
, 1);
6308 printf (_("location view pair\n"));
6312 *vstart_ptr
= vstart
;
6315 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6318 display_loc_list (struct dwarf_section
*section
,
6319 unsigned char **start_ptr
,
6320 unsigned int debug_info_entry
,
6322 dwarf_vma base_address
,
6323 unsigned char **vstart_ptr
,
6326 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6327 unsigned char *section_end
= section
->start
+ section
->size
;
6328 unsigned long cu_offset
;
6329 unsigned int pointer_size
;
6330 unsigned int offset_size
;
6335 unsigned short length
;
6336 int need_frame_base
;
6338 if (debug_info_entry
>= num_debug_info_entries
)
6340 warn (_("No debug information available for loc lists of entry: %u\n"),
6345 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6346 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6347 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6348 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6350 if (pointer_size
< 2 || pointer_size
> 8)
6352 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6353 pointer_size
, debug_info_entry
);
6359 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6360 dwarf_vma vbegin
= vm1
, vend
= vm1
;
6362 if (2 * pointer_size
> (size_t) (section_end
- start
))
6364 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6365 (unsigned long) offset
);
6369 printf (" %8.8lx ", (unsigned long) off
);
6371 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6372 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6374 if (begin
== 0 && end
== 0)
6376 /* PR 18374: In a object file we can have a location list that
6377 starts with a begin and end of 0 because there are relocations
6378 that need to be applied to the addresses. Actually applying
6379 the relocations now does not help as they will probably resolve
6380 to 0, since the object file has not been fully linked. Real
6381 end of list markers will not have any relocations against them. */
6382 if (! reloc_at (section
, off
)
6383 && ! reloc_at (section
, off
+ pointer_size
))
6385 printf (_("<End of list>\n"));
6390 /* Check base address specifiers. */
6391 if (is_max_address (begin
, pointer_size
)
6392 && !is_max_address (end
, pointer_size
))
6395 print_dwarf_vma (begin
, pointer_size
);
6396 print_dwarf_vma (end
, pointer_size
);
6397 printf (_("(base address)\n"));
6403 off
= offset
+ (vstart
- *start_ptr
);
6405 READ_ULEB (vbegin
, vstart
, section_end
);
6406 print_dwarf_view (vbegin
, pointer_size
, 1);
6408 READ_ULEB (vend
, vstart
, section_end
);
6409 print_dwarf_view (vend
, pointer_size
, 1);
6411 printf (_("views at %8.8lx for:\n %*s "),
6412 (unsigned long) off
, 8, "");
6415 if (2 > (size_t) (section_end
- start
))
6417 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6418 (unsigned long) offset
);
6422 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6424 if (length
> (size_t) (section_end
- start
))
6426 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6427 (unsigned long) offset
);
6431 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6432 print_dwarf_vma (end
+ base_address
, pointer_size
);
6435 need_frame_base
= decode_location_expression (start
,
6440 cu_offset
, section
);
6443 if (need_frame_base
&& !has_frame_base
)
6444 printf (_(" [without DW_AT_frame_base]"));
6446 if (begin
== end
&& vbegin
== vend
)
6447 fputs (_(" (start == end)"), stdout
);
6448 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6449 fputs (_(" (start > end)"), stdout
);
6457 *vstart_ptr
= vstart
;
6460 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6463 display_loclists_list (struct dwarf_section
*section
,
6464 unsigned char **start_ptr
,
6465 unsigned int debug_info_entry
,
6467 dwarf_vma base_address
,
6468 unsigned char **vstart_ptr
,
6471 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6472 unsigned char *section_end
= section
->start
+ section
->size
;
6473 unsigned long cu_offset
;
6474 unsigned int pointer_size
;
6475 unsigned int offset_size
;
6478 /* Initialize it due to a false compiler warning. */
6479 dwarf_vma begin
= -1, vbegin
= -1;
6480 dwarf_vma end
= -1, vend
= -1;
6482 int need_frame_base
;
6484 if (debug_info_entry
>= num_debug_info_entries
)
6486 warn (_("No debug information available for "
6487 "loclists lists of entry: %u\n"),
6492 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6493 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6494 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6495 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6497 if (pointer_size
< 2 || pointer_size
> 8)
6499 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6500 pointer_size
, debug_info_entry
);
6506 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6507 enum dwarf_location_list_entry_type llet
;
6509 if (start
+ 1 > section_end
)
6511 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6512 (unsigned long) offset
);
6516 printf (" %8.8lx ", (unsigned long) off
);
6518 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6520 if (vstart
&& (llet
== DW_LLE_offset_pair
6521 || llet
== DW_LLE_start_end
6522 || llet
== DW_LLE_start_length
))
6524 off
= offset
+ (vstart
- *start_ptr
);
6526 READ_ULEB (vbegin
, vstart
, section_end
);
6527 print_dwarf_view (vbegin
, pointer_size
, 1);
6529 READ_ULEB (vend
, vstart
, section_end
);
6530 print_dwarf_view (vend
, pointer_size
, 1);
6532 printf (_("views at %8.8lx for:\n %*s "),
6533 (unsigned long) off
, 8, "");
6538 case DW_LLE_end_of_list
:
6539 printf (_("<End of list>\n"));
6541 case DW_LLE_offset_pair
:
6542 READ_ULEB (begin
, start
, section_end
);
6543 begin
+= base_address
;
6544 READ_ULEB (end
, start
, section_end
);
6545 end
+= base_address
;
6547 case DW_LLE_start_end
:
6548 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6549 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6551 case DW_LLE_start_length
:
6552 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6553 READ_ULEB (end
, start
, section_end
);
6556 case DW_LLE_base_address
:
6557 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6559 print_dwarf_vma (base_address
, pointer_size
);
6560 printf (_("(base address)\n"));
6562 #ifdef DW_LLE_view_pair
6563 case DW_LLE_view_pair
:
6565 printf (_("View pair entry in loclist with locviews attribute\n"));
6566 READ_ULEB (vbegin
, start
, section_end
);
6567 print_dwarf_view (vbegin
, pointer_size
, 1);
6569 READ_ULEB (vend
, start
, section_end
);
6570 print_dwarf_view (vend
, pointer_size
, 1);
6572 printf (_("views for:\n"));
6576 error (_("Invalid location list entry type %d\n"), llet
);
6579 if (llet
== DW_LLE_end_of_list
)
6581 if (llet
!= DW_LLE_offset_pair
6582 && llet
!= DW_LLE_start_end
6583 && llet
!= DW_LLE_start_length
)
6586 if (start
== section_end
)
6588 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6589 (unsigned long) offset
);
6592 READ_ULEB (length
, start
, section_end
);
6594 if (length
> (size_t) (section_end
- start
))
6596 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6597 (unsigned long) offset
);
6601 print_dwarf_vma (begin
, pointer_size
);
6602 print_dwarf_vma (end
, pointer_size
);
6605 need_frame_base
= decode_location_expression (start
,
6610 cu_offset
, section
);
6613 if (need_frame_base
&& !has_frame_base
)
6614 printf (_(" [without DW_AT_frame_base]"));
6616 if (begin
== end
&& vbegin
== vend
)
6617 fputs (_(" (start == end)"), stdout
);
6618 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6619 fputs (_(" (start > end)"), stdout
);
6627 if (vbegin
!= vm1
|| vend
!= vm1
)
6628 printf (_("Trailing view pair not used in a range"));
6631 *vstart_ptr
= vstart
;
6634 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6635 right-adjusted in a field of length LEN, and followed by a space. */
6638 print_addr_index (unsigned int idx
, unsigned int len
)
6640 static char buf
[15];
6641 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6642 printf ("%*s ", len
, buf
);
6645 /* Display a location list from a .dwo section. It uses address indexes rather
6646 than embedded addresses. This code closely follows display_loc_list, but the
6647 two are sufficiently different that combining things is very ugly. */
6650 display_loc_list_dwo (struct dwarf_section
*section
,
6651 unsigned char **start_ptr
,
6652 unsigned int debug_info_entry
,
6654 unsigned char **vstart_ptr
,
6657 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6658 unsigned char *section_end
= section
->start
+ section
->size
;
6659 unsigned long cu_offset
;
6660 unsigned int pointer_size
;
6661 unsigned int offset_size
;
6664 unsigned short length
;
6665 int need_frame_base
;
6668 if (debug_info_entry
>= num_debug_info_entries
)
6670 warn (_("No debug information for loc lists of entry: %u\n"),
6675 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6676 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6677 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6678 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6680 if (pointer_size
< 2 || pointer_size
> 8)
6682 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6683 pointer_size
, debug_info_entry
);
6689 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6691 if (start
>= section_end
)
6693 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6694 (unsigned long) offset
);
6698 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6711 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6713 READ_ULEB (view
, vstart
, section_end
);
6714 print_dwarf_view (view
, 8, 1);
6716 READ_ULEB (view
, vstart
, section_end
);
6717 print_dwarf_view (view
, 8, 1);
6719 printf (_("views at %8.8lx for:\n %*s "),
6720 (unsigned long) off
, 8, "");
6728 case 0: /* A terminating entry. */
6730 *vstart_ptr
= vstart
;
6731 printf (_("<End of list>\n"));
6733 case 1: /* A base-address entry. */
6734 READ_ULEB (idx
, start
, section_end
);
6735 print_addr_index (idx
, 8);
6736 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6737 printf (_("(base address selection entry)\n"));
6739 case 2: /* A start/end entry. */
6740 READ_ULEB (idx
, start
, section_end
);
6741 print_addr_index (idx
, 8);
6742 READ_ULEB (idx
, start
, section_end
);
6743 print_addr_index (idx
, 8);
6745 case 3: /* A start/length entry. */
6746 READ_ULEB (idx
, start
, section_end
);
6747 print_addr_index (idx
, 8);
6748 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6749 printf ("%08x ", idx
);
6751 case 4: /* An offset pair entry. */
6752 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6753 printf ("%08x ", idx
);
6754 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6755 printf ("%08x ", idx
);
6758 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6760 *vstart_ptr
= vstart
;
6764 if (2 > (size_t) (section_end
- start
))
6766 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6767 (unsigned long) offset
);
6771 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6772 if (length
> (size_t) (section_end
- start
))
6774 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6775 (unsigned long) offset
);
6780 need_frame_base
= decode_location_expression (start
,
6785 cu_offset
, section
);
6788 if (need_frame_base
&& !has_frame_base
)
6789 printf (_(" [without DW_AT_frame_base]"));
6797 *vstart_ptr
= vstart
;
6800 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6803 static dwarf_vma
*loc_offsets
, *loc_views
;
6806 loc_offsets_compar (const void *ap
, const void *bp
)
6808 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6809 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6811 int ret
= (a
> b
) - (b
> a
);
6815 a
= loc_views
[*(const unsigned int *) ap
];
6816 b
= loc_views
[*(const unsigned int *) bp
];
6818 ret
= (a
> b
) - (b
> a
);
6824 display_debug_loc (struct dwarf_section
*section
, void *file
)
6826 unsigned char *start
= section
->start
, *vstart
= NULL
;
6827 unsigned long bytes
;
6828 unsigned char *section_begin
= start
;
6829 unsigned int num_loc_list
= 0;
6830 unsigned long last_offset
= 0;
6831 unsigned long last_view
= 0;
6832 unsigned int first
= 0;
6835 int seen_first_offset
= 0;
6836 int locs_sorted
= 1;
6837 unsigned char *next
= start
, *vnext
= vstart
;
6838 unsigned int *array
= NULL
;
6839 const char *suffix
= strrchr (section
->name
, '.');
6840 bool is_dwo
= false;
6841 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6842 dwarf_vma expected_start
= 0;
6844 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6847 bytes
= section
->size
;
6851 printf (_("\nThe %s section is empty.\n"), section
->name
);
6857 unsigned char *hdrptr
= section_begin
;
6858 dwarf_vma ll_length
;
6859 unsigned short ll_version
;
6860 unsigned char *end
= section_begin
+ section
->size
;
6861 unsigned char address_size
, segment_selector_size
;
6862 uint32_t offset_entry_count
;
6864 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6865 if (ll_length
== 0xffffffff)
6866 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6868 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6869 if (ll_version
!= 5)
6871 warn (_("The %s section contains corrupt or "
6872 "unsupported version number: %d.\n"),
6873 section
->name
, ll_version
);
6877 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6879 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6880 if (segment_selector_size
!= 0)
6882 warn (_("The %s section contains "
6883 "unsupported segment selector size: %d.\n"),
6884 section
->name
, segment_selector_size
);
6888 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6889 if (offset_entry_count
!= 0)
6891 warn (_("The %s section contains "
6892 "unsupported offset entry count: %d.\n"),
6893 section
->name
, offset_entry_count
);
6897 expected_start
= hdrptr
- section_begin
;
6900 if (load_debug_info (file
) == 0)
6902 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6907 /* Check the order of location list in .debug_info section. If
6908 offsets of location lists are in the ascending order, we can
6909 use `debug_information' directly. */
6910 for (i
= 0; i
< num_debug_info_entries
; i
++)
6914 num
= debug_information
[i
].num_loc_offsets
;
6915 if (num
> num_loc_list
)
6918 /* Check if we can use `debug_information' directly. */
6919 if (locs_sorted
&& num
!= 0)
6921 if (!seen_first_offset
)
6923 /* This is the first location list. */
6924 last_offset
= debug_information
[i
].loc_offsets
[0];
6925 last_view
= debug_information
[i
].loc_views
[0];
6927 seen_first_offset
= 1;
6933 for (; j
< num
; j
++)
6936 debug_information
[i
].loc_offsets
[j
]
6937 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6938 && last_view
> debug_information
[i
].loc_views
[j
]))
6943 last_offset
= debug_information
[i
].loc_offsets
[j
];
6944 last_view
= debug_information
[i
].loc_views
[j
];
6949 if (!seen_first_offset
)
6950 error (_("No location lists in .debug_info section!\n"));
6952 if (debug_information
[first
].num_loc_offsets
> 0
6953 && debug_information
[first
].loc_offsets
[0] != expected_start
6954 && debug_information
[first
].loc_views
[0] != expected_start
)
6955 warn (_("Location lists in %s section start at 0x%s\n"),
6957 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6960 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6962 introduce (section
, false);
6964 if (reloc_at (section
, 0))
6965 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6967 printf (_(" Offset Begin End Expression\n"));
6969 seen_first_offset
= 0;
6970 for (i
= first
; i
< num_debug_info_entries
; i
++)
6972 dwarf_vma offset
, voffset
;
6973 dwarf_vma base_address
;
6979 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6981 loc_offsets
= debug_information
[i
].loc_offsets
;
6982 loc_views
= debug_information
[i
].loc_views
;
6983 qsort (array
, debug_information
[i
].num_loc_offsets
,
6984 sizeof (*array
), loc_offsets_compar
);
6987 int adjacent_view_loclists
= 1;
6988 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6990 j
= locs_sorted
? k
: array
[k
];
6992 && (debug_information
[i
].loc_offsets
[locs_sorted
6993 ? k
- 1 : array
[k
- 1]]
6994 == debug_information
[i
].loc_offsets
[j
])
6995 && (debug_information
[i
].loc_views
[locs_sorted
6996 ? k
- 1 : array
[k
- 1]]
6997 == debug_information
[i
].loc_views
[j
]))
6999 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
7000 offset
= debug_information
[i
].loc_offsets
[j
];
7001 next
= section_begin
+ offset
;
7002 voffset
= debug_information
[i
].loc_views
[j
];
7004 vnext
= section_begin
+ voffset
;
7007 base_address
= debug_information
[i
].base_address
;
7009 if (vnext
&& vnext
< next
)
7012 display_view_pair_list (section
, &vstart
, i
, next
);
7017 if (!seen_first_offset
|| !adjacent_view_loclists
)
7018 seen_first_offset
= 1;
7022 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
7023 (unsigned long) (start
- section_begin
),
7024 (unsigned long) offset
);
7025 else if (start
> next
)
7026 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
7027 (unsigned long) (start
- section_begin
),
7028 (unsigned long) offset
);
7033 if (offset
>= bytes
)
7035 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
7036 (unsigned long) offset
);
7040 if (vnext
&& voffset
>= bytes
)
7042 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
7043 (unsigned long) voffset
);
7050 display_loc_list_dwo (section
, &start
, i
, offset
,
7051 &vstart
, has_frame_base
);
7053 display_loc_list (section
, &start
, i
, offset
, base_address
,
7054 &vstart
, has_frame_base
);
7059 warn (_("DWO is not yet supported.\n"));
7061 display_loclists_list (section
, &start
, i
, offset
, base_address
,
7062 &vstart
, has_frame_base
);
7065 /* FIXME: this arrangement is quite simplistic. Nothing
7066 requires locview lists to be adjacent to corresponding
7067 loclists, and a single loclist could be augmented by
7068 different locview lists, and vice-versa, unlikely as it
7069 is that it would make sense to do so. Hopefully we'll
7070 have view pair support built into loclists before we ever
7071 need to address all these possibilities. */
7072 if (adjacent_view_loclists
&& vnext
7073 && vnext
!= start
&& vstart
!= next
)
7075 adjacent_view_loclists
= 0;
7076 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7079 if (vnext
&& vnext
== start
)
7080 display_view_pair_list (section
, &start
, i
, vstart
);
7084 if (start
< section
->start
+ section
->size
)
7085 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7086 "There are %ld unused bytes at the end of section %s\n",
7087 (long) (section
->start
+ section
->size
- start
)),
7088 (long) (section
->start
+ section
->size
- start
), section
->name
);
7095 display_debug_str (struct dwarf_section
*section
,
7096 void *file ATTRIBUTE_UNUSED
)
7098 unsigned char *start
= section
->start
;
7099 unsigned long bytes
= section
->size
;
7100 dwarf_vma addr
= section
->address
;
7104 printf (_("\nThe %s section is empty.\n"), section
->name
);
7108 introduce (section
, false);
7116 lbytes
= (bytes
> 16 ? 16 : bytes
);
7118 printf (" 0x%8.8lx ", (unsigned long) addr
);
7120 for (j
= 0; j
< 16; j
++)
7123 printf ("%2.2x", start
[j
]);
7131 for (j
= 0; j
< lbytes
; j
++)
7134 if (k
>= ' ' && k
< 0x80)
7153 display_debug_info (struct dwarf_section
*section
, void *file
)
7155 return process_debug_info (section
, file
, section
->abbrev_sec
, false, false);
7159 display_debug_types (struct dwarf_section
*section
, void *file
)
7161 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7165 display_trace_info (struct dwarf_section
*section
, void *file
)
7167 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7171 display_debug_aranges (struct dwarf_section
*section
,
7172 void *file ATTRIBUTE_UNUSED
)
7174 unsigned char *start
= section
->start
;
7175 unsigned char *end
= start
+ section
->size
;
7177 introduce (section
, false);
7179 /* It does not matter if this load fails,
7180 we test for that later on. */
7181 load_debug_info (file
);
7185 unsigned char *hdrptr
;
7186 DWARF2_Internal_ARange arange
;
7187 unsigned char *addr_ranges
;
7190 unsigned long sec_off
;
7191 unsigned char address_size
;
7193 unsigned int offset_size
;
7194 unsigned char *end_ranges
;
7197 sec_off
= hdrptr
- section
->start
;
7199 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7200 if (arange
.ar_length
== 0xffffffff)
7202 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7208 if (arange
.ar_length
> (size_t) (end
- hdrptr
))
7210 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
7213 dwarf_vmatoa ("x", arange
.ar_length
));
7216 end_ranges
= hdrptr
+ arange
.ar_length
;
7218 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end_ranges
);
7219 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
,
7222 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7223 && num_debug_info_entries
> 0
7224 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7225 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
7226 (unsigned long) arange
.ar_info_offset
, section
->name
);
7228 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end_ranges
);
7229 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end_ranges
);
7231 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7233 /* PR 19872: A version number of 0 probably means that there is
7234 padding at the end of the .debug_aranges section. Gold puts
7235 it there when performing an incremental link, for example.
7236 So do not generate a warning in this case. */
7237 if (arange
.ar_version
)
7238 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7242 printf (_(" Length: %ld\n"),
7243 (long) arange
.ar_length
);
7244 printf (_(" Version: %d\n"), arange
.ar_version
);
7245 printf (_(" Offset into .debug_info: 0x%lx\n"),
7246 (unsigned long) arange
.ar_info_offset
);
7247 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7248 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7250 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7252 /* PR 17512: file: 001-108546-0.001:0.1. */
7253 if (address_size
== 0 || address_size
> 8)
7255 error (_("Invalid address size in %s section!\n"),
7260 /* The DWARF spec does not require that the address size be a power
7261 of two, but we do. This will have to change if we ever encounter
7262 an uneven architecture. */
7263 if ((address_size
& (address_size
- 1)) != 0)
7265 warn (_("Pointer size + Segment size is not a power of two.\n"));
7269 if (address_size
> 4)
7270 printf (_("\n Address Length\n"));
7272 printf (_("\n Address Length\n"));
7274 addr_ranges
= hdrptr
;
7276 /* Must pad to an alignment boundary that is twice the address size. */
7277 excess
= (hdrptr
- start
) % (2 * address_size
);
7279 addr_ranges
+= (2 * address_size
) - excess
;
7283 while (2u * address_size
<= (size_t) (start
- addr_ranges
))
7285 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, start
);
7286 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, start
);
7289 print_dwarf_vma (address
, address_size
);
7290 print_dwarf_vma (length
, address_size
);
7300 /* Comparison function for qsort. */
7302 comp_addr_base (const void * v0
, const void * v1
)
7304 debug_info
*info0
= *(debug_info
**) v0
;
7305 debug_info
*info1
= *(debug_info
**) v1
;
7306 return info0
->addr_base
- info1
->addr_base
;
7309 /* Display the debug_addr section. */
7311 display_debug_addr (struct dwarf_section
*section
,
7314 debug_info
**debug_addr_info
;
7315 unsigned char *entry
;
7319 unsigned char * header
;
7321 if (section
->size
== 0)
7323 printf (_("\nThe %s section is empty.\n"), section
->name
);
7327 if (load_debug_info (file
) == 0)
7329 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7334 introduce (section
, false);
7336 /* PR 17531: file: cf38d01b.
7337 We use xcalloc because a corrupt file may not have initialised all of the
7338 fields in the debug_info structure, which means that the sort below might
7339 try to move uninitialised data. */
7340 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7341 sizeof (debug_info
*));
7344 for (i
= 0; i
< num_debug_info_entries
; i
++)
7345 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7347 /* PR 17531: file: cf38d01b. */
7348 if (debug_information
[i
].addr_base
>= section
->size
)
7349 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
7350 (unsigned long) debug_information
[i
].addr_base
, i
);
7352 debug_addr_info
[count
++] = debug_information
+ i
;
7355 /* Add a sentinel to make iteration convenient. */
7356 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7357 debug_addr_info
[count
]->addr_base
= section
->size
;
7358 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7360 header
= section
->start
;
7361 for (i
= 0; i
< count
; i
++)
7364 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7366 printf (_(" For compilation unit at offset 0x%s:\n"),
7367 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
7369 printf (_("\tIndex\tAddress\n"));
7370 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7371 if (debug_addr_info
[i
]->dwarf_version
>= 5)
7373 size_t header_size
= entry
- header
;
7374 unsigned char * curr_header
= header
;
7377 int segment_selector_size
;
7379 if (header_size
!= 8 && header_size
!= 16)
7381 warn (_("Corrupt %s section: expecting header size of 8 or 16, but found %ld instead\n"),
7382 section
->name
, (long) header_size
);
7386 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 4, entry
);
7387 if (length
== 0xffffffff)
7388 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 8, entry
);
7389 end
= curr_header
+ length
;
7391 SAFE_BYTE_GET_AND_INC (version
, curr_header
, 2, entry
);
7393 warn (_("Corrupt %s section: expecting version number 5 in header but found %d instead\n"),
7394 section
->name
, version
);
7396 SAFE_BYTE_GET_AND_INC (address_size
, curr_header
, 1, entry
);
7397 SAFE_BYTE_GET_AND_INC (segment_selector_size
, curr_header
, 1, entry
);
7398 address_size
+= segment_selector_size
;
7401 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7406 dwarf_vma base
= byte_get (entry
, address_size
);
7407 printf (_("\t%d:\t"), idx
);
7408 print_dwarf_vma (base
, address_size
);
7410 entry
+= address_size
;
7416 free (debug_addr_info
);
7420 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7423 display_debug_str_offsets (struct dwarf_section
*section
,
7424 void *file ATTRIBUTE_UNUSED
)
7428 if (section
->size
== 0)
7430 printf (_("\nThe %s section is empty.\n"), section
->name
);
7434 unsigned char *start
= section
->start
;
7435 unsigned char *end
= start
+ section
->size
;
7436 unsigned char *curr
= start
;
7438 const char *suffix
= strrchr (section
->name
, '.');
7439 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
7442 load_debug_section_with_follow (str_dwo
, file
);
7444 load_debug_section_with_follow (str
, file
);
7446 introduce (section
, false);
7451 dwarf_vma entry_length
;
7453 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7454 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7455 if (length
== 0xffffffff)
7457 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
7463 unsigned char *entries_end
;
7466 /* This is probably an old style .debug_str_offset section which
7467 just contains offsets and no header (and the first offset is 0). */
7468 length
= section
->size
;
7469 curr
= section
->start
;
7472 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7473 printf (_(" Index Offset [String]\n"));
7477 if (length
<= (dwarf_vma
) (end
- curr
))
7478 entries_end
= curr
+ length
;
7481 warn (_("Section %s is too small %#lx\n"),
7482 section
->name
, (unsigned long) section
->size
);
7487 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, entries_end
);
7489 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7492 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, entries_end
);
7494 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
7496 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7497 printf (_(" Version: %#lx\n"), (unsigned long) version
);
7498 printf (_(" Index Offset [String]\n"));
7501 for (idx
= 0; curr
< entries_end
; idx
++)
7504 const unsigned char * string
;
7506 if ((dwarf_vma
) (entries_end
- curr
) < entry_length
)
7507 /* Not enough space to read one entry_length, give up. */
7510 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, entries_end
);
7512 string
= (const unsigned char *)
7513 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
7515 string
= fetch_indirect_string (offset
);
7517 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
7525 /* Each debug_information[x].range_lists[y] gets this representation for
7526 sorting purposes. */
7530 /* The debug_information[x].range_lists[y] value. */
7531 dwarf_vma ranges_offset
;
7533 /* Original debug_information to find parameters of the data. */
7534 debug_info
*debug_info_p
;
7537 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7540 range_entry_compar (const void *ap
, const void *bp
)
7542 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7543 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7544 const dwarf_vma a
= a_re
->ranges_offset
;
7545 const dwarf_vma b
= b_re
->ranges_offset
;
7547 return (a
> b
) - (b
> a
);
7551 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
7552 unsigned int pointer_size
, unsigned long offset
,
7553 unsigned long base_address
)
7555 while (start
< finish
)
7560 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7561 if (start
>= finish
)
7563 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7565 printf (" %8.8lx ", offset
);
7567 if (begin
== 0 && end
== 0)
7569 printf (_("<End of list>\n"));
7573 /* Check base address specifiers. */
7574 if (is_max_address (begin
, pointer_size
)
7575 && !is_max_address (end
, pointer_size
))
7578 print_dwarf_vma (begin
, pointer_size
);
7579 print_dwarf_vma (end
, pointer_size
);
7580 printf ("(base address)\n");
7584 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7585 print_dwarf_vma (end
+ base_address
, pointer_size
);
7588 fputs (_("(start == end)"), stdout
);
7589 else if (begin
> end
)
7590 fputs (_("(start > end)"), stdout
);
7597 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7598 unsigned int pointer_size
, unsigned long offset
,
7599 unsigned long base_address
)
7601 unsigned char *next
= start
;
7605 unsigned long off
= offset
+ (start
- next
);
7606 enum dwarf_range_list_entry rlet
;
7607 /* Initialize it due to a false compiler warning. */
7608 dwarf_vma begin
= -1, length
, end
= -1;
7610 if (start
>= finish
)
7612 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7617 printf (" %8.8lx ", off
);
7619 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7623 case DW_RLE_end_of_list
:
7624 printf (_("<End of list>\n"));
7626 case DW_RLE_base_address
:
7627 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7628 print_dwarf_vma (base_address
, pointer_size
);
7629 printf (_("(base address)\n"));
7631 case DW_RLE_start_length
:
7632 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7633 READ_ULEB (length
, start
, finish
);
7634 end
= begin
+ length
;
7636 case DW_RLE_offset_pair
:
7637 READ_ULEB (begin
, start
, finish
);
7638 READ_ULEB (end
, start
, finish
);
7640 case DW_RLE_start_end
:
7641 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7642 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7645 error (_("Invalid range list entry type %d\n"), rlet
);
7646 rlet
= DW_RLE_end_of_list
;
7649 if (rlet
== DW_RLE_end_of_list
)
7651 if (rlet
== DW_RLE_base_address
)
7654 /* Only a DW_RLE_offset_pair needs the base address added. */
7655 if (rlet
== DW_RLE_offset_pair
)
7657 begin
+= base_address
;
7658 end
+= base_address
;
7661 print_dwarf_vma (begin
, pointer_size
);
7662 print_dwarf_vma (end
, pointer_size
);
7665 fputs (_("(start == end)"), stdout
);
7666 else if (begin
> end
)
7667 fputs (_("(start > end)"), stdout
);
7674 display_debug_ranges (struct dwarf_section
*section
,
7675 void *file ATTRIBUTE_UNUSED
)
7677 unsigned char *start
= section
->start
;
7678 unsigned char *last_start
= start
;
7679 unsigned long bytes
= section
->size
;
7680 unsigned char *section_begin
= start
;
7681 unsigned char *finish
= start
+ bytes
;
7682 unsigned int num_range_list
, i
;
7683 struct range_entry
*range_entries
, *range_entry_fill
;
7684 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7685 /* Initialize it due to a false compiler warning. */
7686 unsigned char address_size
= 0;
7687 dwarf_vma last_offset
= 0;
7691 printf (_("\nThe %s section is empty.\n"), section
->name
);
7697 dwarf_vma initial_length
;
7698 unsigned char segment_selector_size
;
7699 unsigned int offset_size
, offset_entry_count
;
7700 unsigned short version
;
7702 /* Get and check the length of the block. */
7703 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7705 if (initial_length
== 0xffffffff)
7707 /* This section is 64-bit DWARF 3. */
7708 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7714 if (initial_length
> (size_t) (finish
- start
))
7716 /* If the length field has a relocation against it, then we should
7717 not complain if it is inaccurate (and probably negative).
7718 It is copied from .debug_line handling code. */
7719 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7721 initial_length
= finish
- start
;
7725 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7726 (long) initial_length
);
7730 finish
= start
+ initial_length
;
7732 /* Get and check the version number. */
7733 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7737 warn (_("Only DWARF version 5 debug_rnglists info "
7738 "is currently supported.\n"));
7742 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7744 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7745 if (segment_selector_size
!= 0)
7747 warn (_("The %s section contains "
7748 "unsupported segment selector size: %d.\n"),
7749 section
->name
, segment_selector_size
);
7753 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7754 if (offset_entry_count
!= 0)
7756 warn (_("The %s section contains "
7757 "unsupported offset entry count: %u.\n"),
7758 section
->name
, offset_entry_count
);
7763 if (load_debug_info (file
) == 0)
7765 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7771 for (i
= 0; i
< num_debug_info_entries
; i
++)
7773 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7774 /* Skip .debug_rnglists reference. */
7776 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7777 /* Skip .debug_range reference. */
7779 num_range_list
+= debug_information
[i
].num_range_lists
;
7782 if (num_range_list
== 0)
7784 /* This can happen when the file was compiled with -gsplit-debug
7785 which removes references to range lists from the primary .o file. */
7786 printf (_("No range lists in .debug_info section.\n"));
7790 range_entries
= (struct range_entry
*)
7791 xmalloc (sizeof (*range_entries
) * num_range_list
);
7792 range_entry_fill
= range_entries
;
7794 for (i
= 0; i
< num_debug_info_entries
; i
++)
7796 debug_info
*debug_info_p
= &debug_information
[i
];
7799 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7800 /* Skip .debug_rnglists reference. */
7802 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7803 /* Skip .debug_range reference. */
7806 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7808 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7809 range_entry_fill
->debug_info_p
= debug_info_p
;
7814 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7815 range_entry_compar
);
7817 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7818 warn (_("Range lists in %s section start at 0x%lx\n"),
7819 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7821 introduce (section
, false);
7823 printf (_(" Offset Begin End\n"));
7825 for (i
= 0; i
< num_range_list
; i
++)
7827 struct range_entry
*range_entry
= &range_entries
[i
];
7828 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7829 unsigned int pointer_size
;
7831 unsigned char *next
;
7832 dwarf_vma base_address
;
7834 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7835 offset
= range_entry
->ranges_offset
;
7836 base_address
= debug_info_p
->base_address
;
7838 /* PR 17512: file: 001-101485-0.001:0.1. */
7839 if (pointer_size
< 2 || pointer_size
> 8)
7841 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7842 pointer_size
, (unsigned long) offset
);
7846 if (offset
> (size_t) (finish
- section_begin
))
7848 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7849 (unsigned long) offset
, i
);
7852 next
= section_begin
+ offset
;
7854 /* If multiple DWARF entities reference the same range then we will
7855 have multiple entries in the `range_entries' list for the same
7856 offset. Thanks to the sort above these will all be consecutive in
7857 the `range_entries' list, so we can easily ignore duplicates
7859 if (i
> 0 && last_offset
== offset
)
7861 last_offset
= offset
;
7863 if (dwarf_check
!= 0 && i
> 0)
7866 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7867 (unsigned long) (start
- section_begin
),
7868 (unsigned long) (next
- section_begin
), section
->name
);
7869 else if (start
> next
)
7871 if (next
== last_start
)
7873 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7874 (unsigned long) (start
- section_begin
),
7875 (unsigned long) (next
- section_begin
), section
->name
);
7882 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7883 (start
, finish
, pointer_size
, offset
, base_address
);
7887 free (range_entries
);
7892 typedef struct Frame_Chunk
7894 struct Frame_Chunk
*next
;
7895 unsigned char *chunk_start
;
7897 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7898 short int *col_type
;
7901 unsigned int code_factor
;
7905 unsigned int cfa_reg
;
7906 dwarf_vma cfa_offset
;
7908 unsigned char fde_encoding
;
7909 unsigned char cfa_exp
;
7910 unsigned char ptr_size
;
7911 unsigned char segment_size
;
7915 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7916 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7917 static const char *const *dwarf_regnames
;
7918 static unsigned int dwarf_regnames_count
;
7921 /* A marker for a col_type that means this column was never referenced
7922 in the frame info. */
7923 #define DW_CFA_unreferenced (-1)
7925 /* Return 0 if no more space is needed, 1 if more space is needed,
7926 -1 for invalid reg. */
7929 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7931 unsigned int prev
= fc
->ncols
;
7933 if (reg
< (unsigned int) fc
->ncols
)
7936 if (dwarf_regnames_count
> 0
7937 && reg
> dwarf_regnames_count
)
7940 fc
->ncols
= reg
+ 1;
7941 /* PR 17512: file: 10450-2643-0.004.
7942 If reg == -1 then this can happen... */
7946 /* PR 17512: file: 2844a11d. */
7947 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7949 error (_("Unfeasibly large register number: %u\n"), reg
);
7951 /* FIXME: 1024 is an arbitrary limit. Increase it if
7952 we ever encounter a valid binary that exceeds it. */
7956 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7957 sizeof (short int));
7958 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7959 /* PR 17512: file:002-10025-0.005. */
7960 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7962 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7968 while (prev
< fc
->ncols
)
7970 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7971 fc
->col_offset
[prev
] = 0;
7977 static const char *const dwarf_regnames_i386
[] =
7979 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7980 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7981 "eip", "eflags", NULL
, /* 8 - 10 */
7982 "st0", "st1", "st2", "st3", /* 11 - 14 */
7983 "st4", "st5", "st6", "st7", /* 15 - 18 */
7984 NULL
, NULL
, /* 19 - 20 */
7985 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7986 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7987 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7988 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7989 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7990 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7991 "tr", "ldtr", /* 48 - 49 */
7992 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7993 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7994 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7995 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7996 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7997 NULL
, NULL
, NULL
, /* 90 - 92 */
7998 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
8001 static const char *const dwarf_regnames_iamcu
[] =
8003 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8004 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8005 "eip", "eflags", NULL
, /* 8 - 10 */
8006 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
8007 NULL
, NULL
, /* 19 - 20 */
8008 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
8009 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
8010 NULL
, NULL
, NULL
, /* 37 - 39 */
8011 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8012 "tr", "ldtr", /* 48 - 49 */
8013 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8014 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8015 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8016 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8017 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8018 NULL
, NULL
, NULL
, /* 90 - 92 */
8019 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
8023 init_dwarf_regnames_i386 (void)
8025 dwarf_regnames
= dwarf_regnames_i386
;
8026 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
8027 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8031 init_dwarf_regnames_iamcu (void)
8033 dwarf_regnames
= dwarf_regnames_iamcu
;
8034 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
8035 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8038 static const char *const dwarf_regnames_x86_64
[] =
8040 "rax", "rdx", "rcx", "rbx",
8041 "rsi", "rdi", "rbp", "rsp",
8042 "r8", "r9", "r10", "r11",
8043 "r12", "r13", "r14", "r15",
8045 "xmm0", "xmm1", "xmm2", "xmm3",
8046 "xmm4", "xmm5", "xmm6", "xmm7",
8047 "xmm8", "xmm9", "xmm10", "xmm11",
8048 "xmm12", "xmm13", "xmm14", "xmm15",
8049 "st0", "st1", "st2", "st3",
8050 "st4", "st5", "st6", "st7",
8051 "mm0", "mm1", "mm2", "mm3",
8052 "mm4", "mm5", "mm6", "mm7",
8054 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
8055 "fs.base", "gs.base", NULL
, NULL
,
8057 "mxcsr", "fcw", "fsw",
8058 "xmm16", "xmm17", "xmm18", "xmm19",
8059 "xmm20", "xmm21", "xmm22", "xmm23",
8060 "xmm24", "xmm25", "xmm26", "xmm27",
8061 "xmm28", "xmm29", "xmm30", "xmm31",
8062 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
8063 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
8064 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
8065 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
8066 NULL
, NULL
, NULL
, /* 115 - 117 */
8067 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
8071 init_dwarf_regnames_x86_64 (void)
8073 dwarf_regnames
= dwarf_regnames_x86_64
;
8074 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
8075 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8078 static const char *const dwarf_regnames_aarch64
[] =
8080 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
8081 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
8082 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
8083 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
8084 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8085 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
8086 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
8087 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
8088 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
8089 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
8090 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
8091 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
8092 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
8093 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
8094 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
8095 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
8099 init_dwarf_regnames_aarch64 (void)
8101 dwarf_regnames
= dwarf_regnames_aarch64
;
8102 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
8103 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8106 static const char *const dwarf_regnames_s390
[] =
8108 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
8109 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8110 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8111 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
8112 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
8113 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
8114 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
8115 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
8116 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
8119 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
8120 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
8124 init_dwarf_regnames_s390 (void)
8126 dwarf_regnames
= dwarf_regnames_s390
;
8127 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
8128 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8131 static const char *const dwarf_regnames_riscv
[] =
8133 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8134 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8135 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8136 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8137 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8138 "fs0", "fs1", /* 40 - 41 */
8139 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8140 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8141 "fs10", "fs11", /* 58 - 59 */
8142 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8145 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8146 the large number of CSRs. */
8149 regname_internal_riscv (unsigned int regno
)
8151 const char *name
= NULL
;
8153 /* Lookup in the table first, this covers GPR and FPR. */
8154 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8155 name
= dwarf_regnames_riscv
[regno
];
8156 else if (regno
>= 4096 && regno
<= 8191)
8158 /* This might be a CSR, these live in a sparse number space from 4096
8159 to 8191 These numbers are defined in the RISC-V ELF ABI
8163 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8164 case VALUE + 4096: name = #NAME; break;
8165 #include "opcode/riscv-opc.h"
8170 static char csr_name
[10];
8171 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8182 init_dwarf_regnames_riscv (void)
8184 dwarf_regnames
= NULL
;
8185 dwarf_regnames_count
= 8192;
8186 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8190 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8192 dwarf_regnames_lookup_func
= NULL
;
8197 init_dwarf_regnames_i386 ();
8201 init_dwarf_regnames_iamcu ();
8207 init_dwarf_regnames_x86_64 ();
8211 init_dwarf_regnames_aarch64 ();
8215 init_dwarf_regnames_s390 ();
8219 init_dwarf_regnames_riscv ();
8227 /* Initialize the DWARF register name lookup state based on the
8228 architecture and specific machine type of a BFD. */
8231 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8234 dwarf_regnames_lookup_func
= NULL
;
8241 case bfd_mach_x86_64
:
8242 case bfd_mach_x86_64_intel_syntax
:
8243 case bfd_mach_x64_32
:
8244 case bfd_mach_x64_32_intel_syntax
:
8245 init_dwarf_regnames_x86_64 ();
8249 init_dwarf_regnames_i386 ();
8254 case bfd_arch_iamcu
:
8255 init_dwarf_regnames_iamcu ();
8258 case bfd_arch_aarch64
:
8259 init_dwarf_regnames_aarch64();
8263 init_dwarf_regnames_s390 ();
8266 case bfd_arch_riscv
:
8267 init_dwarf_regnames_riscv ();
8276 regname_internal_by_table_only (unsigned int regno
)
8278 if (dwarf_regnames
!= NULL
8279 && regno
< dwarf_regnames_count
8280 && dwarf_regnames
[regno
] != NULL
)
8281 return dwarf_regnames
[regno
];
8287 regname (unsigned int regno
, int name_only_p
)
8289 static char reg
[64];
8291 const char *name
= NULL
;
8293 if (dwarf_regnames_lookup_func
!= NULL
)
8294 name
= dwarf_regnames_lookup_func (regno
);
8300 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8303 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8308 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8313 if (*max_regs
!= fc
->ncols
)
8314 *max_regs
= fc
->ncols
;
8316 if (*need_col_headers
)
8318 *need_col_headers
= 0;
8320 printf ("%-*s CFA ", eh_addr_size
* 2, " LOC");
8322 for (r
= 0; r
< *max_regs
; r
++)
8323 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8328 printf ("%-5s ", regname (r
, 1));
8334 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
8336 strcpy (tmp
, "exp");
8338 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8339 printf ("%-8s ", tmp
);
8341 for (r
= 0; r
< fc
->ncols
; r
++)
8343 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8345 switch (fc
->col_type
[r
])
8347 case DW_CFA_undefined
:
8350 case DW_CFA_same_value
:
8354 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8356 case DW_CFA_val_offset
:
8357 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8359 case DW_CFA_register
:
8360 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8362 case DW_CFA_expression
:
8363 strcpy (tmp
, "exp");
8365 case DW_CFA_val_expression
:
8366 strcpy (tmp
, "vexp");
8369 strcpy (tmp
, "n/a");
8372 printf ("%-5s ", tmp
);
8378 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8380 static unsigned char *
8381 read_cie (unsigned char *start
, unsigned char *end
,
8382 Frame_Chunk
**p_cie
, int *p_version
,
8383 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
8387 unsigned char *augmentation_data
= NULL
;
8388 bfd_size_type augmentation_data_len
= 0;
8391 /* PR 17512: file: 001-228113-0.004. */
8395 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8396 memset (fc
, 0, sizeof (Frame_Chunk
));
8398 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8399 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8403 fc
->augmentation
= (char *) start
;
8404 /* PR 17512: file: 001-228113-0.004.
8405 Skip past augmentation name, but avoid running off the end of the data. */
8407 if (* start
++ == '\0')
8411 warn (_("No terminator for augmentation name\n"));
8415 if (strcmp (fc
->augmentation
, "eh") == 0)
8417 if (eh_addr_size
> (size_t) (end
- start
))
8419 start
+= eh_addr_size
;
8424 if (2 > (size_t) (end
- start
))
8426 GET (fc
->ptr_size
, 1);
8427 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8429 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8433 GET (fc
->segment_size
, 1);
8434 /* PR 17512: file: e99d2804. */
8435 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8437 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8441 eh_addr_size
= fc
->ptr_size
;
8445 fc
->ptr_size
= eh_addr_size
;
8446 fc
->segment_size
= 0;
8449 READ_ULEB (fc
->code_factor
, start
, end
);
8450 READ_SLEB (fc
->data_factor
, start
, end
);
8461 READ_ULEB (fc
->ra
, start
, end
);
8464 if (fc
->augmentation
[0] == 'z')
8468 READ_ULEB (augmentation_data_len
, start
, end
);
8469 augmentation_data
= start
;
8470 /* PR 17512: file: 11042-2589-0.004. */
8471 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8473 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
8474 dwarf_vmatoa ("x", augmentation_data_len
),
8475 (unsigned long) (end
- start
));
8478 start
+= augmentation_data_len
;
8481 if (augmentation_data_len
)
8485 unsigned char *qend
;
8487 p
= (unsigned char *) fc
->augmentation
+ 1;
8488 q
= augmentation_data
;
8489 qend
= q
+ augmentation_data_len
;
8491 while (p
< end
&& q
< qend
)
8496 q
+= 1 + size_of_encoded_value (*q
);
8498 fc
->fde_encoding
= *q
++;
8507 /* Note - it is OK if this loop terminates with q < qend.
8508 Padding may have been inserted to align the end of the CIE. */
8513 *p_version
= version
;
8516 *p_aug_len
= augmentation_data_len
;
8517 *p_aug
= augmentation_data
;
8522 free (fc
->col_offset
);
8523 free (fc
->col_type
);
8528 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8529 If do_wide is not enabled, then formats the output to fit into 80 columns.
8530 PRINTED contains the number of characters already written to the current
8534 display_data (bfd_size_type printed
,
8535 const unsigned char * data
,
8536 const bfd_size_type len
)
8538 if (do_wide
|| len
< ((80 - printed
) / 3))
8539 for (printed
= 0; printed
< len
; ++printed
)
8540 printf (" %02x", data
[printed
]);
8543 for (printed
= 0; printed
< len
; ++printed
)
8545 if (printed
% (80 / 3) == 0)
8547 printf (" %02x", data
[printed
]);
8552 /* Prints out the contents on the augmentation data array.
8553 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8556 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
8560 i
= printf (_(" Augmentation data: "));
8561 display_data (i
, data
, len
);
8565 display_debug_frames (struct dwarf_section
*section
,
8566 void *file ATTRIBUTE_UNUSED
)
8568 unsigned char *start
= section
->start
;
8569 unsigned char *end
= start
+ section
->size
;
8570 unsigned char *section_start
= start
;
8571 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8572 Frame_Chunk
*remembered_state
= NULL
;
8574 bool is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8575 unsigned int max_regs
= 0;
8576 const char *bad_reg
= _("bad register: ");
8577 unsigned int saved_eh_addr_size
= eh_addr_size
;
8579 introduce (section
, false);
8583 unsigned char *saved_start
;
8584 unsigned char *block_end
;
8589 int need_col_headers
= 1;
8590 unsigned char *augmentation_data
= NULL
;
8591 bfd_size_type augmentation_data_len
= 0;
8592 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8593 unsigned int offset_size
;
8595 static Frame_Chunk fde_fc
;
8597 saved_start
= start
;
8599 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8603 printf ("\n%08lx ZERO terminator\n\n",
8604 (unsigned long)(saved_start
- section_start
));
8605 /* Skip any zero terminators that directly follow.
8606 A corrupt section size could have loaded a whole
8607 slew of zero filled memory bytes. eg
8608 PR 17512: file: 070-19381-0.004. */
8609 while (start
< end
&& * start
== 0)
8614 if (length
== 0xffffffff)
8616 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8622 if (length
> (size_t) (end
- start
))
8624 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8625 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8626 (unsigned long) (saved_start
- section_start
));
8630 block_end
= start
+ length
;
8632 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, block_end
);
8634 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8635 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8640 start
= read_cie (start
, block_end
, &cie
, &version
,
8641 &augmentation_data_len
, &augmentation_data
);
8642 /* PR 17512: file: 027-135133-0.005. */
8649 fc
->chunk_start
= saved_start
;
8650 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8653 if (frame_need_space (fc
, mreg
) < 0)
8655 if (fc
->fde_encoding
)
8656 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8658 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8659 print_dwarf_vma (length
, fc
->ptr_size
);
8660 print_dwarf_vma (cie_id
, offset_size
);
8662 if (do_debug_frames_interp
)
8664 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8665 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8670 printf (" Version: %d\n", version
);
8671 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8674 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8675 printf (" Segment Size: %u\n", fc
->segment_size
);
8677 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8678 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8679 printf (" Return address column: %d\n", fc
->ra
);
8681 if (augmentation_data_len
)
8682 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8689 unsigned char *look_for
;
8690 unsigned long segment_selector
;
8696 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8697 cie_off
= (cie_off
^ sign
) - sign
;
8698 cie_off
= start
- 4 - section_start
- cie_off
;
8701 look_for
= section_start
+ cie_off
;
8702 if (cie_off
<= (dwarf_vma
) (saved_start
- section_start
))
8704 for (cie
= chunks
; cie
; cie
= cie
->next
)
8705 if (cie
->chunk_start
== look_for
)
8708 else if (cie_off
>= section
->size
)
8712 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8713 if (cie
->chunk_start
== look_for
)
8717 unsigned int off_size
;
8718 unsigned char *cie_scan
;
8720 cie_scan
= look_for
;
8722 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8723 if (length
== 0xffffffff)
8725 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8728 if (length
!= 0 && length
<= (size_t) (end
- cie_scan
))
8731 unsigned char *cie_end
= cie_scan
+ length
;
8733 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
,
8737 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8738 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8743 read_cie (cie_scan
, cie_end
, &cie
, &version
,
8744 &augmentation_data_len
, &augmentation_data
);
8745 /* PR 17512: file: 3450-2098-0.004. */
8748 warn (_("Failed to read CIE information\n"));
8751 cie
->next
= forward_refs
;
8753 cie
->chunk_start
= look_for
;
8754 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8757 if (frame_need_space (cie
, mreg
) < 0)
8759 warn (_("Invalid max register\n"));
8762 if (cie
->fde_encoding
)
8764 = size_of_encoded_value (cie
->fde_encoding
);
8771 memset (fc
, 0, sizeof (Frame_Chunk
));
8775 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8776 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8777 (unsigned long) (saved_start
- section_start
));
8779 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8780 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8781 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8783 warn (_("Invalid max register\n"));
8787 fc
->augmentation
= "";
8788 fc
->fde_encoding
= 0;
8789 fc
->ptr_size
= eh_addr_size
;
8790 fc
->segment_size
= 0;
8794 fc
->ncols
= cie
->ncols
;
8795 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8796 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8797 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8798 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8799 fc
->augmentation
= cie
->augmentation
;
8800 fc
->ptr_size
= cie
->ptr_size
;
8801 eh_addr_size
= cie
->ptr_size
;
8802 fc
->segment_size
= cie
->segment_size
;
8803 fc
->code_factor
= cie
->code_factor
;
8804 fc
->data_factor
= cie
->data_factor
;
8805 fc
->cfa_reg
= cie
->cfa_reg
;
8806 fc
->cfa_offset
= cie
->cfa_offset
;
8808 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8810 warn (_("Invalid max register\n"));
8813 fc
->fde_encoding
= cie
->fde_encoding
;
8816 if (fc
->fde_encoding
)
8817 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8819 segment_selector
= 0;
8820 if (fc
->segment_size
)
8822 if (fc
->segment_size
> sizeof (segment_selector
))
8824 /* PR 17512: file: 9e196b3e. */
8825 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8826 fc
->segment_size
= 4;
8828 SAFE_BYTE_GET_AND_INC (segment_selector
, start
,
8829 fc
->segment_size
, block_end
);
8832 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
8835 /* FIXME: It appears that sometimes the final pc_range value is
8836 encoded in less than encoded_ptr_size bytes. See the x86_64
8837 run of the "objcopy on compressed debug sections" test for an
8839 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
,
8842 if (cie
->augmentation
[0] == 'z')
8844 READ_ULEB (augmentation_data_len
, start
, block_end
);
8845 augmentation_data
= start
;
8846 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8847 if (augmentation_data_len
> (bfd_size_type
) (block_end
- start
))
8849 warn (_("Augmentation data too long: 0x%s, "
8850 "expected at most %#lx\n"),
8851 dwarf_vmatoa ("x", augmentation_data_len
),
8852 (unsigned long) (block_end
- start
));
8854 augmentation_data
= NULL
;
8855 augmentation_data_len
= 0;
8857 start
+= augmentation_data_len
;
8860 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8861 (unsigned long)(saved_start
- section_start
),
8862 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8863 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8864 (unsigned long)(cie
->chunk_start
- section_start
));
8866 if (fc
->segment_size
)
8867 printf ("%04lx:", segment_selector
);
8870 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8871 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8873 if (! do_debug_frames_interp
&& augmentation_data_len
)
8875 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8880 /* At this point, fc is the current chunk, cie (if any) is set, and
8881 we're about to interpret instructions for the chunk. */
8882 /* ??? At present we need to do this always, since this sizes the
8883 fc->col_type and fc->col_offset arrays, which we write into always.
8884 We should probably split the interpreted and non-interpreted bits
8885 into two different routines, since there's so much that doesn't
8886 really overlap between them. */
8887 if (1 || do_debug_frames_interp
)
8889 /* Start by making a pass over the chunk, allocating storage
8890 and taking note of what registers are used. */
8891 unsigned char *tmp
= start
;
8893 while (start
< block_end
)
8895 unsigned int reg
, op
, opa
;
8903 /* Warning: if you add any more cases to this switch, be
8904 sure to add them to the corresponding switch below. */
8907 case DW_CFA_advance_loc
:
8910 SKIP_ULEB (start
, block_end
);
8911 if (frame_need_space (fc
, opa
) >= 0)
8912 fc
->col_type
[opa
] = DW_CFA_undefined
;
8914 case DW_CFA_restore
:
8915 if (frame_need_space (fc
, opa
) >= 0)
8916 fc
->col_type
[opa
] = DW_CFA_undefined
;
8918 case DW_CFA_set_loc
:
8919 if ((size_t) (block_end
- start
) < encoded_ptr_size
)
8922 start
+= encoded_ptr_size
;
8924 case DW_CFA_advance_loc1
:
8925 if ((size_t) (block_end
- start
) < 1)
8930 case DW_CFA_advance_loc2
:
8931 if ((size_t) (block_end
- start
) < 2)
8936 case DW_CFA_advance_loc4
:
8937 if ((size_t) (block_end
- start
) < 4)
8942 case DW_CFA_offset_extended
:
8943 case DW_CFA_val_offset
:
8944 READ_ULEB (reg
, start
, block_end
);
8945 SKIP_ULEB (start
, block_end
);
8946 if (frame_need_space (fc
, reg
) >= 0)
8947 fc
->col_type
[reg
] = DW_CFA_undefined
;
8949 case DW_CFA_restore_extended
:
8950 READ_ULEB (reg
, start
, block_end
);
8951 if (frame_need_space (fc
, reg
) >= 0)
8952 fc
->col_type
[reg
] = DW_CFA_undefined
;
8954 case DW_CFA_undefined
:
8955 READ_ULEB (reg
, start
, block_end
);
8956 if (frame_need_space (fc
, reg
) >= 0)
8957 fc
->col_type
[reg
] = DW_CFA_undefined
;
8959 case DW_CFA_same_value
:
8960 READ_ULEB (reg
, start
, block_end
);
8961 if (frame_need_space (fc
, reg
) >= 0)
8962 fc
->col_type
[reg
] = DW_CFA_undefined
;
8964 case DW_CFA_register
:
8965 READ_ULEB (reg
, start
, block_end
);
8966 SKIP_ULEB (start
, block_end
);
8967 if (frame_need_space (fc
, reg
) >= 0)
8968 fc
->col_type
[reg
] = DW_CFA_undefined
;
8970 case DW_CFA_def_cfa
:
8971 SKIP_ULEB (start
, block_end
);
8972 SKIP_ULEB (start
, block_end
);
8974 case DW_CFA_def_cfa_register
:
8975 SKIP_ULEB (start
, block_end
);
8977 case DW_CFA_def_cfa_offset
:
8978 SKIP_ULEB (start
, block_end
);
8980 case DW_CFA_def_cfa_expression
:
8981 READ_ULEB (temp
, start
, block_end
);
8982 if ((size_t) (block_end
- start
) < temp
)
8987 case DW_CFA_expression
:
8988 case DW_CFA_val_expression
:
8989 READ_ULEB (reg
, start
, block_end
);
8990 READ_ULEB (temp
, start
, block_end
);
8991 if ((size_t) (block_end
- start
) < temp
)
8995 if (frame_need_space (fc
, reg
) >= 0)
8996 fc
->col_type
[reg
] = DW_CFA_undefined
;
8998 case DW_CFA_offset_extended_sf
:
8999 case DW_CFA_val_offset_sf
:
9000 READ_ULEB (reg
, start
, block_end
);
9001 SKIP_SLEB (start
, block_end
);
9002 if (frame_need_space (fc
, reg
) >= 0)
9003 fc
->col_type
[reg
] = DW_CFA_undefined
;
9005 case DW_CFA_def_cfa_sf
:
9006 SKIP_ULEB (start
, block_end
);
9007 SKIP_SLEB (start
, block_end
);
9009 case DW_CFA_def_cfa_offset_sf
:
9010 SKIP_SLEB (start
, block_end
);
9012 case DW_CFA_MIPS_advance_loc8
:
9013 if ((size_t) (block_end
- start
) < 8)
9018 case DW_CFA_GNU_args_size
:
9019 SKIP_ULEB (start
, block_end
);
9021 case DW_CFA_GNU_negative_offset_extended
:
9022 READ_ULEB (reg
, start
, block_end
);
9023 SKIP_ULEB (start
, block_end
);
9024 if (frame_need_space (fc
, reg
) >= 0)
9025 fc
->col_type
[reg
] = DW_CFA_undefined
;
9036 /* Now we know what registers are used, make a second pass over
9037 the chunk, this time actually printing out the info. */
9039 while (start
< block_end
)
9042 unsigned long ul
, roffs
;
9043 /* Note: It is tempting to use an unsigned long for 'reg' but there
9044 are various functions, notably frame_space_needed() that assume that
9045 reg is an unsigned int. */
9050 const char *reg_prefix
= "";
9057 /* Make a note if something other than DW_CFA_nop happens. */
9058 if (op
!= DW_CFA_nop
)
9061 /* Warning: if you add any more cases to this switch, be
9062 sure to add them to the corresponding switch above. */
9065 case DW_CFA_advance_loc
:
9066 if (do_debug_frames_interp
)
9067 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9069 printf (" DW_CFA_advance_loc: %d to %s\n",
9070 opa
* fc
->code_factor
,
9071 dwarf_vmatoa_1 (NULL
,
9072 fc
->pc_begin
+ opa
* fc
->code_factor
,
9074 fc
->pc_begin
+= opa
* fc
->code_factor
;
9078 READ_ULEB (roffs
, start
, block_end
);
9079 if (opa
>= (unsigned int) fc
->ncols
)
9080 reg_prefix
= bad_reg
;
9081 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9082 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
9083 reg_prefix
, regname (opa
, 0),
9084 roffs
* fc
->data_factor
);
9085 if (*reg_prefix
== '\0')
9087 fc
->col_type
[opa
] = DW_CFA_offset
;
9088 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9092 case DW_CFA_restore
:
9093 if (opa
>= (unsigned int) fc
->ncols
)
9094 reg_prefix
= bad_reg
;
9095 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9096 printf (" DW_CFA_restore: %s%s\n",
9097 reg_prefix
, regname (opa
, 0));
9098 if (*reg_prefix
!= '\0')
9101 if (opa
>= (unsigned int) cie
->ncols
9102 || (do_debug_frames_interp
9103 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
9105 fc
->col_type
[opa
] = DW_CFA_undefined
;
9106 fc
->col_offset
[opa
] = 0;
9110 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9111 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9115 case DW_CFA_set_loc
:
9116 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9118 if (do_debug_frames_interp
)
9119 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9121 printf (" DW_CFA_set_loc: %s\n",
9122 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
9126 case DW_CFA_advance_loc1
:
9127 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, block_end
);
9128 if (do_debug_frames_interp
)
9129 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9131 printf (" DW_CFA_advance_loc1: %ld to %s\n",
9132 (unsigned long) (ofs
* fc
->code_factor
),
9133 dwarf_vmatoa_1 (NULL
,
9134 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9136 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9139 case DW_CFA_advance_loc2
:
9140 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
9141 if (do_debug_frames_interp
)
9142 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9144 printf (" DW_CFA_advance_loc2: %ld to %s\n",
9145 (unsigned long) (ofs
* fc
->code_factor
),
9146 dwarf_vmatoa_1 (NULL
,
9147 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9149 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9152 case DW_CFA_advance_loc4
:
9153 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9154 if (do_debug_frames_interp
)
9155 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9157 printf (" DW_CFA_advance_loc4: %ld to %s\n",
9158 (unsigned long) (ofs
* fc
->code_factor
),
9159 dwarf_vmatoa_1 (NULL
,
9160 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9162 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9165 case DW_CFA_offset_extended
:
9166 READ_ULEB (reg
, start
, block_end
);
9167 READ_ULEB (roffs
, start
, block_end
);
9168 if (reg
>= (unsigned int) fc
->ncols
)
9169 reg_prefix
= bad_reg
;
9170 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9171 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9172 reg_prefix
, regname (reg
, 0),
9173 roffs
* fc
->data_factor
);
9174 if (*reg_prefix
== '\0')
9176 fc
->col_type
[reg
] = DW_CFA_offset
;
9177 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9181 case DW_CFA_val_offset
:
9182 READ_ULEB (reg
, start
, block_end
);
9183 READ_ULEB (roffs
, start
, block_end
);
9184 if (reg
>= (unsigned int) fc
->ncols
)
9185 reg_prefix
= bad_reg
;
9186 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9187 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9188 reg_prefix
, regname (reg
, 0),
9189 roffs
* fc
->data_factor
);
9190 if (*reg_prefix
== '\0')
9192 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9193 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9197 case DW_CFA_restore_extended
:
9198 READ_ULEB (reg
, start
, block_end
);
9199 if (reg
>= (unsigned int) fc
->ncols
)
9200 reg_prefix
= bad_reg
;
9201 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9202 printf (" DW_CFA_restore_extended: %s%s\n",
9203 reg_prefix
, regname (reg
, 0));
9204 if (*reg_prefix
!= '\0')
9207 if (reg
>= (unsigned int) cie
->ncols
)
9209 fc
->col_type
[reg
] = DW_CFA_undefined
;
9210 fc
->col_offset
[reg
] = 0;
9214 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9215 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9219 case DW_CFA_undefined
:
9220 READ_ULEB (reg
, start
, block_end
);
9221 if (reg
>= (unsigned int) fc
->ncols
)
9222 reg_prefix
= bad_reg
;
9223 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9224 printf (" DW_CFA_undefined: %s%s\n",
9225 reg_prefix
, regname (reg
, 0));
9226 if (*reg_prefix
== '\0')
9228 fc
->col_type
[reg
] = DW_CFA_undefined
;
9229 fc
->col_offset
[reg
] = 0;
9233 case DW_CFA_same_value
:
9234 READ_ULEB (reg
, start
, block_end
);
9235 if (reg
>= (unsigned int) fc
->ncols
)
9236 reg_prefix
= bad_reg
;
9237 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9238 printf (" DW_CFA_same_value: %s%s\n",
9239 reg_prefix
, regname (reg
, 0));
9240 if (*reg_prefix
== '\0')
9242 fc
->col_type
[reg
] = DW_CFA_same_value
;
9243 fc
->col_offset
[reg
] = 0;
9247 case DW_CFA_register
:
9248 READ_ULEB (reg
, start
, block_end
);
9249 READ_ULEB (roffs
, start
, block_end
);
9250 if (reg
>= (unsigned int) fc
->ncols
)
9251 reg_prefix
= bad_reg
;
9252 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9254 printf (" DW_CFA_register: %s%s in ",
9255 reg_prefix
, regname (reg
, 0));
9256 puts (regname (roffs
, 0));
9258 if (*reg_prefix
== '\0')
9260 fc
->col_type
[reg
] = DW_CFA_register
;
9261 fc
->col_offset
[reg
] = roffs
;
9265 case DW_CFA_remember_state
:
9266 if (! do_debug_frames_interp
)
9267 printf (" DW_CFA_remember_state\n");
9268 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9269 rs
->cfa_offset
= fc
->cfa_offset
;
9270 rs
->cfa_reg
= fc
->cfa_reg
;
9272 rs
->cfa_exp
= fc
->cfa_exp
;
9273 rs
->ncols
= fc
->ncols
;
9274 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9275 sizeof (* rs
->col_type
));
9276 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9277 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9278 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9279 rs
->next
= remembered_state
;
9280 remembered_state
= rs
;
9283 case DW_CFA_restore_state
:
9284 if (! do_debug_frames_interp
)
9285 printf (" DW_CFA_restore_state\n");
9286 rs
= remembered_state
;
9289 remembered_state
= rs
->next
;
9290 fc
->cfa_offset
= rs
->cfa_offset
;
9291 fc
->cfa_reg
= rs
->cfa_reg
;
9293 fc
->cfa_exp
= rs
->cfa_exp
;
9294 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9296 warn (_("Invalid column number in saved frame state\n"));
9300 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9301 memcpy (fc
->col_offset
, rs
->col_offset
,
9302 rs
->ncols
* sizeof (* rs
->col_offset
));
9303 free (rs
->col_type
);
9304 free (rs
->col_offset
);
9307 else if (do_debug_frames_interp
)
9308 printf ("Mismatched DW_CFA_restore_state\n");
9311 case DW_CFA_def_cfa
:
9312 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9313 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9315 if (! do_debug_frames_interp
)
9316 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9317 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9320 case DW_CFA_def_cfa_register
:
9321 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9323 if (! do_debug_frames_interp
)
9324 printf (" DW_CFA_def_cfa_register: %s\n",
9325 regname (fc
->cfa_reg
, 0));
9328 case DW_CFA_def_cfa_offset
:
9329 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9330 if (! do_debug_frames_interp
)
9331 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9335 if (! do_debug_frames_interp
)
9336 printf (" DW_CFA_nop\n");
9339 case DW_CFA_def_cfa_expression
:
9340 READ_ULEB (ul
, start
, block_end
);
9341 if (ul
> (size_t) (block_end
- start
))
9343 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9346 if (! do_debug_frames_interp
)
9348 printf (" DW_CFA_def_cfa_expression (");
9349 decode_location_expression (start
, eh_addr_size
, 0, -1,
9357 case DW_CFA_expression
:
9358 READ_ULEB (reg
, start
, block_end
);
9359 READ_ULEB (ul
, start
, block_end
);
9360 if (reg
>= (unsigned int) fc
->ncols
)
9361 reg_prefix
= bad_reg
;
9362 /* PR 17512: file: 069-133014-0.006. */
9363 /* PR 17512: file: 98c02eb4. */
9364 if (ul
> (size_t) (block_end
- start
))
9366 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9369 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9371 printf (" DW_CFA_expression: %s%s (",
9372 reg_prefix
, regname (reg
, 0));
9373 decode_location_expression (start
, eh_addr_size
, 0, -1,
9377 if (*reg_prefix
== '\0')
9378 fc
->col_type
[reg
] = DW_CFA_expression
;
9382 case DW_CFA_val_expression
:
9383 READ_ULEB (reg
, start
, block_end
);
9384 READ_ULEB (ul
, start
, block_end
);
9385 if (reg
>= (unsigned int) fc
->ncols
)
9386 reg_prefix
= bad_reg
;
9387 if (ul
> (size_t) (block_end
- start
))
9389 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9392 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9394 printf (" DW_CFA_val_expression: %s%s (",
9395 reg_prefix
, regname (reg
, 0));
9396 decode_location_expression (start
, eh_addr_size
, 0, -1,
9400 if (*reg_prefix
== '\0')
9401 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9405 case DW_CFA_offset_extended_sf
:
9406 READ_ULEB (reg
, start
, block_end
);
9407 READ_SLEB (l
, start
, block_end
);
9408 if (frame_need_space (fc
, reg
) < 0)
9409 reg_prefix
= bad_reg
;
9410 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9411 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
9412 reg_prefix
, regname (reg
, 0),
9413 (long)(l
* fc
->data_factor
));
9414 if (*reg_prefix
== '\0')
9416 fc
->col_type
[reg
] = DW_CFA_offset
;
9417 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9421 case DW_CFA_val_offset_sf
:
9422 READ_ULEB (reg
, start
, block_end
);
9423 READ_SLEB (l
, start
, block_end
);
9424 if (frame_need_space (fc
, reg
) < 0)
9425 reg_prefix
= bad_reg
;
9426 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9427 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
9428 reg_prefix
, regname (reg
, 0),
9429 (long)(l
* fc
->data_factor
));
9430 if (*reg_prefix
== '\0')
9432 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9433 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9437 case DW_CFA_def_cfa_sf
:
9438 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9439 READ_SLEB (l
, start
, block_end
);
9440 l
*= fc
->data_factor
;
9443 if (! do_debug_frames_interp
)
9444 printf (" DW_CFA_def_cfa_sf: %s ofs %ld\n",
9445 regname (fc
->cfa_reg
, 0), (long) l
);
9448 case DW_CFA_def_cfa_offset_sf
:
9449 READ_SLEB (l
, start
, block_end
);
9450 l
*= fc
->data_factor
;
9452 if (! do_debug_frames_interp
)
9453 printf (" DW_CFA_def_cfa_offset_sf: %ld\n", (long) l
);
9456 case DW_CFA_MIPS_advance_loc8
:
9457 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9458 if (do_debug_frames_interp
)
9459 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9461 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
9462 (unsigned long) (ofs
* fc
->code_factor
),
9463 dwarf_vmatoa_1 (NULL
,
9464 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9466 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9469 case DW_CFA_GNU_window_save
:
9470 if (! do_debug_frames_interp
)
9471 printf (" DW_CFA_GNU_window_save\n");
9474 case DW_CFA_GNU_args_size
:
9475 READ_ULEB (ul
, start
, block_end
);
9476 if (! do_debug_frames_interp
)
9477 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9480 case DW_CFA_GNU_negative_offset_extended
:
9481 READ_ULEB (reg
, start
, block_end
);
9482 READ_SLEB (l
, start
, block_end
);
9484 if (frame_need_space (fc
, reg
) < 0)
9485 reg_prefix
= bad_reg
;
9486 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9487 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
9488 reg_prefix
, regname (reg
, 0),
9489 (long)(l
* fc
->data_factor
));
9490 if (*reg_prefix
== '\0')
9492 fc
->col_type
[reg
] = DW_CFA_offset
;
9493 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9498 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9499 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9501 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9506 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9507 if (do_debug_frames_interp
&& ! all_nops
)
9508 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9510 if (fde_fc
.col_type
!= NULL
)
9512 free (fde_fc
.col_type
);
9513 fde_fc
.col_type
= NULL
;
9515 if (fde_fc
.col_offset
!= NULL
)
9517 free (fde_fc
.col_offset
);
9518 fde_fc
.col_offset
= NULL
;
9522 eh_addr_size
= saved_eh_addr_size
;
9527 while (remembered_state
!= NULL
)
9529 rs
= remembered_state
;
9530 remembered_state
= rs
->next
;
9531 free (rs
->col_type
);
9532 free (rs
->col_offset
);
9533 rs
->next
= NULL
; /* Paranoia. */
9537 while (chunks
!= NULL
)
9541 free (rs
->col_type
);
9542 free (rs
->col_offset
);
9543 rs
->next
= NULL
; /* Paranoia. */
9547 while (forward_refs
!= NULL
)
9550 forward_refs
= rs
->next
;
9551 free (rs
->col_type
);
9552 free (rs
->col_offset
);
9553 rs
->next
= NULL
; /* Paranoia. */
9563 display_debug_names (struct dwarf_section
*section
, void *file
)
9565 unsigned char *hdrptr
= section
->start
;
9566 dwarf_vma unit_length
;
9567 unsigned char *unit_start
;
9568 const unsigned char *const section_end
= section
->start
+ section
->size
;
9569 unsigned char *unit_end
;
9571 introduce (section
, false);
9573 load_debug_section_with_follow (str
, file
);
9575 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9577 unsigned int offset_size
;
9578 uint16_t dwarf_version
, padding
;
9579 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9580 uint64_t bucket_count
, name_count
, abbrev_table_size
;
9581 uint32_t augmentation_string_size
;
9583 bool augmentation_printable
;
9584 const char *augmentation_string
;
9587 unit_start
= hdrptr
;
9589 /* Get and check the length of the block. */
9590 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9592 if (unit_length
== 0xffffffff)
9594 /* This section is 64-bit DWARF. */
9595 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9601 if (unit_length
> (size_t) (section_end
- hdrptr
)
9602 || unit_length
< 2 + 2 + 4 * 7)
9605 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9607 (unsigned long) (unit_start
- section
->start
),
9608 dwarf_vmatoa ("x", unit_length
));
9611 unit_end
= hdrptr
+ unit_length
;
9613 /* Get and check the version number. */
9614 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9615 printf (_("Version %ld\n"), (long) dwarf_version
);
9617 /* Prior versions did not exist, and future versions may not be
9618 backwards compatible. */
9619 if (dwarf_version
!= 5)
9621 warn (_("Only DWARF version 5 .debug_names "
9622 "is currently supported.\n"));
9626 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9628 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9631 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9632 if (comp_unit_count
== 0)
9633 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9635 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9636 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9637 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9638 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9639 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9641 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9642 if (augmentation_string_size
% 4 != 0)
9644 warn (_("Augmentation string length %u must be rounded up "
9645 "to a multiple of 4 in .debug_names.\n"),
9646 augmentation_string_size
);
9647 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9649 if (augmentation_string_size
> (size_t) (unit_end
- hdrptr
))
9652 printf (_("Augmentation string:"));
9654 augmentation_printable
= true;
9655 augmentation_string
= (const char *) hdrptr
;
9657 for (i
= 0; i
< augmentation_string_size
; i
++)
9661 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9662 printf (" %02x", uc
);
9664 if (uc
!= 0 && !ISPRINT (uc
))
9665 augmentation_printable
= false;
9668 if (augmentation_printable
)
9672 i
< augmentation_string_size
&& augmentation_string
[i
];
9674 putchar (augmentation_string
[i
]);
9679 printf (_("CU table:\n"));
9680 if (_mul_overflow (comp_unit_count
, offset_size
, &total
)
9681 || total
> (size_t) (unit_end
- hdrptr
))
9683 for (i
= 0; i
< comp_unit_count
; i
++)
9687 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9688 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9692 printf (_("TU table:\n"));
9693 if (_mul_overflow (local_type_unit_count
, offset_size
, &total
)
9694 || total
> (size_t) (unit_end
- hdrptr
))
9696 for (i
= 0; i
< local_type_unit_count
; i
++)
9700 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9701 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9705 printf (_("Foreign TU table:\n"));
9706 if (_mul_overflow (foreign_type_unit_count
, 8, &total
)
9707 || total
> (size_t) (unit_end
- hdrptr
))
9709 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9713 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9714 printf (_("[%3u] "), i
);
9715 print_dwarf_vma (signature
, 8);
9720 uint64_t xtra
= (bucket_count
* sizeof (uint32_t)
9721 + name_count
* (sizeof (uint32_t) + 2 * offset_size
)
9722 + abbrev_table_size
);
9723 if (xtra
> (size_t) (unit_end
- hdrptr
))
9725 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9726 "for unit 0x%lx in the debug_names\n"),
9728 (long) (unit_end
- unit_start
),
9729 (long) (unit_start
- section
->start
));
9732 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9733 hdrptr
+= bucket_count
* sizeof (uint32_t);
9734 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9735 hdrptr
+= name_count
* sizeof (uint32_t);
9736 unsigned char *const name_table_string_offsets
= hdrptr
;
9737 hdrptr
+= name_count
* offset_size
;
9738 unsigned char *const name_table_entry_offsets
= hdrptr
;
9739 hdrptr
+= name_count
* offset_size
;
9740 unsigned char *const abbrev_table
= hdrptr
;
9741 hdrptr
+= abbrev_table_size
;
9742 const unsigned char *const abbrev_table_end
= hdrptr
;
9743 unsigned char *const entry_pool
= hdrptr
;
9745 size_t buckets_filled
= 0;
9747 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9749 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9754 printf (ngettext ("Used %zu of %lu bucket.\n",
9755 "Used %zu of %lu buckets.\n",
9757 buckets_filled
, (unsigned long) bucket_count
);
9759 uint32_t hash_prev
= 0;
9760 size_t hash_clash_count
= 0;
9761 size_t longest_clash
= 0;
9762 size_t this_length
= 0;
9764 for (hashi
= 0; hashi
< name_count
; hashi
++)
9766 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9770 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9774 longest_clash
= MAX (longest_clash
, this_length
);
9779 hash_prev
= hash_this
;
9781 printf (_("Out of %lu items there are %zu bucket clashes"
9782 " (longest of %zu entries).\n"),
9783 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9784 assert (name_count
== buckets_filled
+ hash_clash_count
);
9786 struct abbrev_lookup_entry
9788 dwarf_vma abbrev_tag
;
9789 unsigned char *abbrev_lookup_ptr
;
9791 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9792 size_t abbrev_lookup_used
= 0;
9793 size_t abbrev_lookup_allocated
= 0;
9795 unsigned char *abbrevptr
= abbrev_table
;
9798 dwarf_vma abbrev_tag
;
9800 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9801 if (abbrev_tag
== 0)
9803 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9805 abbrev_lookup_allocated
= MAX (0x100,
9806 abbrev_lookup_allocated
* 2);
9807 abbrev_lookup
= xrealloc (abbrev_lookup
,
9808 (abbrev_lookup_allocated
9809 * sizeof (*abbrev_lookup
)));
9811 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9812 struct abbrev_lookup_entry
*entry
;
9813 for (entry
= abbrev_lookup
;
9814 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9816 if (entry
->abbrev_tag
== abbrev_tag
)
9818 warn (_("Duplicate abbreviation tag %lu "
9819 "in unit 0x%lx in the debug_names\n"),
9820 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9823 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9824 entry
->abbrev_tag
= abbrev_tag
;
9825 entry
->abbrev_lookup_ptr
= abbrevptr
;
9827 /* Skip DWARF tag. */
9828 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9831 dwarf_vma xindex
, form
;
9833 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9834 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9835 if (xindex
== 0 && form
== 0)
9840 printf (_("\nSymbol table:\n"));
9842 for (namei
= 0; namei
< name_count
; ++namei
)
9844 uint64_t string_offset
, entry_offset
;
9847 p
= name_table_string_offsets
+ namei
* offset_size
;
9848 SAFE_BYTE_GET (string_offset
, p
, offset_size
, unit_end
);
9849 p
= name_table_entry_offsets
+ namei
* offset_size
;
9850 SAFE_BYTE_GET (entry_offset
, p
, offset_size
, unit_end
);
9852 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9853 fetch_indirect_string (string_offset
));
9855 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9857 /* We need to scan first whether there is a single or multiple
9858 entries. TAGNO is -2 for the first entry, it is -1 for the
9859 initial tag read of the second entry, then it becomes 0 for the
9860 first entry for real printing etc. */
9862 /* Initialize it due to a false compiler warning. */
9863 dwarf_vma second_abbrev_tag
= -1;
9866 dwarf_vma abbrev_tag
;
9867 dwarf_vma dwarf_tag
;
9868 const struct abbrev_lookup_entry
*entry
;
9870 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9873 second_abbrev_tag
= abbrev_tag
;
9875 entryptr
= entry_pool
+ entry_offset
;
9878 if (abbrev_tag
== 0)
9882 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9883 (unsigned long) abbrev_tag
);
9885 for (entry
= abbrev_lookup
;
9886 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9888 if (entry
->abbrev_tag
== abbrev_tag
)
9890 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9892 warn (_("Undefined abbreviation tag %lu "
9893 "in unit 0x%lx in the debug_names\n"),
9895 (long) (unit_start
- section
->start
));
9898 abbrevptr
= entry
->abbrev_lookup_ptr
;
9899 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9901 printf (" %s", get_TAG_name (dwarf_tag
));
9904 dwarf_vma xindex
, form
;
9906 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9907 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9908 if (xindex
== 0 && form
== 0)
9912 printf (" %s", get_IDX_name (xindex
));
9913 entryptr
= read_and_display_attr_value (0, form
, 0,
9914 unit_start
, entryptr
, unit_end
,
9916 dwarf_version
, NULL
,
9923 printf (_(" <no entries>"));
9927 free (abbrev_lookup
);
9934 display_debug_links (struct dwarf_section
* section
,
9935 void * file ATTRIBUTE_UNUSED
)
9937 const unsigned char * filename
;
9938 unsigned int filelen
;
9940 introduce (section
, false);
9942 /* The .gnu_debuglink section is formatted as:
9943 (c-string) Filename.
9944 (padding) If needed to reach a 4 byte boundary.
9945 (uint32_t) CRC32 value.
9947 The .gun_debugaltlink section is formatted as:
9948 (c-string) Filename.
9949 (binary) Build-ID. */
9951 filename
= section
->start
;
9952 filelen
= strnlen ((const char *) filename
, section
->size
);
9953 if (filelen
== section
->size
)
9955 warn (_("The debuglink filename is corrupt/missing\n"));
9959 printf (_(" Separate debug info file: %s\n"), filename
);
9961 if (startswith (section
->name
, ".gnu_debuglink"))
9964 unsigned int crc_offset
;
9966 crc_offset
= filelen
+ 1;
9967 crc_offset
= (crc_offset
+ 3) & ~3;
9968 if (crc_offset
+ 4 > section
->size
)
9970 warn (_("CRC offset missing/truncated\n"));
9974 crc32
= byte_get (filename
+ crc_offset
, 4);
9976 printf (_(" CRC value: %#x\n"), crc32
);
9978 if (crc_offset
+ 4 < section
->size
)
9980 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9981 (long)(section
->size
- (crc_offset
+ 4)));
9985 else /* startswith (section->name, ".gnu_debugaltlink") */
9987 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9988 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9989 bfd_size_type printed
;
9991 /* FIXME: Should we support smaller build-id notes ? */
9992 if (build_id_len
< 0x14)
9994 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9998 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9999 display_data (printed
, build_id
, build_id_len
);
10008 display_gdb_index (struct dwarf_section
*section
,
10009 void *file ATTRIBUTE_UNUSED
)
10011 unsigned char *start
= section
->start
;
10013 uint32_t cu_list_offset
, tu_list_offset
;
10014 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
10015 unsigned int cu_list_elements
, tu_list_elements
;
10016 unsigned int address_table_size
, symbol_table_slots
;
10017 unsigned char *cu_list
, *tu_list
;
10018 unsigned char *address_table
, *symbol_table
, *constant_pool
;
10021 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
10023 introduce (section
, false);
10025 if (section
->size
< 6 * sizeof (uint32_t))
10027 warn (_("Truncated header in the %s section.\n"), section
->name
);
10031 version
= byte_get_little_endian (start
, 4);
10032 printf (_("Version %ld\n"), (long) version
);
10034 /* Prior versions are obsolete, and future versions may not be
10035 backwards compatible. */
10036 if (version
< 3 || version
> 8)
10038 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
10042 warn (_("The address table data in version 3 may be wrong.\n"));
10044 warn (_("Version 4 does not support case insensitive lookups.\n"));
10046 warn (_("Version 5 does not include inlined functions.\n"));
10048 warn (_("Version 6 does not include symbol attributes.\n"));
10049 /* Version 7 indices generated by Gold have bad type unit references,
10050 PR binutils/15021. But we don't know if the index was generated by
10051 Gold or not, so to avoid worrying users with gdb-generated indices
10052 we say nothing for version 7 here. */
10054 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
10055 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
10056 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
10057 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
10058 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
10060 if (cu_list_offset
> section
->size
10061 || tu_list_offset
> section
->size
10062 || address_table_offset
> section
->size
10063 || symbol_table_offset
> section
->size
10064 || constant_pool_offset
> section
->size
)
10066 warn (_("Corrupt header in the %s section.\n"), section
->name
);
10070 /* PR 17531: file: 418d0a8a. */
10071 if (tu_list_offset
< cu_list_offset
)
10073 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
10074 tu_list_offset
, cu_list_offset
);
10078 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
10080 if (address_table_offset
< tu_list_offset
)
10082 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
10083 address_table_offset
, tu_list_offset
);
10087 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
10089 /* PR 17531: file: 18a47d3d. */
10090 if (symbol_table_offset
< address_table_offset
)
10092 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
10093 symbol_table_offset
, address_table_offset
);
10097 address_table_size
= symbol_table_offset
- address_table_offset
;
10099 if (constant_pool_offset
< symbol_table_offset
)
10101 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
10102 constant_pool_offset
, symbol_table_offset
);
10106 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
10108 cu_list
= start
+ cu_list_offset
;
10109 tu_list
= start
+ tu_list_offset
;
10110 address_table
= start
+ address_table_offset
;
10111 symbol_table
= start
+ symbol_table_offset
;
10112 constant_pool
= start
+ constant_pool_offset
;
10114 if (address_table_offset
+ address_table_size
> section
->size
)
10116 warn (_("Address table extends beyond end of section.\n"));
10120 printf (_("\nCU table:\n"));
10121 for (i
= 0; i
< cu_list_elements
; i
+= 2)
10123 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
10124 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
10126 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
10127 (unsigned long) cu_offset
,
10128 (unsigned long) (cu_offset
+ cu_length
- 1));
10131 printf (_("\nTU table:\n"));
10132 for (i
= 0; i
< tu_list_elements
; i
+= 3)
10134 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
10135 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
10136 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
10138 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
10139 (unsigned long) tu_offset
,
10140 (unsigned long) type_offset
);
10141 print_dwarf_vma (signature
, 8);
10145 printf (_("\nAddress table:\n"));
10146 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
10149 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
10150 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
10151 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
10153 print_dwarf_vma (low
, 8);
10154 print_dwarf_vma (high
, 8);
10155 printf (_("%lu\n"), (unsigned long) cu_index
);
10158 printf (_("\nSymbol table:\n"));
10159 for (i
= 0; i
< symbol_table_slots
; ++i
)
10161 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10162 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10163 uint32_t num_cus
, cu
;
10165 if (name_offset
!= 0
10166 || cu_vector_offset
!= 0)
10170 /* PR 17531: file: 5b7b07ad. */
10171 if (name_offset
>= section
->size
- constant_pool_offset
)
10173 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10174 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10178 printf ("[%3u] %.*s:", i
,
10179 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10180 constant_pool
+ name_offset
);
10182 if (section
->size
- constant_pool_offset
< 4
10183 || cu_vector_offset
> section
->size
- constant_pool_offset
- 4)
10185 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10186 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10187 cu_vector_offset
, i
);
10191 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
10193 if ((uint64_t) num_cus
* 4 > section
->size
- (constant_pool_offset
10194 + cu_vector_offset
+ 4))
10196 printf ("<invalid number of CUs: %d>\n", num_cus
);
10197 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10205 for (j
= 0; j
< num_cus
; ++j
)
10208 gdb_index_symbol_kind kind
;
10210 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10211 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10212 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10213 cu
= GDB_INDEX_CU_VALUE (cu
);
10214 /* Convert to TU number if it's for a type unit. */
10215 if (cu
>= cu_list_elements
/ 2)
10216 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10217 (unsigned long) (cu
- cu_list_elements
/ 2));
10219 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10221 printf (" [%s, %s]",
10222 is_static
? _("static") : _("global"),
10223 get_gdb_index_symbol_kind_name (kind
));
10235 /* Pre-allocate enough space for the CU/TU sets needed. */
10238 prealloc_cu_tu_list (unsigned int nshndx
)
10240 if (shndx_pool
== NULL
)
10242 shndx_pool_size
= nshndx
;
10243 shndx_pool_used
= 0;
10244 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10245 sizeof (unsigned int));
10249 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10250 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10251 sizeof (unsigned int));
10256 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10258 if (shndx_pool_used
>= shndx_pool_size
)
10260 error (_("Internal error: out of space in the shndx pool.\n"));
10263 shndx_pool
[shndx_pool_used
++] = shndx
;
10267 end_cu_tu_entry (void)
10269 if (shndx_pool_used
>= shndx_pool_size
)
10271 error (_("Internal error: out of space in the shndx pool.\n"));
10274 shndx_pool
[shndx_pool_used
++] = 0;
10277 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10279 static const char *
10280 get_DW_SECT_short_name (unsigned int dw_sect
)
10282 static char buf
[16];
10288 case DW_SECT_TYPES
:
10290 case DW_SECT_ABBREV
:
10296 case DW_SECT_STR_OFFSETS
:
10298 case DW_SECT_MACINFO
:
10300 case DW_SECT_MACRO
:
10306 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10310 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10311 These sections are extensions for Fission.
10312 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10315 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10317 unsigned char *phdr
= section
->start
;
10318 unsigned char *limit
= phdr
+ section
->size
;
10319 unsigned char *phash
;
10320 unsigned char *pindex
;
10321 unsigned char *ppool
;
10322 unsigned int version
;
10323 unsigned int ncols
= 0;
10324 unsigned int nused
;
10325 unsigned int nslots
;
10328 dwarf_vma signature
;
10331 /* PR 17512: file: 002-168123-0.004. */
10334 warn (_("Section %s is empty\n"), section
->name
);
10337 /* PR 17512: file: 002-376-0.004. */
10338 if (section
->size
< 24)
10340 warn (_("Section %s is too small to contain a CU/TU header\n"),
10346 SAFE_BYTE_GET_AND_INC (version
, phash
, 4, limit
);
10348 SAFE_BYTE_GET_AND_INC (ncols
, phash
, 4, limit
);
10349 SAFE_BYTE_GET_AND_INC (nused
, phash
, 4, limit
);
10350 SAFE_BYTE_GET_AND_INC (nslots
, phash
, 4, limit
);
10352 pindex
= phash
+ (size_t) nslots
* 8;
10353 ppool
= pindex
+ (size_t) nslots
* 4;
10357 introduce (section
, false);
10359 printf (_(" Version: %u\n"), version
);
10361 printf (_(" Number of columns: %u\n"), ncols
);
10362 printf (_(" Number of used entries: %u\n"), nused
);
10363 printf (_(" Number of slots: %u\n\n"), nslots
);
10366 /* PR 17531: file: 45d69832. */
10367 if (_mul_overflow ((size_t) nslots
, 12, &total
)
10368 || total
> (size_t) (limit
- phash
))
10370 warn (ngettext ("Section %s is too small for %u slot\n",
10371 "Section %s is too small for %u slots\n",
10373 section
->name
, nslots
);
10380 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10381 for (i
= 0; i
< nslots
; i
++)
10383 unsigned char *shndx_list
;
10384 unsigned int shndx
;
10386 SAFE_BYTE_GET (signature
, phash
, 8, limit
);
10387 if (signature
!= 0)
10389 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10390 shndx_list
= ppool
+ j
* 4;
10391 /* PR 17531: file: 705e010d. */
10392 if (shndx_list
< ppool
)
10394 warn (_("Section index pool located before start of section\n"));
10399 printf (_(" [%3d] Signature: 0x%s Sections: "),
10400 i
, dwarf_vmatoa ("x", signature
));
10403 if (shndx_list
>= limit
)
10405 warn (_("Section %s too small for shndx pool\n"),
10409 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10413 printf (" %d", shndx
);
10415 add_shndx_to_cu_tu_entry (shndx
);
10421 end_cu_tu_entry ();
10427 else if (version
== 2)
10430 unsigned int dw_sect
;
10431 unsigned char *ph
= phash
;
10432 unsigned char *pi
= pindex
;
10433 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10434 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10436 struct cu_tu_set
*this_set
= NULL
;
10438 unsigned char *prow
;
10441 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10443 /* PR 17531: file: 0dd159bf.
10444 Check for integer overflow (can occur when size_t is 32-bit)
10445 with overlarge ncols or nused values. */
10447 || _mul_overflow ((size_t) ncols
, 4, &temp
)
10448 || _mul_overflow ((size_t) nused
+ 1, temp
, &total
)
10449 || total
> (size_t) (limit
- ppool
))
10451 warn (_("Section %s too small for offset and size tables\n"),
10458 printf (_(" Offset table\n"));
10459 printf (" slot %-16s ",
10460 is_tu_index
? _("signature") : _("dwo_id"));
10467 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10468 this_set
= tu_sets
;
10473 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10474 this_set
= cu_sets
;
10480 for (j
= 0; j
< ncols
; j
++)
10482 unsigned char *p
= ppool
+ j
* 4;
10483 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10484 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10489 for (i
= 0; i
< nslots
; i
++)
10491 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10493 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10496 /* PR 17531: file: a05f6ab3. */
10499 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10506 size_t num_copy
= sizeof (uint64_t);
10508 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10511 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10513 printf (_(" [%3d] 0x%s"),
10514 i
, dwarf_vmatoa ("x", signature
));
10515 for (j
= 0; j
< ncols
; j
++)
10517 unsigned char *p
= prow
+ j
* 4;
10518 SAFE_BYTE_GET (val
, p
, 4, limit
);
10520 printf (" %8d", val
);
10524 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10526 /* PR 17531: file: 10796eb3. */
10527 if (dw_sect
>= DW_SECT_MAX
)
10528 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10530 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10546 printf (_(" Size table\n"));
10547 printf (" slot %-16s ",
10548 is_tu_index
? _("signature") : _("dwo_id"));
10551 for (j
= 0; j
< ncols
; j
++)
10553 unsigned char *p
= ppool
+ j
* 4;
10554 SAFE_BYTE_GET (val
, p
, 4, limit
);
10556 printf (" %8s", get_DW_SECT_short_name (val
));
10562 for (i
= 0; i
< nslots
; i
++)
10564 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10566 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10569 prow
= psizes
+ (row
- 1) * ncols
* 4;
10572 printf (_(" [%3d] 0x%s"),
10573 i
, dwarf_vmatoa ("x", signature
));
10575 for (j
= 0; j
< ncols
; j
++)
10577 unsigned char *p
= prow
+ j
* 4;
10578 SAFE_BYTE_GET (val
, p
, 4, limit
);
10580 printf (" %8d", val
);
10584 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10585 if (dw_sect
>= DW_SECT_MAX
)
10586 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10588 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10600 else if (do_display
)
10601 printf (_(" Unsupported version (%d)\n"), version
);
10609 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10611 /* Load the CU and TU indexes if present. This will build a list of
10612 section sets that we can use to associate a .debug_info.dwo section
10613 with its associated .debug_abbrev.dwo section in a .dwp file. */
10616 load_cu_tu_indexes (void *file
)
10618 /* If we have already loaded (or tried to load) the CU and TU indexes
10619 then do not bother to repeat the task. */
10620 if (cu_tu_indexes_read
== -1)
10622 cu_tu_indexes_read
= true;
10624 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10625 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10626 cu_tu_indexes_read
= false;
10628 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10629 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10630 cu_tu_indexes_read
= false;
10633 return (bool) cu_tu_indexes_read
;
10636 /* Find the set of sections that includes section SHNDX. */
10639 find_cu_tu_set (void *file
, unsigned int shndx
)
10643 if (! load_cu_tu_indexes (file
))
10646 /* Find SHNDX in the shndx pool. */
10647 for (i
= 0; i
< shndx_pool_used
; i
++)
10648 if (shndx_pool
[i
] == shndx
)
10651 if (i
>= shndx_pool_used
)
10654 /* Now backup to find the first entry in the set. */
10655 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10658 return shndx_pool
+ i
;
10661 /* Display a .debug_cu_index or .debug_tu_index section. */
10664 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10666 return process_cu_tu_index (section
, 1);
10670 display_debug_not_supported (struct dwarf_section
*section
,
10671 void *file ATTRIBUTE_UNUSED
)
10673 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10679 /* Like malloc, but takes two parameters like calloc.
10680 Verifies that the first parameter is not too large.
10681 Note: does *not* initialise the allocated memory to zero. */
10684 cmalloc (size_t nmemb
, size_t size
)
10686 /* Check for overflow. */
10687 if (nmemb
>= ~(size_t) 0 / size
)
10690 return xmalloc (nmemb
* size
);
10693 /* Like xmalloc, but takes two parameters like calloc.
10694 Verifies that the first parameter is not too large.
10695 Note: does *not* initialise the allocated memory to zero. */
10698 xcmalloc (size_t nmemb
, size_t size
)
10700 /* Check for overflow. */
10701 if (nmemb
>= ~(size_t) 0 / size
)
10704 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10709 return xmalloc (nmemb
* size
);
10712 /* Like xrealloc, but takes three parameters.
10713 Verifies that the second parameter is not too large.
10714 Note: does *not* initialise any new memory to zero. */
10717 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10719 /* Check for overflow. */
10720 if (nmemb
>= ~(size_t) 0 / size
)
10722 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10727 return xrealloc (ptr
, nmemb
* size
);
10730 /* Like xcalloc, but verifies that the first parameter is not too large. */
10733 xcalloc2 (size_t nmemb
, size_t size
)
10735 /* Check for overflow. */
10736 if (nmemb
>= ~(size_t) 0 / size
)
10738 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10743 return xcalloc (nmemb
, size
);
10746 static unsigned long
10747 calc_gnu_debuglink_crc32 (unsigned long crc
,
10748 const unsigned char * buf
,
10751 static const unsigned long crc32_table
[256] =
10753 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10754 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10755 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10756 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10757 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10758 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10759 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10760 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10761 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10762 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10763 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10764 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10765 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10766 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10767 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10768 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10769 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10770 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10771 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10772 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10773 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10774 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10775 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10776 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10777 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10778 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10779 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10780 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10781 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10782 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10783 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10784 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10785 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10786 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10787 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10788 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10789 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10790 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10791 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10792 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10793 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10794 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10795 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10796 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10797 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10798 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10799 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10800 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10801 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10802 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10803 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10806 const unsigned char *end
;
10808 crc
= ~crc
& 0xffffffff;
10809 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10810 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10811 return ~crc
& 0xffffffff;
10814 typedef bool (*check_func_type
) (const char *, void *);
10815 typedef const char *(* parse_func_type
) (struct dwarf_section
*, void *);
10818 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10820 static unsigned char buffer
[8 * 1024];
10822 bfd_size_type count
;
10823 unsigned long crc
= 0;
10826 sep_data
= open_debug_file (pathname
);
10827 if (sep_data
== NULL
)
10830 /* Yes - we are opening the file twice... */
10831 f
= fopen (pathname
, "rb");
10834 /* Paranoia: This should never happen. */
10835 close_debug_file (sep_data
);
10836 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10840 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10841 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10845 if (crc
!= * (unsigned long *) crc_pointer
)
10847 close_debug_file (sep_data
);
10848 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10856 static const char *
10857 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10860 unsigned int crc_offset
;
10861 unsigned long * crc32
= (unsigned long *) data
;
10863 /* The name is first.
10864 The CRC value is stored after the filename, aligned up to 4 bytes. */
10865 name
= (const char *) section
->start
;
10867 crc_offset
= strnlen (name
, section
->size
) + 1;
10868 if (crc_offset
== 1)
10870 crc_offset
= (crc_offset
+ 3) & ~3;
10871 if (crc_offset
+ 4 > section
->size
)
10874 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10879 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10881 void * sep_data
= open_debug_file (filename
);
10883 if (sep_data
== NULL
)
10886 /* FIXME: We should now extract the build-id in the separate file
10892 typedef struct build_id_data
10895 const unsigned char * data
;
10898 static const char *
10899 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10902 bfd_size_type namelen
;
10903 bfd_size_type id_len
;
10904 Build_id_data
* build_id_data
;
10906 /* The name is first.
10907 The build-id follows immediately, with no padding, up to the section's end. */
10909 name
= (const char *) section
->start
;
10910 namelen
= strnlen (name
, section
->size
) + 1;
10913 if (namelen
>= section
->size
)
10916 id_len
= section
->size
- namelen
;
10920 build_id_data
= (Build_id_data
*) data
;
10921 build_id_data
->len
= id_len
;
10922 build_id_data
->data
= section
->start
+ namelen
;
10928 add_separate_debug_file (const char * filename
, void * handle
)
10930 separate_info
* i
= xmalloc (sizeof * i
);
10932 i
->filename
= filename
;
10933 i
->handle
= handle
;
10934 i
->next
= first_separate_info
;
10935 first_separate_info
= i
;
10938 #if HAVE_LIBDEBUGINFOD
10939 /* Query debuginfod servers for the target debuglink or debugaltlink
10940 file. If successful, store the path of the file in filename and
10941 return TRUE, otherwise return FALSE. */
10944 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10948 size_t build_id_len
;
10949 unsigned char * build_id
;
10951 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10953 /* Get the build-id of file. */
10954 build_id
= get_build_id (file
);
10957 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10959 /* Get the build-id of the debugaltlink file. */
10960 unsigned int filelen
;
10962 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10963 if (filelen
== section
->size
)
10964 /* Corrupt debugaltlink. */
10967 build_id
= section
->start
+ filelen
+ 1;
10968 build_id_len
= section
->size
- (filelen
+ 1);
10970 if (build_id_len
== 0)
10979 debuginfod_client
* client
;
10981 client
= debuginfod_begin ();
10982 if (client
== NULL
)
10985 /* Query debuginfod servers for the target file. If found its path
10986 will be stored in filename. */
10987 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10988 debuginfod_end (client
);
10990 /* Only free build_id if we allocated space for a hex string
10991 in get_build_id (). */
10992 if (build_id_len
== 0)
10997 /* File successfully retrieved. Close fd since we want to
10998 use open_debug_file () on filename instead. */
11009 load_separate_debug_info (const char * main_filename
,
11010 struct dwarf_section
* xlink
,
11011 parse_func_type parse_func
,
11012 check_func_type check_func
,
11014 void * file ATTRIBUTE_UNUSED
)
11016 const char * separate_filename
;
11017 char * debug_filename
;
11019 size_t canon_dirlen
;
11022 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
11024 warn (_("Corrupt debuglink section: %s\n"),
11025 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
11029 /* Attempt to locate the separate file.
11030 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
11032 canon_dir
= lrealpath (main_filename
);
11034 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
11035 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
11037 canon_dir
[canon_dirlen
] = '\0';
11040 #define DEBUGDIR "/lib/debug"
11042 #ifndef EXTRA_DEBUG_ROOT1
11043 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
11045 #ifndef EXTRA_DEBUG_ROOT2
11046 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
11049 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
11051 + strlen (".debug/")
11052 #ifdef EXTRA_DEBUG_ROOT1
11053 + strlen (EXTRA_DEBUG_ROOT1
)
11055 #ifdef EXTRA_DEBUG_ROOT2
11056 + strlen (EXTRA_DEBUG_ROOT2
)
11058 + strlen (separate_filename
)
11060 if (debug_filename
== NULL
)
11062 warn (_("Out of memory"));
11067 /* First try in the current directory. */
11068 sprintf (debug_filename
, "%s", separate_filename
);
11069 if (check_func (debug_filename
, func_data
))
11072 /* Then try in a subdirectory called .debug. */
11073 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11074 if (check_func (debug_filename
, func_data
))
11077 /* Then try in the same directory as the original file. */
11078 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11079 if (check_func (debug_filename
, func_data
))
11082 /* And the .debug subdirectory of that directory. */
11083 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11084 if (check_func (debug_filename
, func_data
))
11087 #ifdef EXTRA_DEBUG_ROOT1
11088 /* Try the first extra debug file root. */
11089 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11090 if (check_func (debug_filename
, func_data
))
11093 /* Try the first extra debug file root. */
11094 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
11095 if (check_func (debug_filename
, func_data
))
11099 #ifdef EXTRA_DEBUG_ROOT2
11100 /* Try the second extra debug file root. */
11101 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
11102 if (check_func (debug_filename
, func_data
))
11106 /* Then try in the global debug_filename directory. */
11107 strcpy (debug_filename
, DEBUGDIR
);
11108 dirlen
= strlen (DEBUGDIR
) - 1;
11109 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
11110 strcat (debug_filename
, "/");
11111 strcat (debug_filename
, (const char *) separate_filename
);
11113 if (check_func (debug_filename
, func_data
))
11116 #if HAVE_LIBDEBUGINFOD
11118 char * tmp_filename
;
11120 if (debuginfod_fetch_separate_debug_info (xlink
,
11124 /* File successfully downloaded from server, replace
11125 debug_filename with the file's path. */
11126 free (debug_filename
);
11127 debug_filename
= tmp_filename
;
11133 if (do_debug_links
)
11135 /* Failed to find the file. */
11136 warn (_("could not find separate debug file '%s'\n"),
11137 separate_filename
);
11138 warn (_("tried: %s\n"), debug_filename
);
11140 #ifdef EXTRA_DEBUG_ROOT2
11141 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
,
11142 separate_filename
);
11143 warn (_("tried: %s\n"), debug_filename
);
11146 #ifdef EXTRA_DEBUG_ROOT1
11147 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
,
11148 canon_dir
, separate_filename
);
11149 warn (_("tried: %s\n"), debug_filename
);
11151 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
,
11152 separate_filename
);
11153 warn (_("tried: %s\n"), debug_filename
);
11156 sprintf (debug_filename
, "%s.debug/%s", canon_dir
,
11157 separate_filename
);
11158 warn (_("tried: %s\n"), debug_filename
);
11160 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11161 warn (_("tried: %s\n"), debug_filename
);
11163 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11164 warn (_("tried: %s\n"), debug_filename
);
11166 sprintf (debug_filename
, "%s", separate_filename
);
11167 warn (_("tried: %s\n"), debug_filename
);
11169 #if HAVE_LIBDEBUGINFOD
11171 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11175 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11181 free (debug_filename
);
11187 void * debug_handle
;
11189 /* Now open the file.... */
11190 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11192 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11193 free (debug_filename
);
11197 /* FIXME: We do not check to see if there are any other separate debug info
11198 files that would also match. */
11200 if (do_debug_links
)
11201 printf (_("\n%s: Found separate debug info file: %s\n"), main_filename
, debug_filename
);
11202 add_separate_debug_file (debug_filename
, debug_handle
);
11204 /* Do not free debug_filename - it might be referenced inside
11205 the structure returned by open_debug_file(). */
11206 return debug_handle
;
11209 /* Attempt to load a separate dwarf object file. */
11212 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11214 char * separate_filename
;
11215 void * separate_handle
;
11217 if (IS_ABSOLUTE_PATH (name
))
11218 separate_filename
= strdup (name
);
11220 /* FIXME: Skip adding / if dwo_dir ends in /. */
11221 separate_filename
= concat (dir
, "/", name
, NULL
);
11222 if (separate_filename
== NULL
)
11224 warn (_("Out of memory allocating dwo filename\n"));
11228 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11230 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11231 free (separate_filename
);
11235 /* FIXME: We should check the dwo_id. */
11237 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11239 add_separate_debug_file (separate_filename
, separate_handle
);
11240 /* Note - separate_filename will be freed in free_debug_memory(). */
11241 return separate_handle
;
11245 load_debug_sup_file (const char * main_filename
, void * file
)
11247 if (! load_debug_section (debug_sup
, file
))
11248 return; /* No .debug_sup section. */
11250 struct dwarf_section
* section
;
11251 section
= & debug_displays
[debug_sup
].section
;
11252 assert (section
!= NULL
);
11254 if (section
->start
== NULL
|| section
->size
< 5)
11256 warn (_(".debug_sup section is corrupt/empty\n"));
11260 if (section
->start
[2] != 0)
11261 return; /* This is a supplementary file. */
11263 const char * filename
= (const char *) section
->start
+ 3;
11264 if (strnlen (filename
, section
->size
- 3) == section
->size
- 3)
11266 warn (_("filename in .debug_sup section is corrupt\n"));
11270 if (filename
[0] != '/' && strchr (main_filename
, '/'))
11275 new_len
= asprintf (& new_name
, "%.*s/%s",
11276 (int) (strrchr (main_filename
, '/') - main_filename
),
11281 warn (_("unable to construct path for supplementary debug file"));
11286 filename
= new_name
;
11290 /* PR 27796: Make sure that we pass a filename that can be free'd to
11291 add_separate_debug_file(). */
11292 filename
= strdup (filename
);
11293 if (filename
== NULL
)
11295 warn (_("out of memory constructing filename for .debug_sup link\n"));
11300 void * handle
= open_debug_file (filename
);
11301 if (handle
== NULL
)
11303 warn (_("unable to open file '%s' referenced from .debug_sup section\n"), filename
);
11304 free ((void *) filename
);
11308 printf (_("%s: Found supplementary debug file: %s\n\n"), main_filename
, filename
);
11310 /* FIXME: Compare the checksums, if present. */
11311 add_separate_debug_file (filename
, handle
);
11314 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11315 Recursively check the loaded files for more of these sections.
11316 Also follow any links in .debug_sup sections.
11317 FIXME: Should also check for DWO_* entries in the newly loaded files. */
11320 check_for_and_load_links (void * file
, const char * filename
)
11322 void * handle
= NULL
;
11324 if (load_debug_section (gnu_debugaltlink
, file
))
11326 Build_id_data build_id_data
;
11328 handle
= load_separate_debug_info (filename
,
11329 & debug_displays
[gnu_debugaltlink
].section
,
11330 parse_gnu_debugaltlink
,
11331 check_gnu_debugaltlink
,
11336 assert (handle
== first_separate_info
->handle
);
11337 check_for_and_load_links (first_separate_info
->handle
,
11338 first_separate_info
->filename
);
11342 if (load_debug_section (gnu_debuglink
, file
))
11344 unsigned long crc32
;
11346 handle
= load_separate_debug_info (filename
,
11347 & debug_displays
[gnu_debuglink
].section
,
11348 parse_gnu_debuglink
,
11349 check_gnu_debuglink
,
11354 assert (handle
== first_separate_info
->handle
);
11355 check_for_and_load_links (first_separate_info
->handle
,
11356 first_separate_info
->filename
);
11360 load_debug_sup_file (filename
, file
);
11363 /* Load the separate debug info file(s) attached to FILE, if any exist.
11364 Returns TRUE if any were found, FALSE otherwise.
11365 If TRUE is returned then the linked list starting at first_separate_info
11366 will be populated with open file handles. */
11369 load_separate_debug_files (void * file
, const char * filename
)
11371 /* Skip this operation if we are not interested in debug links. */
11372 if (! do_follow_links
&& ! do_debug_links
)
11375 /* See if there are any dwo links. */
11376 if (load_debug_section (str
, file
)
11377 && load_debug_section (abbrev
, file
)
11378 && load_debug_section (info
, file
))
11382 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
,
11385 bool introduced
= false;
11387 const char *dir
= NULL
;
11388 const char *id
= NULL
;
11389 const char *name
= NULL
;
11391 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11393 /* Accumulate NAME, DIR and ID fields. */
11394 switch (dwinfo
->type
)
11398 warn (_("Multiple DWO_NAMEs encountered for the same CU\n"));
11399 name
= dwinfo
->value
;
11403 /* There can be multiple DW_AT_comp_dir entries in a CU,
11404 so do not complain. */
11405 dir
= dwinfo
->value
;
11410 warn (_("multiple DWO_IDs encountered for the same CU\n"));
11411 id
= dwinfo
->value
;
11415 error (_("Unexpected DWO INFO type"));
11419 /* If we have reached the end of our list, or we are changing
11420 CUs, then display the information that we have accumulated
11423 && (dwinfo
->next
== NULL
11424 || dwinfo
->next
->cu_offset
!= dwinfo
->cu_offset
))
11426 if (do_debug_links
)
11430 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11431 debug_displays
[info
].section
.uncompressed_name
);
11435 printf (_(" Name: %s\n"), name
);
11436 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11438 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11440 printf (_(" ID: <not specified>\n"));
11444 if (do_follow_links
)
11445 load_dwo_file (filename
, name
, dir
, id
);
11447 name
= dir
= id
= NULL
;
11453 if (! do_follow_links
)
11454 /* The other debug links will be displayed by display_debug_links()
11455 so we do not need to do any further processing here. */
11458 /* FIXME: We do not check for the presence of both link sections in the same file. */
11459 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11460 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11462 check_for_and_load_links (file
, filename
);
11463 if (first_separate_info
!= NULL
)
11466 do_follow_links
= 0;
11471 free_debug_memory (void)
11475 free_all_abbrevs ();
11477 free (cu_abbrev_map
);
11478 cu_abbrev_map
= NULL
;
11479 next_free_abbrev_map_entry
= 0;
11483 shndx_pool_size
= 0;
11484 shndx_pool_used
= 0;
11492 memset (level_type_signed
, 0, sizeof level_type_signed
);
11493 cu_tu_indexes_read
= -1;
11495 for (i
= 0; i
< max
; i
++)
11496 free_debug_section ((enum dwarf_section_display_enum
) i
);
11498 if (debug_information
!= NULL
)
11500 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
11502 if (debug_information
[i
].max_loc_offsets
)
11504 free (debug_information
[i
].loc_offsets
);
11505 free (debug_information
[i
].have_frame_base
);
11507 if (debug_information
[i
].max_range_lists
)
11508 free (debug_information
[i
].range_lists
);
11510 free (debug_information
);
11511 debug_information
= NULL
;
11512 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
11516 separate_info
* next
;
11518 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
11520 close_debug_file (d
->handle
);
11521 free ((void *) d
->filename
);
11525 first_separate_info
= NULL
;
11531 dwarf_select_sections_by_names (const char *names
)
11535 const char * option
;
11539 debug_dump_long_opts
;
11541 static const debug_dump_long_opts opts_table
[] =
11543 /* Please keep this table alpha- sorted. */
11544 { "Ranges", & do_debug_ranges
, 1 },
11545 { "abbrev", & do_debug_abbrevs
, 1 },
11546 { "addr", & do_debug_addr
, 1 },
11547 { "aranges", & do_debug_aranges
, 1 },
11548 { "cu_index", & do_debug_cu_index
, 1 },
11549 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
11550 { "follow-links", & do_follow_links
, 1 },
11551 { "frames", & do_debug_frames
, 1 },
11552 { "frames-interp", & do_debug_frames_interp
, 1 },
11553 /* The special .gdb_index section. */
11554 { "gdb_index", & do_gdb_index
, 1 },
11555 { "info", & do_debug_info
, 1 },
11556 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
11557 { "links", & do_debug_links
, 1 },
11558 { "loc", & do_debug_loc
, 1 },
11559 { "macro", & do_debug_macinfo
, 1 },
11560 { "no-follow-links", & do_follow_links
, 0 },
11561 { "pubnames", & do_debug_pubnames
, 1 },
11562 { "pubtypes", & do_debug_pubtypes
, 1 },
11563 /* This entry is for compatibility
11564 with earlier versions of readelf. */
11565 { "ranges", & do_debug_aranges
, 1 },
11566 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
11567 { "str", & do_debug_str
, 1 },
11568 { "str-offsets", & do_debug_str_offsets
, 1 },
11569 /* These trace_* sections are used by Itanium VMS. */
11570 { "trace_abbrev", & do_trace_abbrevs
, 1 },
11571 { "trace_aranges", & do_trace_aranges
, 1 },
11572 { "trace_info", & do_trace_info
, 1 },
11581 const debug_dump_long_opts
* entry
;
11583 for (entry
= opts_table
; entry
->option
; entry
++)
11585 size_t len
= strlen (entry
->option
);
11587 if (strncmp (p
, entry
->option
, len
) == 0
11588 && (p
[len
] == ',' || p
[len
] == '\0'))
11590 * entry
->variable
= entry
->val
;
11592 /* The --debug-dump=frames-interp option also
11593 enables the --debug-dump=frames option. */
11594 if (do_debug_frames_interp
)
11595 do_debug_frames
= 1;
11602 if (entry
->option
== NULL
)
11604 warn (_("Unrecognized debug option '%s'\n"), p
);
11605 p
= strchr (p
, ',');
11616 dwarf_select_sections_by_letters (const char *letters
)
11618 unsigned int lindex
= 0;
11620 while (letters
[lindex
])
11621 switch (letters
[lindex
++])
11623 case 'A': do_debug_addr
= 1; break;
11624 case 'a': do_debug_abbrevs
= 1; break;
11625 case 'c': do_debug_cu_index
= 1; break;
11626 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
11627 case 'f': do_debug_frames
= 1; break;
11628 case 'g': do_gdb_index
= 1; break;
11629 case 'i': do_debug_info
= 1; break;
11630 case 'K': do_follow_links
= 1; break;
11631 case 'N': do_follow_links
= 0; break;
11632 case 'k': do_debug_links
= 1; break;
11633 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
11634 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
11635 case 'm': do_debug_macinfo
= 1; break;
11636 case 'O': do_debug_str_offsets
= 1; break;
11637 case 'o': do_debug_loc
= 1; break;
11638 case 'p': do_debug_pubnames
= 1; break;
11639 case 'R': do_debug_ranges
= 1; break;
11640 case 'r': do_debug_aranges
= 1; break;
11641 case 's': do_debug_str
= 1; break;
11642 case 'T': do_trace_aranges
= 1; break;
11643 case 't': do_debug_pubtypes
= 1; break;
11644 case 'U': do_trace_info
= 1; break;
11645 case 'u': do_trace_abbrevs
= 1; break;
11648 warn (_("Unrecognized debug option '%s'\n"), letters
);
11654 dwarf_select_sections_all (void)
11657 do_debug_abbrevs
= 1;
11658 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
11659 do_debug_pubnames
= 1;
11660 do_debug_pubtypes
= 1;
11661 do_debug_aranges
= 1;
11662 do_debug_ranges
= 1;
11663 do_debug_frames
= 1;
11664 do_debug_macinfo
= 1;
11669 do_trace_abbrevs
= 1;
11670 do_trace_aranges
= 1;
11672 do_debug_cu_index
= 1;
11673 do_follow_links
= 1;
11674 do_debug_links
= 1;
11675 do_debug_str_offsets
= 1;
11678 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0
11679 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0
11681 /* N.B. The order here must match the order in section_display_enum. */
11683 struct dwarf_section_display debug_displays
[] =
11685 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11686 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, true },
11687 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11688 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, true },
11689 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11690 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, false },
11691 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, false },
11692 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11693 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11694 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11695 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11696 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11697 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11698 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11699 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, false },
11700 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, false },
11701 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11702 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11703 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11704 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11705 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, true },
11706 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11707 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, false },
11708 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, false },
11709 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, true },
11710 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, false },
11711 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, false },
11712 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, true },
11713 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11714 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, true },
11715 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11716 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11717 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11718 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11719 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, true },
11720 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11721 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11722 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, true },
11723 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11724 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11725 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11726 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11727 { { ".debug_sup", "", NO_ABBREVS
}, display_debug_sup
, &do_debug_links
, false },
11728 /* Separate debug info files can containt their own .debug_str section,
11729 and this might be in *addition* to a .debug_str section already present
11730 in the main file. Hence we need to have two entries for .debug_str. */
11731 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11734 /* A static assertion. */
11735 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];