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 unsigned char *cu_end
,
2070 const struct dwarf_section
*section
,
2071 unsigned long *abbrev_num_return
,
2072 unsigned char **data_return
,
2073 abbrev_map
**map_return
)
2075 unsigned long abbrev_number
;
2077 abbrev_entry
* entry
;
2078 unsigned char * data
;
2080 if (abbrev_num_return
!= NULL
)
2081 * abbrev_num_return
= 0;
2082 if (data_return
!= NULL
)
2083 * data_return
= NULL
;
2087 case DW_FORM_GNU_ref_alt
:
2088 case DW_FORM_ref_sig8
:
2089 /* FIXME: We are unable to handle this form at the moment. */
2092 case DW_FORM_ref_addr
:
2093 if (uvalue
>= section
->size
)
2095 warn (_("Unable to resolve ref_addr form: uvalue %lx > section size %lx (%s)\n"),
2096 uvalue
, (long) section
->size
, section
->name
);
2101 case DW_FORM_ref_sup4
:
2102 case DW_FORM_ref_sup8
:
2109 case DW_FORM_ref_udata
:
2110 if (uvalue
+ cu_offset
> (size_t) (cu_end
- section
->start
))
2112 warn (_("Unable to resolve ref form: uvalue %lx + cu_offset %lx > CU size %lx\n"),
2113 uvalue
, (long) cu_offset
, (long) (cu_end
- section
->start
));
2116 uvalue
+= cu_offset
;
2119 /* FIXME: Are there other DW_FORMs that can be used by types ? */
2122 warn (_("Unexpected form %lx encountered whilst finding abbreviation for type\n"), form
);
2126 data
= (unsigned char *) section
->start
+ uvalue
;
2127 map
= find_abbrev_map_by_offset (uvalue
);
2131 warn (_("Unable to find abbreviations for CU offset %#lx\n"), uvalue
);
2134 if (map
->list
== NULL
)
2136 warn (_("Empty abbreviation list encountered for CU offset %lx\n"), uvalue
);
2140 if (map_return
!= NULL
)
2142 if (form
== DW_FORM_ref_addr
)
2148 READ_ULEB (abbrev_number
, data
, section
->start
+ section
->size
);
2150 for (entry
= map
->list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2151 if (entry
->number
== abbrev_number
)
2154 if (abbrev_num_return
!= NULL
)
2155 * abbrev_num_return
= abbrev_number
;
2157 if (data_return
!= NULL
)
2158 * data_return
= data
;
2161 warn (_("Unable to find entry for abbreviation %lu\n"), abbrev_number
);
2166 /* Return IS_SIGNED set to TRUE if the type using abbreviation ENTRY
2167 can be determined to be a signed type. The data for ENTRY can be
2168 found starting at DATA. */
2171 get_type_signedness (abbrev_entry
*entry
,
2172 const struct dwarf_section
*section
,
2173 unsigned char *data
,
2175 dwarf_vma cu_offset
,
2176 dwarf_vma pointer_size
,
2177 dwarf_vma offset_size
,
2180 unsigned int nesting
)
2184 * is_signed
= false;
2186 #define MAX_NESTING 20
2187 if (nesting
> MAX_NESTING
)
2189 /* FIXME: Warn - or is this expected ?
2190 NB/ We need to avoid infinite recursion. */
2194 for (attr
= entry
->first_attr
;
2195 attr
!= NULL
&& attr
->attribute
;
2198 unsigned char * orig_data
= data
;
2199 dwarf_vma uvalue
= 0;
2201 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
2202 offset_size
, dwarf_version
, & uvalue
);
2206 switch (attr
->attribute
)
2208 case DW_AT_linkage_name
:
2212 if (attr
->form
== DW_FORM_strp
)
2213 printf (", %s", fetch_indirect_string (uvalue
));
2214 else if (attr
->form
== DW_FORM_string
)
2215 printf (", %.*s", (int) (end
- orig_data
), orig_data
);
2222 abbrev_entry
*type_abbrev
;
2223 unsigned char *type_data
;
2226 type_abbrev
= get_type_abbrev_from_form (attr
->form
,
2231 NULL
/* abbrev num return */,
2234 if (type_abbrev
== NULL
)
2237 get_type_signedness (type_abbrev
, section
, type_data
,
2238 map
? section
->start
+ map
->end
: end
,
2239 map
? map
->start
: cu_offset
,
2240 pointer_size
, offset_size
, dwarf_version
,
2241 is_signed
, nesting
+ 1);
2245 case DW_AT_encoding
:
2246 /* Determine signness. */
2249 case DW_ATE_address
:
2250 /* FIXME - some architectures have signed addresses. */
2251 case DW_ATE_boolean
:
2252 case DW_ATE_unsigned
:
2253 case DW_ATE_unsigned_char
:
2254 case DW_ATE_unsigned_fixed
:
2255 * is_signed
= false;
2259 case DW_ATE_complex_float
:
2262 case DW_ATE_signed_char
:
2263 case DW_ATE_imaginary_float
:
2264 case DW_ATE_decimal_float
:
2265 case DW_ATE_signed_fixed
:
2275 read_and_print_leb128 (unsigned char *data
,
2276 unsigned int *bytes_read
,
2277 unsigned const char *end
,
2281 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2283 report_leb_status (status
);
2285 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2289 display_discr_list (unsigned long form
,
2291 unsigned char * data
,
2294 unsigned char *end
= data
;
2298 printf ("[default]");
2305 case DW_FORM_block1
:
2306 case DW_FORM_block2
:
2307 case DW_FORM_block4
:
2308 /* Move data pointer back to the start of the byte array. */
2312 printf ("<corrupt>\n");
2313 warn (_("corrupt discr_list - not using a block form\n"));
2319 printf ("<corrupt>\n");
2320 warn (_("corrupt discr_list - block not long enough\n"));
2324 bool is_signed
= (level
> 0 && level
<= MAX_CU_NESTING
2325 ? level_type_signed
[level
- 1] : false);
2330 unsigned char discriminant
;
2331 unsigned int bytes_read
;
2333 SAFE_BYTE_GET_AND_INC (discriminant
, data
, 1, end
);
2335 switch (discriminant
)
2339 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2345 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2349 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2354 printf ("<corrupt>\n");
2355 warn (_("corrupt discr_list - unrecognized discriminant byte %#x\n"),
2365 printf (")(signed)");
2367 printf (")(unsigned)");
2370 static unsigned char *
2371 read_and_display_attr_value (unsigned long attribute
,
2373 dwarf_signed_vma implicit_const
,
2374 unsigned char * start
,
2375 unsigned char * data
,
2376 unsigned char * end
,
2377 dwarf_vma cu_offset
,
2378 dwarf_vma pointer_size
,
2379 dwarf_vma offset_size
,
2381 debug_info
* debug_info_p
,
2383 struct dwarf_section
* section
,
2384 struct cu_tu_set
* this_set
,
2388 dwarf_signed_vma svalue
;
2389 dwarf_vma uvalue
= 0;
2390 dwarf_vma uvalue_hi
= 0;
2391 unsigned char *block_start
= NULL
;
2392 unsigned char *orig_data
= data
;
2394 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2396 warn (_("Corrupt attribute\n"));
2400 if (do_wide
&& ! do_loc
)
2402 /* PR 26847: Display the name of the form. */
2403 const char * name
= get_FORM_name (form
);
2405 /* For convenience we skip the DW_FORM_ prefix to the name. */
2407 name
+= 8; /* strlen ("DW_FORM_") */
2408 printf ("%c(%s)", delimiter
, name
);
2416 case DW_FORM_ref_addr
:
2417 if (dwarf_version
== 2)
2418 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2419 else if (dwarf_version
> 2)
2420 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2422 error (_("Internal error: DW_FORM_ref_addr is not supported in DWARF version 1.\n"));
2426 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2429 case DW_FORM_strp_sup
:
2431 case DW_FORM_line_strp
:
2432 case DW_FORM_sec_offset
:
2433 case DW_FORM_GNU_ref_alt
:
2434 case DW_FORM_GNU_strp_alt
:
2435 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2438 case DW_FORM_flag_present
:
2446 case DW_FORM_addrx1
:
2447 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2453 case DW_FORM_addrx2
:
2454 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2458 case DW_FORM_addrx3
:
2459 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 3, end
);
2462 case DW_FORM_ref_sup4
:
2466 case DW_FORM_addrx4
:
2467 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2470 case DW_FORM_ref_sup8
:
2473 case DW_FORM_ref_sig8
:
2474 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2477 case DW_FORM_data16
:
2478 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 8, end
);
2479 SAFE_BYTE_GET_AND_INC (uvalue_hi
, data
, 8, end
);
2480 if (byte_get
!= byte_get_little_endian
)
2482 dwarf_vma utmp
= uvalue
;
2489 READ_SLEB (svalue
, data
, end
);
2493 case DW_FORM_GNU_str_index
:
2495 case DW_FORM_ref_udata
:
2497 case DW_FORM_GNU_addr_index
:
2499 READ_ULEB (uvalue
, data
, end
);
2502 case DW_FORM_indirect
:
2503 READ_ULEB (form
, data
, end
);
2505 printf ("%c%s", delimiter
, get_FORM_name (form
));
2506 if (form
== DW_FORM_implicit_const
)
2507 READ_SLEB (implicit_const
, data
, end
);
2508 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2510 cu_offset
, pointer_size
,
2511 offset_size
, dwarf_version
,
2512 debug_info_p
, do_loc
,
2513 section
, this_set
, delimiter
, level
);
2515 case DW_FORM_implicit_const
:
2516 uvalue
= implicit_const
;
2522 case DW_FORM_ref_addr
:
2524 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2527 case DW_FORM_GNU_ref_alt
:
2531 /* We have already printed the form name. */
2532 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2534 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2536 /* FIXME: Follow the reference... */
2542 case DW_FORM_ref_sup4
:
2543 case DW_FORM_ref_udata
:
2545 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2550 case DW_FORM_sec_offset
:
2552 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2555 case DW_FORM_flag_present
:
2562 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2565 case DW_FORM_implicit_const
:
2567 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2570 case DW_FORM_ref_sup8
:
2575 dwarf_vma utmp
= uvalue
;
2576 if (form
== DW_FORM_ref8
)
2578 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", utmp
));
2582 case DW_FORM_data16
:
2585 uvalue_hi
== 0 ? "" : dwarf_vmatoa ("x", uvalue_hi
),
2586 dwarf_vmatoa_1 ("x", uvalue
, uvalue_hi
== 0 ? 0 : 8));
2589 case DW_FORM_string
:
2591 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2592 data
+= strnlen ((char *) data
, end
- data
);
2598 case DW_FORM_exprloc
:
2599 READ_ULEB (uvalue
, data
, end
);
2602 if (block_start
>= end
)
2604 warn (_("Block ends prematurely\n"));
2609 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2612 data
= block_start
+ uvalue
;
2614 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2617 case DW_FORM_block1
:
2618 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2621 case DW_FORM_block2
:
2622 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2625 case DW_FORM_block4
:
2626 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2633 /* We have already displayed the form name. */
2634 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2635 dwarf_vmatoa ("x", uvalue
),
2636 fetch_indirect_string (uvalue
));
2638 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2639 dwarf_vmatoa ("x", uvalue
),
2640 fetch_indirect_string (uvalue
));
2644 case DW_FORM_line_strp
:
2648 /* We have already displayed the form name. */
2649 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2650 dwarf_vmatoa ("x", uvalue
),
2651 fetch_indirect_line_string (uvalue
));
2653 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2654 dwarf_vmatoa ("x", uvalue
),
2655 fetch_indirect_line_string (uvalue
));
2659 case DW_FORM_GNU_str_index
:
2667 const char *suffix
= strrchr (section
->name
, '.');
2668 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
2671 /* We have already displayed the form name. */
2672 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2673 dwarf_vmatoa ("x", uvalue
),
2674 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2676 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2677 dwarf_vmatoa ("x", uvalue
),
2678 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2682 case DW_FORM_GNU_strp_alt
:
2686 /* We have already displayed the form name. */
2687 printf (_("%c(offset: 0x%s) %s"), delimiter
,
2688 dwarf_vmatoa ("x", uvalue
),
2689 fetch_alt_indirect_string (uvalue
));
2691 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2692 dwarf_vmatoa ("x", uvalue
),
2693 fetch_alt_indirect_string (uvalue
));
2697 case DW_FORM_indirect
:
2698 /* Handled above. */
2701 case DW_FORM_ref_sig8
:
2703 printf ("%c%s: 0x%s", delimiter
, do_wide
? "" : "signature",
2704 dwarf_vmatoa ("x", uvalue
));
2707 case DW_FORM_GNU_addr_index
:
2709 case DW_FORM_addrx1
:
2710 case DW_FORM_addrx2
:
2711 case DW_FORM_addrx3
:
2712 case DW_FORM_addrx4
:
2718 if (debug_info_p
== NULL
)
2720 else if (debug_info_p
->addr_base
== DEBUG_INFO_UNAVAILABLE
)
2723 base
= debug_info_p
->addr_base
;
2725 offset
= base
+ uvalue
* pointer_size
;
2728 /* We have already displayed the form name. */
2729 printf (_("%c(index: 0x%s): %s"), delimiter
,
2730 dwarf_vmatoa ("x", uvalue
),
2731 fetch_indexed_value (offset
, pointer_size
));
2733 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2734 dwarf_vmatoa ("x", uvalue
),
2735 fetch_indexed_value (offset
, pointer_size
));
2739 case DW_FORM_strp_sup
:
2741 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2745 warn (_("Unrecognized form: 0x%lx\n"), form
);
2746 /* What to do? Consume a byte maybe? */
2751 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2752 && num_debug_info_entries
== 0
2753 && debug_info_p
!= NULL
)
2757 case DW_AT_frame_base
:
2758 have_frame_base
= 1;
2760 case DW_AT_location
:
2761 case DW_AT_GNU_locviews
:
2762 case DW_AT_string_length
:
2763 case DW_AT_return_addr
:
2764 case DW_AT_data_member_location
:
2765 case DW_AT_vtable_elem_location
:
2767 case DW_AT_static_link
:
2768 case DW_AT_use_location
:
2769 case DW_AT_call_value
:
2770 case DW_AT_GNU_call_site_value
:
2771 case DW_AT_call_data_value
:
2772 case DW_AT_GNU_call_site_data_value
:
2773 case DW_AT_call_target
:
2774 case DW_AT_GNU_call_site_target
:
2775 case DW_AT_call_target_clobbered
:
2776 case DW_AT_GNU_call_site_target_clobbered
:
2777 if ((dwarf_version
< 4
2778 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2779 || form
== DW_FORM_sec_offset
)
2781 /* Process location list. */
2782 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2783 unsigned int num
= debug_info_p
->num_loc_offsets
;
2785 if (lmax
== 0 || num
>= lmax
)
2788 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2789 xcrealloc (debug_info_p
->loc_offsets
,
2790 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2791 debug_info_p
->loc_views
= (dwarf_vma
*)
2792 xcrealloc (debug_info_p
->loc_views
,
2793 lmax
, sizeof (*debug_info_p
->loc_views
));
2794 debug_info_p
->have_frame_base
= (int *)
2795 xcrealloc (debug_info_p
->have_frame_base
,
2796 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2797 debug_info_p
->max_loc_offsets
= lmax
;
2799 if (this_set
!= NULL
)
2800 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2801 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2802 if (attribute
!= DW_AT_GNU_locviews
)
2804 /* Corrupt DWARF info can produce more offsets than views.
2805 See PR 23062 for an example. */
2806 if (debug_info_p
->num_loc_offsets
2807 > debug_info_p
->num_loc_views
)
2808 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2811 debug_info_p
->loc_offsets
[num
] = uvalue
;
2812 debug_info_p
->num_loc_offsets
++;
2817 assert (debug_info_p
->num_loc_views
<= num
);
2818 num
= debug_info_p
->num_loc_views
;
2819 if (num
> debug_info_p
->num_loc_offsets
)
2820 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2823 debug_info_p
->loc_views
[num
] = uvalue
;
2824 debug_info_p
->num_loc_views
++;
2831 if (need_base_address
)
2832 debug_info_p
->base_address
= uvalue
;
2835 case DW_AT_GNU_addr_base
:
2836 case DW_AT_addr_base
:
2837 debug_info_p
->addr_base
= uvalue
;
2840 case DW_AT_GNU_ranges_base
:
2841 debug_info_p
->ranges_base
= uvalue
;
2845 if ((dwarf_version
< 4
2846 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2847 || form
== DW_FORM_sec_offset
)
2849 /* Process range list. */
2850 unsigned int lmax
= debug_info_p
->max_range_lists
;
2851 unsigned int num
= debug_info_p
->num_range_lists
;
2853 if (lmax
== 0 || num
>= lmax
)
2856 debug_info_p
->range_lists
= (dwarf_vma
*)
2857 xcrealloc (debug_info_p
->range_lists
,
2858 lmax
, sizeof (*debug_info_p
->range_lists
));
2859 debug_info_p
->max_range_lists
= lmax
;
2861 debug_info_p
->range_lists
[num
] = uvalue
;
2862 debug_info_p
->num_range_lists
++;
2866 case DW_AT_GNU_dwo_name
:
2867 case DW_AT_dwo_name
:
2872 add_dwo_name ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2874 case DW_FORM_GNU_strp_alt
:
2875 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
), cu_offset
);
2877 case DW_FORM_GNU_str_index
:
2883 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2885 case DW_FORM_string
:
2886 add_dwo_name ((const char *) orig_data
, cu_offset
);
2889 warn (_("Unsupported form (%s) for attribute %s\n"),
2890 get_FORM_name (form
), get_AT_name (attribute
));
2895 case DW_AT_comp_dir
:
2896 /* FIXME: Also extract a build-id in a CU/TU. */
2901 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2903 case DW_FORM_GNU_strp_alt
:
2904 add_dwo_dir (fetch_alt_indirect_string (uvalue
), cu_offset
);
2906 case DW_FORM_line_strp
:
2907 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
), cu_offset
);
2909 case DW_FORM_GNU_str_index
:
2915 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2917 case DW_FORM_string
:
2918 add_dwo_dir ((const char *) orig_data
, cu_offset
);
2921 warn (_("Unsupported form (%s) for attribute %s\n"),
2922 get_FORM_name (form
), get_AT_name (attribute
));
2927 case DW_AT_GNU_dwo_id
:
2932 /* FIXME: Record the length of the ID as well ? */
2933 add_dwo_id ((const char *) (data
- 8), cu_offset
);
2936 warn (_("Unsupported form (%s) for attribute %s\n"),
2937 get_FORM_name (form
), get_AT_name (attribute
));
2947 if (do_loc
|| attribute
== 0)
2950 /* For some attributes we can display further information. */
2954 if (level
>= 0 && level
< MAX_CU_NESTING
2955 && uvalue
< (size_t) (end
- start
))
2957 bool is_signed
= false;
2958 abbrev_entry
*type_abbrev
;
2959 unsigned char *type_data
;
2962 type_abbrev
= get_type_abbrev_from_form (form
, uvalue
,
2966 if (type_abbrev
!= NULL
)
2968 get_type_signedness (type_abbrev
, section
, type_data
,
2969 map
? section
->start
+ map
->end
: end
,
2970 map
? map
->start
: cu_offset
,
2971 pointer_size
, offset_size
, dwarf_version
,
2974 level_type_signed
[level
] = is_signed
;
2982 case DW_INL_not_inlined
:
2983 printf (_("(not inlined)"));
2985 case DW_INL_inlined
:
2986 printf (_("(inlined)"));
2988 case DW_INL_declared_not_inlined
:
2989 printf (_("(declared as inline but ignored)"));
2991 case DW_INL_declared_inlined
:
2992 printf (_("(declared as inline and inlined)"));
2995 printf (_(" (Unknown inline attribute value: %s)"),
2996 dwarf_vmatoa ("x", uvalue
));
3001 case DW_AT_language
:
3005 /* Ordered by the numeric value of these constants. */
3006 case DW_LANG_C89
: printf ("(ANSI C)"); break;
3007 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
3008 case DW_LANG_Ada83
: printf ("(Ada)"); break;
3009 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
3010 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
3011 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
3012 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
3013 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
3014 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
3015 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
3016 /* DWARF 2.1 values. */
3017 case DW_LANG_Java
: printf ("(Java)"); break;
3018 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
3019 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
3020 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
3021 /* DWARF 3 values. */
3022 case DW_LANG_PLI
: printf ("(PLI)"); break;
3023 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
3024 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
3025 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
3026 case DW_LANG_D
: printf ("(D)"); break;
3027 /* DWARF 4 values. */
3028 case DW_LANG_Python
: printf ("(Python)"); break;
3029 /* DWARF 5 values. */
3030 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
3031 case DW_LANG_Go
: printf ("(Go)"); break;
3032 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
3033 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
3034 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
3035 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
3036 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
3037 case DW_LANG_Rust
: printf ("(Rust)"); break;
3038 case DW_LANG_C11
: printf ("(C11)"); break;
3039 case DW_LANG_Swift
: printf ("(Swift)"); break;
3040 case DW_LANG_Julia
: printf ("(Julia)"); break;
3041 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
3042 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
3043 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
3044 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
3045 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
3046 /* MIPS extension. */
3047 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
3048 /* UPC extension. */
3049 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
3051 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
3052 printf (_("(implementation defined: %s)"),
3053 dwarf_vmatoa ("x", uvalue
));
3055 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
3060 case DW_AT_encoding
:
3064 case DW_ATE_void
: printf ("(void)"); break;
3065 case DW_ATE_address
: printf ("(machine address)"); break;
3066 case DW_ATE_boolean
: printf ("(boolean)"); break;
3067 case DW_ATE_complex_float
: printf ("(complex float)"); break;
3068 case DW_ATE_float
: printf ("(float)"); break;
3069 case DW_ATE_signed
: printf ("(signed)"); break;
3070 case DW_ATE_signed_char
: printf ("(signed char)"); break;
3071 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
3072 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
3073 /* DWARF 2.1 values: */
3074 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
3075 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
3076 /* DWARF 3 values: */
3077 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
3078 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
3079 case DW_ATE_edited
: printf ("(edited)"); break;
3080 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
3081 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
3082 /* DWARF 4 values: */
3083 case DW_ATE_UTF
: printf ("(unicode string)"); break;
3084 /* DWARF 5 values: */
3085 case DW_ATE_UCS
: printf ("(UCS)"); break;
3086 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
3088 /* HP extensions: */
3089 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
3090 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
3091 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
3092 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
3093 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
3094 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
3095 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
3098 if (uvalue
>= DW_ATE_lo_user
3099 && uvalue
<= DW_ATE_hi_user
)
3100 printf (_("(user defined type)"));
3102 printf (_("(unknown type)"));
3107 case DW_AT_accessibility
:
3111 case DW_ACCESS_public
: printf ("(public)"); break;
3112 case DW_ACCESS_protected
: printf ("(protected)"); break;
3113 case DW_ACCESS_private
: printf ("(private)"); break;
3115 printf (_("(unknown accessibility)"));
3120 case DW_AT_visibility
:
3124 case DW_VIS_local
: printf ("(local)"); break;
3125 case DW_VIS_exported
: printf ("(exported)"); break;
3126 case DW_VIS_qualified
: printf ("(qualified)"); break;
3127 default: printf (_("(unknown visibility)")); break;
3131 case DW_AT_endianity
:
3135 case DW_END_default
: printf ("(default)"); break;
3136 case DW_END_big
: printf ("(big)"); break;
3137 case DW_END_little
: printf ("(little)"); break;
3139 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
3140 printf (_("(user specified)"));
3142 printf (_("(unknown endianity)"));
3147 case DW_AT_virtuality
:
3151 case DW_VIRTUALITY_none
: printf ("(none)"); break;
3152 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
3153 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
3154 default: printf (_("(unknown virtuality)")); break;
3158 case DW_AT_identifier_case
:
3162 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
3163 case DW_ID_up_case
: printf ("(up_case)"); break;
3164 case DW_ID_down_case
: printf ("(down_case)"); break;
3165 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
3166 default: printf (_("(unknown case)")); break;
3170 case DW_AT_calling_convention
:
3174 case DW_CC_normal
: printf ("(normal)"); break;
3175 case DW_CC_program
: printf ("(program)"); break;
3176 case DW_CC_nocall
: printf ("(nocall)"); break;
3177 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
3178 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
3179 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
3180 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
3182 if (uvalue
>= DW_CC_lo_user
3183 && uvalue
<= DW_CC_hi_user
)
3184 printf (_("(user defined)"));
3186 printf (_("(unknown convention)"));
3190 case DW_AT_ordering
:
3195 case -1: printf (_("(undefined)")); break;
3196 case 0: printf ("(row major)"); break;
3197 case 1: printf ("(column major)"); break;
3201 case DW_AT_decimal_sign
:
3205 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
3206 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
3207 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
3208 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
3209 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
3210 default: printf (_("(unrecognised)")); break;
3214 case DW_AT_defaulted
:
3218 case DW_DEFAULTED_no
: printf (_("(no)")); break;
3219 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
3220 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
3221 default: printf (_("(unrecognised)")); break;
3225 case DW_AT_discr_list
:
3227 display_discr_list (form
, uvalue
, data
, level
);
3230 case DW_AT_frame_base
:
3231 have_frame_base
= 1;
3233 case DW_AT_location
:
3234 case DW_AT_string_length
:
3235 case DW_AT_return_addr
:
3236 case DW_AT_data_member_location
:
3237 case DW_AT_vtable_elem_location
:
3239 case DW_AT_static_link
:
3240 case DW_AT_use_location
:
3241 case DW_AT_call_value
:
3242 case DW_AT_GNU_call_site_value
:
3243 case DW_AT_call_data_value
:
3244 case DW_AT_GNU_call_site_data_value
:
3245 case DW_AT_call_target
:
3246 case DW_AT_GNU_call_site_target
:
3247 case DW_AT_call_target_clobbered
:
3248 case DW_AT_GNU_call_site_target_clobbered
:
3249 if ((dwarf_version
< 4
3250 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3251 || form
== DW_FORM_sec_offset
)
3252 printf (_(" (location list)"));
3254 case DW_AT_allocated
:
3255 case DW_AT_associated
:
3256 case DW_AT_data_location
:
3258 case DW_AT_upper_bound
:
3259 case DW_AT_lower_bound
:
3262 int need_frame_base
;
3265 need_frame_base
= decode_location_expression (block_start
,
3270 cu_offset
, section
);
3272 if (need_frame_base
&& !have_frame_base
)
3273 printf (_(" [without DW_AT_frame_base]"));
3277 case DW_AT_data_bit_offset
:
3278 case DW_AT_byte_size
:
3279 case DW_AT_bit_size
:
3280 case DW_AT_string_length_byte_size
:
3281 case DW_AT_string_length_bit_size
:
3282 case DW_AT_bit_stride
:
3283 if (form
== DW_FORM_exprloc
)
3286 (void) decode_location_expression (block_start
, pointer_size
,
3287 offset_size
, dwarf_version
,
3288 uvalue
, cu_offset
, section
);
3295 unsigned long abbrev_number
;
3296 abbrev_entry
*entry
;
3298 entry
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
, end
,
3299 section
, & abbrev_number
, NULL
, NULL
);
3302 if (form
!= DW_FORM_GNU_ref_alt
)
3303 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
3304 dwarf_vmatoa ("x", uvalue
),
3305 (unsigned long) (orig_data
- section
->start
));
3309 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3310 printf (" (%s)", get_TAG_name (entry
->tag
));
3323 static unsigned char *
3324 read_and_display_attr (unsigned long attribute
,
3326 dwarf_signed_vma implicit_const
,
3327 unsigned char * start
,
3328 unsigned char * data
,
3329 unsigned char * end
,
3330 dwarf_vma cu_offset
,
3331 dwarf_vma pointer_size
,
3332 dwarf_vma offset_size
,
3334 debug_info
* debug_info_p
,
3336 struct dwarf_section
* section
,
3337 struct cu_tu_set
* this_set
,
3341 printf (" %-18s:", get_AT_name (attribute
));
3342 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3344 cu_offset
, pointer_size
, offset_size
,
3345 dwarf_version
, debug_info_p
,
3346 do_loc
, section
, this_set
, ' ', level
);
3352 /* Like load_debug_section, but if the ordinary call fails, and we are
3353 following debug links, then attempt to load the requested section
3354 from one of the separate debug info files. */
3357 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3360 if (load_debug_section (sec_enum
, handle
))
3362 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3364 /* See if we can associate a filename with this section. */
3367 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3368 if (i
->handle
== handle
)
3370 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3378 if (do_follow_links
)
3382 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3384 if (load_debug_section (sec_enum
, i
->handle
))
3386 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3388 /* FIXME: We should check to see if any of the remaining debug info
3389 files also contain this section, and, umm, do something about it. */
3399 introduce (struct dwarf_section
* section
, bool raw
)
3403 if (do_follow_links
&& section
->filename
)
3404 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3405 section
->name
, section
->filename
);
3407 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3411 if (do_follow_links
&& section
->filename
)
3412 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3413 section
->name
, section
->filename
);
3415 printf (_("Contents of the %s section:\n\n"), section
->name
);
3419 /* Process the contents of a .debug_info section.
3420 If do_loc is TRUE then we are scanning for location lists and dwo tags
3421 and we do not want to display anything to the user.
3422 If do_types is TRUE, we are processing a .debug_types section instead of
3423 a .debug_info section.
3424 The information displayed is restricted by the values in DWARF_START_DIE
3425 and DWARF_CUTOFF_LEVEL.
3426 Returns TRUE upon success. Otherwise an error or warning message is
3427 printed and FALSE is returned. */
3430 process_debug_info (struct dwarf_section
* section
,
3432 enum dwarf_section_display_enum abbrev_sec
,
3436 unsigned char *start
= section
->start
;
3437 unsigned char *end
= start
+ section
->size
;
3438 unsigned char *section_begin
;
3440 unsigned int num_units
= 0;
3442 /* First scan the section to get the number of comp units.
3443 Length sanity checks are done here. */
3444 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3449 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3450 will be the length. For a 64-bit DWARF section, it'll be
3451 the escape code 0xffffffff followed by an 8 byte length. */
3452 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 4, end
);
3454 if (length
== 0xffffffff)
3455 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 8, end
);
3456 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3458 warn (_("Reserved length value (0x%s) found in section %s\n"),
3459 dwarf_vmatoa ("x", length
), section
->name
);
3463 /* Negative values are illegal, they may even cause infinite
3464 looping. This can happen if we can't accurately apply
3465 relocations to an object file, or if the file is corrupt. */
3466 if (length
> (size_t) (end
- section_begin
))
3468 warn (_("Corrupt unit length (got 0x%s expected at most 0x%s) in section %s\n"),
3469 dwarf_vmatoa ("x", length
),
3470 dwarf_vmatoa ("x", end
- section_begin
),
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
;
5305 if (linfo
.li_version
< 5)
5307 if (file_table
== NULL
|| n_files
== 0)
5308 printf (_("\n [Use file table entry %d]\n"), file
);
5310 else if (file
>= n_files
)
5312 warn (_("file index %u > number of files %u\n"), file
, n_files
);
5313 printf (_("\n <over large file table index %u>"), file
);
5315 else if ((dir
= file_table
[file
].directory_index
) == 0)
5316 /* If directory index is 0, that means current directory. */
5317 printf ("\n./%s:[++]\n", file_table
[file
].name
);
5318 else if (directory_table
== NULL
|| n_directories
== 0)
5319 printf (_("\n [Use file %s in directory table entry %d]\n"),
5320 file_table
[file
].name
, dir
);
5322 else if (dir
> n_directories
)
5324 warn (_("directory index %u > number of directories %s\n"),
5325 dir
, dwarf_vmatoa ("u", n_directories
));
5326 printf (_("\n <over large directory table entry %u>\n"), dir
);
5329 printf ("\n%s/%s:\n",
5330 /* The directory index starts counting at 1. */
5331 directory_table
[dir
- 1], file_table
[file
].name
);
5335 case DW_LNS_set_column
:
5336 READ_ULEB (uladv
, data
, end
);
5337 state_machine_regs
.column
= uladv
;
5340 case DW_LNS_negate_stmt
:
5341 adv
= state_machine_regs
.is_stmt
;
5343 state_machine_regs
.is_stmt
= adv
;
5346 case DW_LNS_set_basic_block
:
5347 state_machine_regs
.basic_block
= 1;
5350 case DW_LNS_const_add_pc
:
5351 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5352 if (linfo
.li_max_ops_per_insn
== 1)
5354 uladv
*= linfo
.li_min_insn_length
;
5355 state_machine_regs
.address
+= uladv
;
5357 state_machine_regs
.view
= 0;
5362 = ((state_machine_regs
.op_index
+ uladv
)
5363 / linfo
.li_max_ops_per_insn
)
5364 * linfo
.li_min_insn_length
;
5365 state_machine_regs
.address
5367 state_machine_regs
.op_index
5368 = (state_machine_regs
.op_index
+ uladv
)
5369 % linfo
.li_max_ops_per_insn
;
5371 state_machine_regs
.view
= 0;
5375 case DW_LNS_fixed_advance_pc
:
5376 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5377 state_machine_regs
.address
+= uladv
;
5378 state_machine_regs
.op_index
= 0;
5379 /* Do NOT reset view. */
5382 case DW_LNS_set_prologue_end
:
5385 case DW_LNS_set_epilogue_begin
:
5388 case DW_LNS_set_isa
:
5389 READ_ULEB (uladv
, data
, end
);
5390 printf (_(" Set ISA to %lu\n"), uladv
);
5394 printf (_(" Unknown opcode %d with operands: "), op_code
);
5396 if (standard_opcodes
!= NULL
)
5397 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5401 READ_ULEB (val
, data
, end
);
5402 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
5403 i
== 1 ? "" : ", ");
5409 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5410 to the DWARF address/line matrix. */
5411 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5412 || (xop
== DW_LNS_copy
))
5414 const unsigned int MAX_FILENAME_LENGTH
= 35;
5416 char *newFileName
= NULL
;
5417 size_t fileNameLength
;
5421 unsigned indx
= state_machine_regs
.file
;
5423 if (linfo
.li_version
< 5)
5426 if (indx
>= n_files
)
5428 warn (_("corrupt file index %u encountered\n"), indx
);
5429 fileName
= _("<corrupt>");
5432 fileName
= (char *) file_table
[indx
].name
;
5435 fileName
= _("<unknown>");
5437 fileNameLength
= strlen (fileName
);
5438 newFileName
= fileName
;
5439 if (fileNameLength
> MAX_FILENAME_LENGTH
&& !do_wide
)
5441 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5442 /* Truncate file name */
5443 memcpy (newFileName
,
5444 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5445 MAX_FILENAME_LENGTH
);
5446 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5449 /* A row with end_seq set to true has a meaningful address, but
5450 the other information in the same row is not significant.
5451 In such a row, print line as "-", and don't print
5453 if (!do_wide
|| fileNameLength
<= MAX_FILENAME_LENGTH
)
5455 if (linfo
.li_max_ops_per_insn
== 1)
5457 if (xop
== -DW_LNE_end_sequence
)
5458 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x",
5460 state_machine_regs
.address
);
5462 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
5463 newFileName
, state_machine_regs
.line
,
5464 state_machine_regs
.address
);
5468 if (xop
== -DW_LNE_end_sequence
)
5469 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5471 state_machine_regs
.address
,
5472 state_machine_regs
.op_index
);
5474 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5475 newFileName
, state_machine_regs
.line
,
5476 state_machine_regs
.address
,
5477 state_machine_regs
.op_index
);
5482 if (linfo
.li_max_ops_per_insn
== 1)
5484 if (xop
== -DW_LNE_end_sequence
)
5485 printf ("%s %11s %#18" DWARF_VMA_FMT
"x",
5487 state_machine_regs
.address
);
5489 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5490 newFileName
, state_machine_regs
.line
,
5491 state_machine_regs
.address
);
5495 if (xop
== -DW_LNE_end_sequence
)
5496 printf ("%s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5498 state_machine_regs
.address
,
5499 state_machine_regs
.op_index
);
5501 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5502 newFileName
, state_machine_regs
.line
,
5503 state_machine_regs
.address
,
5504 state_machine_regs
.op_index
);
5508 if (xop
!= -DW_LNE_end_sequence
)
5510 if (state_machine_regs
.view
)
5511 printf (" %6u", state_machine_regs
.view
);
5515 if (state_machine_regs
.is_stmt
)
5520 state_machine_regs
.view
++;
5522 if (xop
== -DW_LNE_end_sequence
)
5524 reset_state_machine (linfo
.li_default_is_stmt
);
5528 if (newFileName
!= fileName
)
5540 if (directory_table
)
5542 free (directory_table
);
5543 directory_table
= NULL
;
5554 display_debug_lines (struct dwarf_section
*section
, void *file
)
5556 unsigned char *data
= section
->start
;
5557 unsigned char *end
= data
+ section
->size
;
5559 int retValDecoded
= 1;
5561 if (do_debug_lines
== 0)
5562 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5564 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5565 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5567 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5568 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5570 if (!retValRaw
|| !retValDecoded
)
5577 find_debug_info_for_offset (unsigned long offset
)
5581 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5584 for (i
= 0; i
< num_debug_info_entries
; i
++)
5585 if (debug_information
[i
].cu_offset
== offset
)
5586 return debug_information
+ i
;
5592 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5594 /* See gdb/gdb-index.h. */
5595 static const char * const kinds
[] =
5607 return _ (kinds
[kind
]);
5611 display_debug_pubnames_worker (struct dwarf_section
*section
,
5612 void *file ATTRIBUTE_UNUSED
,
5615 DWARF2_Internal_PubNames names
;
5616 unsigned char *start
= section
->start
;
5617 unsigned char *end
= start
+ section
->size
;
5619 /* It does not matter if this load fails,
5620 we test for that later on. */
5621 load_debug_info (file
);
5623 introduce (section
, false);
5627 unsigned char *data
;
5628 unsigned long sec_off
= start
- section
->start
;
5629 unsigned int offset_size
;
5631 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5632 if (names
.pn_length
== 0xffffffff)
5634 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5640 if (names
.pn_length
> (size_t) (end
- start
))
5642 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5645 dwarf_vmatoa ("x", names
.pn_length
));
5650 start
+= names
.pn_length
;
5652 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, start
);
5653 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, start
);
5655 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5656 && num_debug_info_entries
> 0
5657 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5658 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5659 (unsigned long) names
.pn_offset
, section
->name
);
5661 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, start
);
5663 printf (_(" Length: %ld\n"),
5664 (long) names
.pn_length
);
5665 printf (_(" Version: %d\n"),
5667 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5668 (unsigned long) names
.pn_offset
);
5669 printf (_(" Size of area in .debug_info section: %ld\n"),
5670 (long) names
.pn_size
);
5672 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5674 static int warned
= 0;
5678 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5686 printf (_("\n Offset Kind Name\n"));
5688 printf (_("\n Offset\tName\n"));
5692 bfd_size_type maxprint
;
5695 SAFE_BYTE_GET_AND_INC (offset
, data
, offset_size
, start
);
5702 maxprint
= (start
- data
) - 1;
5706 unsigned int kind_data
;
5707 gdb_index_symbol_kind kind
;
5708 const char *kind_name
;
5711 SAFE_BYTE_GET_AND_INC (kind_data
, data
, 1, start
);
5713 /* GCC computes the kind as the upper byte in the CU index
5714 word, and then right shifts it by the CU index size.
5715 Left shift KIND to where the gdb-index.h accessor macros
5717 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5718 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5719 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5720 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5721 printf (" %-6lx %s,%-10s %.*s\n",
5722 (unsigned long) offset
, is_static
? _("s") : _("g"),
5723 kind_name
, (int) maxprint
, data
);
5726 printf (" %-6lx\t%.*s\n",
5727 (unsigned long) offset
, (int) maxprint
, data
);
5729 data
+= strnlen ((char *) data
, maxprint
);
5742 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5744 return display_debug_pubnames_worker (section
, file
, 0);
5748 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5750 return display_debug_pubnames_worker (section
, file
, 1);
5754 display_debug_macinfo (struct dwarf_section
*section
,
5755 void *file ATTRIBUTE_UNUSED
)
5757 unsigned char *start
= section
->start
;
5758 unsigned char *end
= start
+ section
->size
;
5759 unsigned char *curr
= start
;
5760 enum dwarf_macinfo_record_type op
;
5762 introduce (section
, false);
5766 unsigned int lineno
;
5767 const unsigned char *string
;
5769 op
= (enum dwarf_macinfo_record_type
) *curr
;
5774 case DW_MACINFO_start_file
:
5776 unsigned int filenum
;
5778 READ_ULEB (lineno
, curr
, end
);
5779 READ_ULEB (filenum
, curr
, end
);
5780 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5785 case DW_MACINFO_end_file
:
5786 printf (_(" DW_MACINFO_end_file\n"));
5789 case DW_MACINFO_define
:
5790 READ_ULEB (lineno
, curr
, end
);
5792 curr
+= strnlen ((char *) string
, end
- string
);
5793 printf (_(" DW_MACINFO_define - lineno : %d macro : %*s\n"),
5794 lineno
, (int) (curr
- string
), string
);
5799 case DW_MACINFO_undef
:
5800 READ_ULEB (lineno
, curr
, end
);
5802 curr
+= strnlen ((char *) string
, end
- string
);
5803 printf (_(" DW_MACINFO_undef - lineno : %d macro : %*s\n"),
5804 lineno
, (int) (curr
- string
), string
);
5809 case DW_MACINFO_vendor_ext
:
5811 unsigned int constant
;
5813 READ_ULEB (constant
, curr
, end
);
5815 curr
+= strnlen ((char *) string
, end
- string
);
5816 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %*s\n"),
5817 constant
, (int) (curr
- string
), string
);
5828 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5829 filename and dirname corresponding to file name table entry with index
5830 FILEIDX. Return NULL on failure. */
5832 static unsigned char *
5833 get_line_filename_and_dirname (dwarf_vma line_offset
,
5835 unsigned char **dir_name
)
5837 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5838 unsigned char *hdrptr
, *dirtable
, *file_name
;
5839 unsigned int offset_size
;
5840 unsigned int version
, opcode_base
;
5841 dwarf_vma length
, diridx
;
5842 const unsigned char * end
;
5845 if (section
->start
== NULL
5846 || line_offset
>= section
->size
5850 hdrptr
= section
->start
+ line_offset
;
5851 end
= section
->start
+ section
->size
;
5853 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5854 if (length
== 0xffffffff)
5856 /* This section is 64-bit DWARF 3. */
5857 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5863 if (length
> (size_t) (end
- hdrptr
)
5864 || length
< 2 + offset_size
+ 1 + 3 + 1)
5866 end
= hdrptr
+ length
;
5868 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5869 if (version
!= 2 && version
!= 3 && version
!= 4)
5871 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5873 hdrptr
++; /* Skip max_ops_per_insn. */
5874 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5876 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5877 if (opcode_base
== 0
5878 || opcode_base
- 1 >= (size_t) (end
- hdrptr
))
5881 hdrptr
+= opcode_base
- 1;
5884 /* Skip over dirname table. */
5885 while (*hdrptr
!= '\0')
5887 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5893 hdrptr
++; /* Skip the NUL at the end of the table. */
5895 /* Now skip over preceding filename table entries. */
5896 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5898 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5901 SKIP_ULEB (hdrptr
, end
);
5902 SKIP_ULEB (hdrptr
, end
);
5903 SKIP_ULEB (hdrptr
, end
);
5905 if (hdrptr
>= end
|| *hdrptr
== '\0')
5909 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5914 READ_ULEB (diridx
, hdrptr
, end
);
5917 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5919 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
);
5923 if (dirtable
>= end
|| *dirtable
== '\0')
5925 *dir_name
= dirtable
;
5930 display_debug_macro (struct dwarf_section
*section
,
5933 unsigned char *start
= section
->start
;
5934 unsigned char *end
= start
+ section
->size
;
5935 unsigned char *curr
= start
;
5936 unsigned char *extended_op_buf
[256];
5937 bool is_dwo
= false;
5938 const char *suffix
= strrchr (section
->name
, '.');
5940 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
5943 load_debug_section_with_follow (str
, file
);
5944 load_debug_section_with_follow (line
, file
);
5945 load_debug_section_with_follow (str_index
, file
);
5947 introduce (section
, false);
5951 unsigned int lineno
, version
, flags
;
5952 unsigned int offset_size
;
5953 const unsigned char *string
;
5954 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5955 unsigned char **extended_ops
= NULL
;
5957 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5958 if (version
!= 4 && version
!= 5)
5960 error (_("Expected to find a version number of 4 or 5 in section %s but found %d instead\n"),
5961 section
->name
, version
);
5965 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5966 offset_size
= (flags
& 1) ? 8 : 4;
5967 printf (_(" Offset: 0x%lx\n"),
5968 (unsigned long) sec_offset
);
5969 printf (_(" Version: %d\n"), version
);
5970 printf (_(" Offset size: %d\n"), offset_size
);
5973 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5974 printf (_(" Offset into .debug_line: 0x%lx\n"),
5975 (unsigned long) line_offset
);
5979 unsigned int i
, count
, op
;
5982 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5984 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5985 extended_ops
= extended_op_buf
;
5988 printf (_(" Extension opcode arguments:\n"));
5989 for (i
= 0; i
< count
; i
++)
5991 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5992 extended_ops
[op
] = curr
;
5993 READ_ULEB (nargs
, curr
, end
);
5995 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5998 printf (_(" DW_MACRO_%02x arguments: "), op
);
5999 for (n
= 0; n
< nargs
; n
++)
6003 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
6004 printf ("%s%s", get_FORM_name (form
),
6005 n
== nargs
- 1 ? "\n" : ", ");
6015 case DW_FORM_block1
:
6016 case DW_FORM_block2
:
6017 case DW_FORM_block4
:
6019 case DW_FORM_string
:
6021 case DW_FORM_sec_offset
:
6024 error (_("Invalid extension opcode form %s\n"),
6025 get_FORM_name (form
));
6041 error (_(".debug_macro section not zero terminated\n"));
6045 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6051 case DW_MACRO_define
:
6052 READ_ULEB (lineno
, curr
, end
);
6054 curr
+= strnlen ((char *) string
, end
- string
);
6055 printf (_(" DW_MACRO_define - lineno : %d macro : %*s\n"),
6056 lineno
, (int) (curr
- string
), string
);
6061 case DW_MACRO_undef
:
6062 READ_ULEB (lineno
, curr
, end
);
6064 curr
+= strnlen ((char *) string
, end
- string
);
6065 printf (_(" DW_MACRO_undef - lineno : %d macro : %*s\n"),
6066 lineno
, (int) (curr
- string
), string
);
6071 case DW_MACRO_start_file
:
6073 unsigned int filenum
;
6074 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6076 READ_ULEB (lineno
, curr
, end
);
6077 READ_ULEB (filenum
, curr
, end
);
6079 if ((flags
& 2) == 0)
6080 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6083 = get_line_filename_and_dirname (line_offset
, filenum
,
6085 if (file_name
== NULL
)
6086 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6089 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6091 dir_name
!= NULL
? (const char *) dir_name
: "",
6092 dir_name
!= NULL
? "/" : "", file_name
);
6096 case DW_MACRO_end_file
:
6097 printf (_(" DW_MACRO_end_file\n"));
6100 case DW_MACRO_define_strp
:
6101 READ_ULEB (lineno
, curr
, end
);
6102 if (version
== 4 && is_dwo
)
6103 READ_ULEB (offset
, curr
, end
);
6105 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6106 string
= fetch_indirect_string (offset
);
6107 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6111 case DW_MACRO_undef_strp
:
6112 READ_ULEB (lineno
, curr
, end
);
6113 if (version
== 4 && is_dwo
)
6114 READ_ULEB (offset
, curr
, end
);
6116 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6117 string
= fetch_indirect_string (offset
);
6118 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6122 case DW_MACRO_import
:
6123 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6124 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
6125 (unsigned long) offset
);
6128 case DW_MACRO_define_sup
:
6129 READ_ULEB (lineno
, curr
, end
);
6130 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6131 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
6132 lineno
, (unsigned long) offset
);
6135 case DW_MACRO_undef_sup
:
6136 READ_ULEB (lineno
, curr
, end
);
6137 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6138 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
6139 lineno
, (unsigned long) offset
);
6142 case DW_MACRO_import_sup
:
6143 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6144 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
6145 (unsigned long) offset
);
6148 case DW_MACRO_define_strx
:
6149 case DW_MACRO_undef_strx
:
6150 READ_ULEB (lineno
, curr
, end
);
6151 READ_ULEB (offset
, curr
, end
);
6152 string
= (const unsigned char *)
6153 fetch_indexed_string (offset
, NULL
, offset_size
, false);
6154 if (op
== DW_MACRO_define_strx
)
6155 printf (" DW_MACRO_define_strx ");
6157 printf (" DW_MACRO_undef_strx ");
6159 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
6160 printf (_("lineno : %d macro : %s\n"),
6165 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6167 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6171 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6173 error (_(" Unknown macro opcode %02x seen\n"), op
);
6178 /* Skip over unhandled opcodes. */
6180 unsigned char *desc
= extended_ops
[op
];
6181 READ_ULEB (nargs
, desc
, end
);
6184 printf (_(" DW_MACRO_%02x\n"), op
);
6187 printf (_(" DW_MACRO_%02x -"), op
);
6188 for (n
= 0; n
< nargs
; n
++)
6192 /* DW_FORM_implicit_const is not expected here. */
6193 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6195 = read_and_display_attr_value (0, val
, 0,
6196 start
, curr
, end
, 0, 0, offset_size
,
6197 version
, NULL
, 0, NULL
,
6215 display_debug_abbrev (struct dwarf_section
*section
,
6216 void *file ATTRIBUTE_UNUSED
)
6218 abbrev_entry
*entry
;
6219 unsigned char *start
= section
->start
;
6221 introduce (section
, false);
6228 offset
= start
- section
->start
;
6229 list
= find_abbrev_list_by_abbrev_offset (0, offset
);
6232 list
= new_abbrev_list (0, offset
);
6233 start
= process_abbrev_set (section
, 0, section
->size
, offset
, list
);
6234 list
->start_of_next_abbrevs
= start
;
6237 start
= list
->start_of_next_abbrevs
;
6239 if (list
->first_abbrev
== NULL
)
6242 printf (_(" Number TAG (0x%lx)\n"), (long) offset
);
6244 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6248 printf (" %ld %s [%s]\n",
6250 get_TAG_name (entry
->tag
),
6251 entry
->children
? _("has children") : _("no children"));
6253 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6255 printf (" %-18s %s",
6256 get_AT_name (attr
->attribute
),
6257 get_FORM_name (attr
->form
));
6258 if (attr
->form
== DW_FORM_implicit_const
)
6259 printf (": %s", dwarf_vmatoa ("d", attr
->implicit_const
));
6271 /* Return true when ADDR is the maximum address, when addresses are
6272 POINTER_SIZE bytes long. */
6275 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
6277 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
6278 return ((addr
& mask
) == mask
);
6281 /* Display a view pair list starting at *VSTART_PTR and ending at
6282 VLISTEND within SECTION. */
6285 display_view_pair_list (struct dwarf_section
*section
,
6286 unsigned char **vstart_ptr
,
6287 unsigned int debug_info_entry
,
6288 unsigned char *vlistend
)
6290 unsigned char *vstart
= *vstart_ptr
;
6291 unsigned char *section_end
= section
->start
+ section
->size
;
6292 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6294 if (vlistend
< section_end
)
6295 section_end
= vlistend
;
6299 while (vstart
< section_end
)
6301 dwarf_vma off
= vstart
- section
->start
;
6302 dwarf_vma vbegin
, vend
;
6304 READ_ULEB (vbegin
, vstart
, section_end
);
6305 if (vstart
== section_end
)
6308 READ_ULEB (vend
, vstart
, section_end
);
6309 printf (" %8.8lx ", (unsigned long) off
);
6311 print_dwarf_view (vbegin
, pointer_size
, 1);
6312 print_dwarf_view (vend
, pointer_size
, 1);
6313 printf (_("location view pair\n"));
6317 *vstart_ptr
= vstart
;
6320 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6323 display_loc_list (struct dwarf_section
*section
,
6324 unsigned char **start_ptr
,
6325 unsigned int debug_info_entry
,
6327 dwarf_vma base_address
,
6328 unsigned char **vstart_ptr
,
6331 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6332 unsigned char *section_end
= section
->start
+ section
->size
;
6333 unsigned long cu_offset
;
6334 unsigned int pointer_size
;
6335 unsigned int offset_size
;
6340 unsigned short length
;
6341 int need_frame_base
;
6343 if (debug_info_entry
>= num_debug_info_entries
)
6345 warn (_("No debug information available for loc lists of entry: %u\n"),
6350 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6351 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6352 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6353 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6355 if (pointer_size
< 2 || pointer_size
> 8)
6357 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6358 pointer_size
, debug_info_entry
);
6364 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6365 dwarf_vma vbegin
= vm1
, vend
= vm1
;
6367 if (2 * pointer_size
> (size_t) (section_end
- start
))
6369 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6370 (unsigned long) offset
);
6374 printf (" %8.8lx ", (unsigned long) off
);
6376 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6377 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6379 if (begin
== 0 && end
== 0)
6381 /* PR 18374: In a object file we can have a location list that
6382 starts with a begin and end of 0 because there are relocations
6383 that need to be applied to the addresses. Actually applying
6384 the relocations now does not help as they will probably resolve
6385 to 0, since the object file has not been fully linked. Real
6386 end of list markers will not have any relocations against them. */
6387 if (! reloc_at (section
, off
)
6388 && ! reloc_at (section
, off
+ pointer_size
))
6390 printf (_("<End of list>\n"));
6395 /* Check base address specifiers. */
6396 if (is_max_address (begin
, pointer_size
)
6397 && !is_max_address (end
, pointer_size
))
6400 print_dwarf_vma (begin
, pointer_size
);
6401 print_dwarf_vma (end
, pointer_size
);
6402 printf (_("(base address)\n"));
6408 off
= offset
+ (vstart
- *start_ptr
);
6410 READ_ULEB (vbegin
, vstart
, section_end
);
6411 print_dwarf_view (vbegin
, pointer_size
, 1);
6413 READ_ULEB (vend
, vstart
, section_end
);
6414 print_dwarf_view (vend
, pointer_size
, 1);
6416 printf (_("views at %8.8lx for:\n %*s "),
6417 (unsigned long) off
, 8, "");
6420 if (2 > (size_t) (section_end
- start
))
6422 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6423 (unsigned long) offset
);
6427 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6429 if (length
> (size_t) (section_end
- start
))
6431 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6432 (unsigned long) offset
);
6436 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6437 print_dwarf_vma (end
+ base_address
, pointer_size
);
6440 need_frame_base
= decode_location_expression (start
,
6445 cu_offset
, section
);
6448 if (need_frame_base
&& !has_frame_base
)
6449 printf (_(" [without DW_AT_frame_base]"));
6451 if (begin
== end
&& vbegin
== vend
)
6452 fputs (_(" (start == end)"), stdout
);
6453 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6454 fputs (_(" (start > end)"), stdout
);
6462 *vstart_ptr
= vstart
;
6465 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6468 display_loclists_list (struct dwarf_section
*section
,
6469 unsigned char **start_ptr
,
6470 unsigned int debug_info_entry
,
6472 dwarf_vma base_address
,
6473 unsigned char **vstart_ptr
,
6476 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6477 unsigned char *section_end
= section
->start
+ section
->size
;
6478 unsigned long cu_offset
;
6479 unsigned int pointer_size
;
6480 unsigned int offset_size
;
6483 /* Initialize it due to a false compiler warning. */
6484 dwarf_vma begin
= -1, vbegin
= -1;
6485 dwarf_vma end
= -1, vend
= -1;
6487 int need_frame_base
;
6489 if (debug_info_entry
>= num_debug_info_entries
)
6491 warn (_("No debug information available for "
6492 "loclists lists of entry: %u\n"),
6497 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6498 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6499 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6500 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6502 if (pointer_size
< 2 || pointer_size
> 8)
6504 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6505 pointer_size
, debug_info_entry
);
6511 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6512 enum dwarf_location_list_entry_type llet
;
6514 if (start
+ 1 > section_end
)
6516 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6517 (unsigned long) offset
);
6521 printf (" %8.8lx ", (unsigned long) off
);
6523 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6525 if (vstart
&& (llet
== DW_LLE_offset_pair
6526 || llet
== DW_LLE_start_end
6527 || llet
== DW_LLE_start_length
))
6529 off
= offset
+ (vstart
- *start_ptr
);
6531 READ_ULEB (vbegin
, vstart
, section_end
);
6532 print_dwarf_view (vbegin
, pointer_size
, 1);
6534 READ_ULEB (vend
, vstart
, section_end
);
6535 print_dwarf_view (vend
, pointer_size
, 1);
6537 printf (_("views at %8.8lx for:\n %*s "),
6538 (unsigned long) off
, 8, "");
6543 case DW_LLE_end_of_list
:
6544 printf (_("<End of list>\n"));
6546 case DW_LLE_offset_pair
:
6547 READ_ULEB (begin
, start
, section_end
);
6548 begin
+= base_address
;
6549 READ_ULEB (end
, start
, section_end
);
6550 end
+= base_address
;
6552 case DW_LLE_start_end
:
6553 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6554 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6556 case DW_LLE_start_length
:
6557 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6558 READ_ULEB (end
, start
, section_end
);
6561 case DW_LLE_base_address
:
6562 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6564 print_dwarf_vma (base_address
, pointer_size
);
6565 printf (_("(base address)\n"));
6567 #ifdef DW_LLE_view_pair
6568 case DW_LLE_view_pair
:
6570 printf (_("View pair entry in loclist with locviews attribute\n"));
6571 READ_ULEB (vbegin
, start
, section_end
);
6572 print_dwarf_view (vbegin
, pointer_size
, 1);
6574 READ_ULEB (vend
, start
, section_end
);
6575 print_dwarf_view (vend
, pointer_size
, 1);
6577 printf (_("views for:\n"));
6581 error (_("Invalid location list entry type %d\n"), llet
);
6584 if (llet
== DW_LLE_end_of_list
)
6586 if (llet
!= DW_LLE_offset_pair
6587 && llet
!= DW_LLE_start_end
6588 && llet
!= DW_LLE_start_length
)
6591 if (start
== section_end
)
6593 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6594 (unsigned long) offset
);
6597 READ_ULEB (length
, start
, section_end
);
6599 if (length
> (size_t) (section_end
- start
))
6601 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6602 (unsigned long) offset
);
6606 print_dwarf_vma (begin
, pointer_size
);
6607 print_dwarf_vma (end
, pointer_size
);
6610 need_frame_base
= decode_location_expression (start
,
6615 cu_offset
, section
);
6618 if (need_frame_base
&& !has_frame_base
)
6619 printf (_(" [without DW_AT_frame_base]"));
6621 if (begin
== end
&& vbegin
== vend
)
6622 fputs (_(" (start == end)"), stdout
);
6623 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6624 fputs (_(" (start > end)"), stdout
);
6632 if (vbegin
!= vm1
|| vend
!= vm1
)
6633 printf (_("Trailing view pair not used in a range"));
6636 *vstart_ptr
= vstart
;
6639 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6640 right-adjusted in a field of length LEN, and followed by a space. */
6643 print_addr_index (unsigned int idx
, unsigned int len
)
6645 static char buf
[15];
6646 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6647 printf ("%*s ", len
, buf
);
6650 /* Display a location list from a .dwo section. It uses address indexes rather
6651 than embedded addresses. This code closely follows display_loc_list, but the
6652 two are sufficiently different that combining things is very ugly. */
6655 display_loc_list_dwo (struct dwarf_section
*section
,
6656 unsigned char **start_ptr
,
6657 unsigned int debug_info_entry
,
6659 unsigned char **vstart_ptr
,
6662 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6663 unsigned char *section_end
= section
->start
+ section
->size
;
6664 unsigned long cu_offset
;
6665 unsigned int pointer_size
;
6666 unsigned int offset_size
;
6669 unsigned short length
;
6670 int need_frame_base
;
6673 if (debug_info_entry
>= num_debug_info_entries
)
6675 warn (_("No debug information for loc lists of entry: %u\n"),
6680 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6681 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6682 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6683 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6685 if (pointer_size
< 2 || pointer_size
> 8)
6687 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6688 pointer_size
, debug_info_entry
);
6694 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6696 if (start
>= section_end
)
6698 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6699 (unsigned long) offset
);
6703 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6716 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6718 READ_ULEB (view
, vstart
, section_end
);
6719 print_dwarf_view (view
, 8, 1);
6721 READ_ULEB (view
, vstart
, section_end
);
6722 print_dwarf_view (view
, 8, 1);
6724 printf (_("views at %8.8lx for:\n %*s "),
6725 (unsigned long) off
, 8, "");
6733 case 0: /* A terminating entry. */
6735 *vstart_ptr
= vstart
;
6736 printf (_("<End of list>\n"));
6738 case 1: /* A base-address entry. */
6739 READ_ULEB (idx
, start
, section_end
);
6740 print_addr_index (idx
, 8);
6741 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6742 printf (_("(base address selection entry)\n"));
6744 case 2: /* A start/end entry. */
6745 READ_ULEB (idx
, start
, section_end
);
6746 print_addr_index (idx
, 8);
6747 READ_ULEB (idx
, start
, section_end
);
6748 print_addr_index (idx
, 8);
6750 case 3: /* A start/length entry. */
6751 READ_ULEB (idx
, start
, section_end
);
6752 print_addr_index (idx
, 8);
6753 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6754 printf ("%08x ", idx
);
6756 case 4: /* An offset pair entry. */
6757 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6758 printf ("%08x ", idx
);
6759 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6760 printf ("%08x ", idx
);
6763 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6765 *vstart_ptr
= vstart
;
6769 if (2 > (size_t) (section_end
- start
))
6771 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6772 (unsigned long) offset
);
6776 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6777 if (length
> (size_t) (section_end
- start
))
6779 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6780 (unsigned long) offset
);
6785 need_frame_base
= decode_location_expression (start
,
6790 cu_offset
, section
);
6793 if (need_frame_base
&& !has_frame_base
)
6794 printf (_(" [without DW_AT_frame_base]"));
6802 *vstart_ptr
= vstart
;
6805 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6808 static dwarf_vma
*loc_offsets
, *loc_views
;
6811 loc_offsets_compar (const void *ap
, const void *bp
)
6813 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6814 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6816 int ret
= (a
> b
) - (b
> a
);
6820 a
= loc_views
[*(const unsigned int *) ap
];
6821 b
= loc_views
[*(const unsigned int *) bp
];
6823 ret
= (a
> b
) - (b
> a
);
6829 display_debug_loc (struct dwarf_section
*section
, void *file
)
6831 unsigned char *start
= section
->start
, *vstart
= NULL
;
6832 unsigned long bytes
;
6833 unsigned char *section_begin
= start
;
6834 unsigned int num_loc_list
= 0;
6835 unsigned long last_offset
= 0;
6836 unsigned long last_view
= 0;
6837 unsigned int first
= 0;
6840 int seen_first_offset
= 0;
6841 int locs_sorted
= 1;
6842 unsigned char *next
= start
, *vnext
= vstart
;
6843 unsigned int *array
= NULL
;
6844 const char *suffix
= strrchr (section
->name
, '.');
6845 bool is_dwo
= false;
6846 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6847 dwarf_vma expected_start
= 0;
6849 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6852 bytes
= section
->size
;
6856 printf (_("\nThe %s section is empty.\n"), section
->name
);
6862 unsigned char *hdrptr
= section_begin
;
6863 dwarf_vma ll_length
;
6864 unsigned short ll_version
;
6865 unsigned char *end
= section_begin
+ section
->size
;
6866 unsigned char address_size
, segment_selector_size
;
6867 uint32_t offset_entry_count
;
6869 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6870 if (ll_length
== 0xffffffff)
6871 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6873 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6874 if (ll_version
!= 5)
6876 warn (_("The %s section contains corrupt or "
6877 "unsupported version number: %d.\n"),
6878 section
->name
, ll_version
);
6882 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6884 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6885 if (segment_selector_size
!= 0)
6887 warn (_("The %s section contains "
6888 "unsupported segment selector size: %d.\n"),
6889 section
->name
, segment_selector_size
);
6893 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6894 if (offset_entry_count
!= 0)
6896 warn (_("The %s section contains "
6897 "unsupported offset entry count: %d.\n"),
6898 section
->name
, offset_entry_count
);
6902 expected_start
= hdrptr
- section_begin
;
6905 if (load_debug_info (file
) == 0)
6907 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6912 /* Check the order of location list in .debug_info section. If
6913 offsets of location lists are in the ascending order, we can
6914 use `debug_information' directly. */
6915 for (i
= 0; i
< num_debug_info_entries
; i
++)
6919 num
= debug_information
[i
].num_loc_offsets
;
6920 if (num
> num_loc_list
)
6923 /* Check if we can use `debug_information' directly. */
6924 if (locs_sorted
&& num
!= 0)
6926 if (!seen_first_offset
)
6928 /* This is the first location list. */
6929 last_offset
= debug_information
[i
].loc_offsets
[0];
6930 last_view
= debug_information
[i
].loc_views
[0];
6932 seen_first_offset
= 1;
6938 for (; j
< num
; j
++)
6941 debug_information
[i
].loc_offsets
[j
]
6942 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6943 && last_view
> debug_information
[i
].loc_views
[j
]))
6948 last_offset
= debug_information
[i
].loc_offsets
[j
];
6949 last_view
= debug_information
[i
].loc_views
[j
];
6954 if (!seen_first_offset
)
6955 error (_("No location lists in .debug_info section!\n"));
6957 if (debug_information
[first
].num_loc_offsets
> 0
6958 && debug_information
[first
].loc_offsets
[0] != expected_start
6959 && debug_information
[first
].loc_views
[0] != expected_start
)
6960 warn (_("Location lists in %s section start at 0x%s\n"),
6962 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6965 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6967 introduce (section
, false);
6969 if (reloc_at (section
, 0))
6970 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6972 printf (_(" Offset Begin End Expression\n"));
6974 seen_first_offset
= 0;
6975 for (i
= first
; i
< num_debug_info_entries
; i
++)
6977 dwarf_vma offset
, voffset
;
6978 dwarf_vma base_address
;
6984 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6986 loc_offsets
= debug_information
[i
].loc_offsets
;
6987 loc_views
= debug_information
[i
].loc_views
;
6988 qsort (array
, debug_information
[i
].num_loc_offsets
,
6989 sizeof (*array
), loc_offsets_compar
);
6992 int adjacent_view_loclists
= 1;
6993 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6995 j
= locs_sorted
? k
: array
[k
];
6997 && (debug_information
[i
].loc_offsets
[locs_sorted
6998 ? k
- 1 : array
[k
- 1]]
6999 == debug_information
[i
].loc_offsets
[j
])
7000 && (debug_information
[i
].loc_views
[locs_sorted
7001 ? k
- 1 : array
[k
- 1]]
7002 == debug_information
[i
].loc_views
[j
]))
7004 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
7005 offset
= debug_information
[i
].loc_offsets
[j
];
7006 next
= section_begin
+ offset
;
7007 voffset
= debug_information
[i
].loc_views
[j
];
7009 vnext
= section_begin
+ voffset
;
7012 base_address
= debug_information
[i
].base_address
;
7014 if (vnext
&& vnext
< next
)
7017 display_view_pair_list (section
, &vstart
, i
, next
);
7022 if (!seen_first_offset
|| !adjacent_view_loclists
)
7023 seen_first_offset
= 1;
7027 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7028 (unsigned long) (start
- section_begin
),
7029 (unsigned long) offset
,
7031 else if (start
> next
)
7032 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7033 (unsigned long) (start
- section_begin
),
7034 (unsigned long) offset
,
7040 if (offset
>= bytes
)
7042 warn (_("Offset 0x%lx is bigger than %s section size.\n"),
7043 (unsigned long) offset
,
7048 if (vnext
&& voffset
>= bytes
)
7050 warn (_("View Offset 0x%lx is bigger than %s section size.\n"),
7051 (unsigned long) voffset
,
7059 display_loc_list_dwo (section
, &start
, i
, offset
,
7060 &vstart
, has_frame_base
);
7062 display_loc_list (section
, &start
, i
, offset
, base_address
,
7063 &vstart
, has_frame_base
);
7068 warn (_("DWO is not yet supported.\n"));
7070 display_loclists_list (section
, &start
, i
, offset
, base_address
,
7071 &vstart
, has_frame_base
);
7074 /* FIXME: this arrangement is quite simplistic. Nothing
7075 requires locview lists to be adjacent to corresponding
7076 loclists, and a single loclist could be augmented by
7077 different locview lists, and vice-versa, unlikely as it
7078 is that it would make sense to do so. Hopefully we'll
7079 have view pair support built into loclists before we ever
7080 need to address all these possibilities. */
7081 if (adjacent_view_loclists
&& vnext
7082 && vnext
!= start
&& vstart
!= next
)
7084 adjacent_view_loclists
= 0;
7085 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7088 if (vnext
&& vnext
== start
)
7089 display_view_pair_list (section
, &start
, i
, vstart
);
7093 if (start
< section
->start
+ section
->size
)
7094 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7095 "There are %ld unused bytes at the end of section %s\n",
7096 (long) (section
->start
+ section
->size
- start
)),
7097 (long) (section
->start
+ section
->size
- start
), section
->name
);
7104 display_debug_str (struct dwarf_section
*section
,
7105 void *file ATTRIBUTE_UNUSED
)
7107 unsigned char *start
= section
->start
;
7108 unsigned long bytes
= section
->size
;
7109 dwarf_vma addr
= section
->address
;
7113 printf (_("\nThe %s section is empty.\n"), section
->name
);
7117 introduce (section
, false);
7125 lbytes
= (bytes
> 16 ? 16 : bytes
);
7127 printf (" 0x%8.8lx ", (unsigned long) addr
);
7129 for (j
= 0; j
< 16; j
++)
7132 printf ("%2.2x", start
[j
]);
7140 for (j
= 0; j
< lbytes
; j
++)
7143 if (k
>= ' ' && k
< 0x80)
7162 display_debug_info (struct dwarf_section
*section
, void *file
)
7164 return process_debug_info (section
, file
, section
->abbrev_sec
, false, false);
7168 display_debug_types (struct dwarf_section
*section
, void *file
)
7170 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7174 display_trace_info (struct dwarf_section
*section
, void *file
)
7176 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7180 display_debug_aranges (struct dwarf_section
*section
,
7181 void *file ATTRIBUTE_UNUSED
)
7183 unsigned char *start
= section
->start
;
7184 unsigned char *end
= start
+ section
->size
;
7186 introduce (section
, false);
7188 /* It does not matter if this load fails,
7189 we test for that later on. */
7190 load_debug_info (file
);
7194 unsigned char *hdrptr
;
7195 DWARF2_Internal_ARange arange
;
7196 unsigned char *addr_ranges
;
7199 unsigned long sec_off
;
7200 unsigned char address_size
;
7201 unsigned int offset_size
;
7202 unsigned char *end_ranges
;
7205 sec_off
= hdrptr
- section
->start
;
7207 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7208 if (arange
.ar_length
== 0xffffffff)
7210 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7216 if (arange
.ar_length
> (size_t) (end
- hdrptr
))
7218 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
7221 dwarf_vmatoa ("x", arange
.ar_length
));
7224 end_ranges
= hdrptr
+ arange
.ar_length
;
7226 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end_ranges
);
7227 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
,
7230 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7231 && num_debug_info_entries
> 0
7232 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7233 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
7234 (unsigned long) arange
.ar_info_offset
, section
->name
);
7236 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end_ranges
);
7237 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end_ranges
);
7239 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7241 /* PR 19872: A version number of 0 probably means that there is
7242 padding at the end of the .debug_aranges section. Gold puts
7243 it there when performing an incremental link, for example.
7244 So do not generate a warning in this case. */
7245 if (arange
.ar_version
)
7246 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7250 printf (_(" Length: %ld\n"),
7251 (long) arange
.ar_length
);
7252 printf (_(" Version: %d\n"), arange
.ar_version
);
7253 printf (_(" Offset into .debug_info: 0x%lx\n"),
7254 (unsigned long) arange
.ar_info_offset
);
7255 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7256 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7258 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7260 /* PR 17512: file: 001-108546-0.001:0.1. */
7261 if (address_size
== 0 || address_size
> 8)
7263 error (_("Invalid address size in %s section!\n"),
7268 /* The DWARF spec does not require that the address size be a power
7269 of two, but we do. This will have to change if we ever encounter
7270 an uneven architecture. */
7271 if ((address_size
& (address_size
- 1)) != 0)
7273 warn (_("Pointer size + Segment size is not a power of two.\n"));
7277 if (address_size
> 4)
7278 printf (_("\n Address Length\n"));
7280 printf (_("\n Address Length\n"));
7282 addr_ranges
= hdrptr
;
7284 /* Must pad to an alignment boundary that is twice the address size. */
7285 addr_ranges
+= (2 * address_size
- 1
7286 - (hdrptr
- start
- 1) % (2 * address_size
));
7288 while (2 * address_size
<= end_ranges
- addr_ranges
)
7290 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
,
7292 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
,
7295 print_dwarf_vma (address
, address_size
);
7296 print_dwarf_vma (length
, address_size
);
7308 /* Comparison function for qsort. */
7310 comp_addr_base (const void * v0
, const void * v1
)
7312 debug_info
*info0
= *(debug_info
**) v0
;
7313 debug_info
*info1
= *(debug_info
**) v1
;
7314 return info0
->addr_base
- info1
->addr_base
;
7317 /* Display the debug_addr section. */
7319 display_debug_addr (struct dwarf_section
*section
,
7322 debug_info
**debug_addr_info
;
7323 unsigned char *entry
;
7327 unsigned char * header
;
7329 if (section
->size
== 0)
7331 printf (_("\nThe %s section is empty.\n"), section
->name
);
7335 if (load_debug_info (file
) == 0)
7337 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7342 introduce (section
, false);
7344 /* PR 17531: file: cf38d01b.
7345 We use xcalloc because a corrupt file may not have initialised all of the
7346 fields in the debug_info structure, which means that the sort below might
7347 try to move uninitialised data. */
7348 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7349 sizeof (debug_info
*));
7352 for (i
= 0; i
< num_debug_info_entries
; i
++)
7353 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7355 /* PR 17531: file: cf38d01b. */
7356 if (debug_information
[i
].addr_base
>= section
->size
)
7357 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
7358 (unsigned long) debug_information
[i
].addr_base
, i
);
7360 debug_addr_info
[count
++] = debug_information
+ i
;
7363 /* Add a sentinel to make iteration convenient. */
7364 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7365 debug_addr_info
[count
]->addr_base
= section
->size
;
7366 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7368 header
= section
->start
;
7369 for (i
= 0; i
< count
; i
++)
7372 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7374 printf (_(" For compilation unit at offset 0x%s:\n"),
7375 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
7377 printf (_("\tIndex\tAddress\n"));
7378 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7379 if (debug_addr_info
[i
]->dwarf_version
>= 5)
7381 size_t header_size
= entry
- header
;
7382 unsigned char * curr_header
= header
;
7385 int segment_selector_size
;
7387 if (header_size
!= 8 && header_size
!= 16)
7389 warn (_("Corrupt %s section: expecting header size of 8 or 16, but found %ld instead\n"),
7390 section
->name
, (long) header_size
);
7394 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 4, entry
);
7395 if (length
== 0xffffffff)
7396 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 8, entry
);
7397 end
= curr_header
+ length
;
7399 SAFE_BYTE_GET_AND_INC (version
, curr_header
, 2, entry
);
7401 warn (_("Corrupt %s section: expecting version number 5 in header but found %d instead\n"),
7402 section
->name
, version
);
7404 SAFE_BYTE_GET_AND_INC (address_size
, curr_header
, 1, entry
);
7405 SAFE_BYTE_GET_AND_INC (segment_selector_size
, curr_header
, 1, entry
);
7406 address_size
+= segment_selector_size
;
7409 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7414 dwarf_vma base
= byte_get (entry
, address_size
);
7415 printf (_("\t%d:\t"), idx
);
7416 print_dwarf_vma (base
, address_size
);
7418 entry
+= address_size
;
7424 free (debug_addr_info
);
7428 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7431 display_debug_str_offsets (struct dwarf_section
*section
,
7432 void *file ATTRIBUTE_UNUSED
)
7436 if (section
->size
== 0)
7438 printf (_("\nThe %s section is empty.\n"), section
->name
);
7442 unsigned char *start
= section
->start
;
7443 unsigned char *end
= start
+ section
->size
;
7444 unsigned char *curr
= start
;
7446 const char *suffix
= strrchr (section
->name
, '.');
7447 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
7450 load_debug_section_with_follow (str_dwo
, file
);
7452 load_debug_section_with_follow (str
, file
);
7454 introduce (section
, false);
7459 dwarf_vma entry_length
;
7461 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7462 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7463 if (length
== 0xffffffff)
7465 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
7471 unsigned char *entries_end
;
7474 /* This is probably an old style .debug_str_offset section which
7475 just contains offsets and no header (and the first offset is 0). */
7476 length
= section
->size
;
7477 curr
= section
->start
;
7480 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7481 printf (_(" Index Offset [String]\n"));
7485 if (length
<= (dwarf_vma
) (end
- curr
))
7486 entries_end
= curr
+ length
;
7489 warn (_("Section %s is too small %#lx\n"),
7490 section
->name
, (unsigned long) section
->size
);
7495 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, entries_end
);
7497 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7500 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, entries_end
);
7502 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
7504 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7505 printf (_(" Version: %#lx\n"), (unsigned long) version
);
7506 printf (_(" Index Offset [String]\n"));
7509 for (idx
= 0; curr
< entries_end
; idx
++)
7512 const unsigned char * string
;
7514 if ((dwarf_vma
) (entries_end
- curr
) < entry_length
)
7515 /* Not enough space to read one entry_length, give up. */
7518 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, entries_end
);
7520 string
= (const unsigned char *)
7521 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
7523 string
= fetch_indirect_string (offset
);
7525 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
7533 /* Each debug_information[x].range_lists[y] gets this representation for
7534 sorting purposes. */
7538 /* The debug_information[x].range_lists[y] value. */
7539 dwarf_vma ranges_offset
;
7541 /* Original debug_information to find parameters of the data. */
7542 debug_info
*debug_info_p
;
7545 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7548 range_entry_compar (const void *ap
, const void *bp
)
7550 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7551 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7552 const dwarf_vma a
= a_re
->ranges_offset
;
7553 const dwarf_vma b
= b_re
->ranges_offset
;
7555 return (a
> b
) - (b
> a
);
7559 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
7560 unsigned int pointer_size
, unsigned long offset
,
7561 unsigned long base_address
)
7563 while (start
< finish
)
7568 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7569 if (start
>= finish
)
7571 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7573 printf (" %8.8lx ", offset
);
7575 if (begin
== 0 && end
== 0)
7577 printf (_("<End of list>\n"));
7581 /* Check base address specifiers. */
7582 if (is_max_address (begin
, pointer_size
)
7583 && !is_max_address (end
, pointer_size
))
7586 print_dwarf_vma (begin
, pointer_size
);
7587 print_dwarf_vma (end
, pointer_size
);
7588 printf ("(base address)\n");
7592 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7593 print_dwarf_vma (end
+ base_address
, pointer_size
);
7596 fputs (_("(start == end)"), stdout
);
7597 else if (begin
> end
)
7598 fputs (_("(start > end)"), stdout
);
7605 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7606 unsigned int pointer_size
, unsigned long offset
,
7607 unsigned long base_address
)
7609 unsigned char *next
= start
;
7613 unsigned long off
= offset
+ (start
- next
);
7614 enum dwarf_range_list_entry rlet
;
7615 /* Initialize it due to a false compiler warning. */
7616 dwarf_vma begin
= -1, length
, end
= -1;
7618 if (start
>= finish
)
7620 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7625 printf (" %8.8lx ", off
);
7627 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7631 case DW_RLE_end_of_list
:
7632 printf (_("<End of list>\n"));
7634 case DW_RLE_base_address
:
7635 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7636 print_dwarf_vma (base_address
, pointer_size
);
7637 printf (_("(base address)\n"));
7639 case DW_RLE_start_length
:
7640 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7641 READ_ULEB (length
, start
, finish
);
7642 end
= begin
+ length
;
7644 case DW_RLE_offset_pair
:
7645 READ_ULEB (begin
, start
, finish
);
7646 READ_ULEB (end
, start
, finish
);
7648 case DW_RLE_start_end
:
7649 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7650 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7653 error (_("Invalid range list entry type %d\n"), rlet
);
7654 rlet
= DW_RLE_end_of_list
;
7657 if (rlet
== DW_RLE_end_of_list
)
7659 if (rlet
== DW_RLE_base_address
)
7662 /* Only a DW_RLE_offset_pair needs the base address added. */
7663 if (rlet
== DW_RLE_offset_pair
)
7665 begin
+= base_address
;
7666 end
+= base_address
;
7669 print_dwarf_vma (begin
, pointer_size
);
7670 print_dwarf_vma (end
, pointer_size
);
7673 fputs (_("(start == end)"), stdout
);
7674 else if (begin
> end
)
7675 fputs (_("(start > end)"), stdout
);
7682 display_debug_ranges (struct dwarf_section
*section
,
7683 void *file ATTRIBUTE_UNUSED
)
7685 unsigned char *start
= section
->start
;
7686 unsigned char *last_start
= start
;
7687 unsigned long bytes
= section
->size
;
7688 unsigned char *section_begin
= start
;
7689 unsigned char *finish
= start
+ bytes
;
7690 unsigned int num_range_list
, i
;
7691 struct range_entry
*range_entries
, *range_entry_fill
;
7692 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7693 /* Initialize it due to a false compiler warning. */
7694 unsigned char address_size
= 0;
7695 dwarf_vma last_offset
= 0;
7699 printf (_("\nThe %s section is empty.\n"), section
->name
);
7705 dwarf_vma initial_length
;
7706 unsigned char segment_selector_size
;
7707 unsigned int offset_size
, offset_entry_count
;
7708 unsigned short version
;
7710 /* Get and check the length of the block. */
7711 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7713 if (initial_length
== 0xffffffff)
7715 /* This section is 64-bit DWARF 3. */
7716 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7722 if (initial_length
> (size_t) (finish
- start
))
7724 /* If the length field has a relocation against it, then we should
7725 not complain if it is inaccurate (and probably negative).
7726 It is copied from .debug_line handling code. */
7727 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7729 initial_length
= finish
- start
;
7733 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7734 (long) initial_length
);
7739 /* Get and check the version number. */
7740 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7744 warn (_("Only DWARF version 5 debug_rnglists info "
7745 "is currently supported.\n"));
7749 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7751 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7752 if (segment_selector_size
!= 0)
7754 warn (_("The %s section contains "
7755 "unsupported segment selector size: %d.\n"),
7756 section
->name
, segment_selector_size
);
7760 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7761 if (offset_entry_count
!= 0)
7763 warn (_("The %s section contains "
7764 "unsupported offset entry count: %u.\n"),
7765 section
->name
, offset_entry_count
);
7770 if (load_debug_info (file
) == 0)
7772 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7778 for (i
= 0; i
< num_debug_info_entries
; i
++)
7780 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7781 /* Skip .debug_rnglists reference. */
7783 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7784 /* Skip .debug_range reference. */
7786 num_range_list
+= debug_information
[i
].num_range_lists
;
7789 if (num_range_list
== 0)
7791 /* This can happen when the file was compiled with -gsplit-debug
7792 which removes references to range lists from the primary .o file. */
7793 printf (_("No range lists in .debug_info section.\n"));
7797 range_entries
= (struct range_entry
*)
7798 xmalloc (sizeof (*range_entries
) * num_range_list
);
7799 range_entry_fill
= range_entries
;
7801 for (i
= 0; i
< num_debug_info_entries
; i
++)
7803 debug_info
*debug_info_p
= &debug_information
[i
];
7806 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7807 /* Skip .debug_rnglists reference. */
7809 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7810 /* Skip .debug_range reference. */
7813 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7815 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7816 range_entry_fill
->debug_info_p
= debug_info_p
;
7821 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7822 range_entry_compar
);
7824 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7825 warn (_("Range lists in %s section start at 0x%lx\n"),
7826 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7828 introduce (section
, false);
7830 printf (_(" Offset Begin End\n"));
7832 for (i
= 0; i
< num_range_list
; i
++)
7834 struct range_entry
*range_entry
= &range_entries
[i
];
7835 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7836 unsigned int pointer_size
;
7838 unsigned char *next
;
7839 dwarf_vma base_address
;
7841 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7842 offset
= range_entry
->ranges_offset
;
7843 base_address
= debug_info_p
->base_address
;
7845 /* PR 17512: file: 001-101485-0.001:0.1. */
7846 if (pointer_size
< 2 || pointer_size
> 8)
7848 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7849 pointer_size
, (unsigned long) offset
);
7853 if (offset
> (size_t) (finish
- section_begin
))
7855 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7856 (unsigned long) offset
, i
);
7859 next
= section_begin
+ offset
;
7861 /* If multiple DWARF entities reference the same range then we will
7862 have multiple entries in the `range_entries' list for the same
7863 offset. Thanks to the sort above these will all be consecutive in
7864 the `range_entries' list, so we can easily ignore duplicates
7866 if (i
> 0 && last_offset
== offset
)
7868 last_offset
= offset
;
7870 if (dwarf_check
!= 0 && i
> 0)
7873 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7874 (unsigned long) (start
- section_begin
),
7875 (unsigned long) (next
- section_begin
), section
->name
);
7876 else if (start
> next
)
7878 if (next
== last_start
)
7880 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7881 (unsigned long) (start
- section_begin
),
7882 (unsigned long) (next
- section_begin
), section
->name
);
7889 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7890 (start
, finish
, pointer_size
, offset
, base_address
);
7894 free (range_entries
);
7899 typedef struct Frame_Chunk
7901 struct Frame_Chunk
*next
;
7902 unsigned char *chunk_start
;
7904 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7905 short int *col_type
;
7908 unsigned int code_factor
;
7912 unsigned int cfa_reg
;
7913 dwarf_vma cfa_offset
;
7915 unsigned char fde_encoding
;
7916 unsigned char cfa_exp
;
7917 unsigned char ptr_size
;
7918 unsigned char segment_size
;
7922 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7923 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7924 static const char *const *dwarf_regnames
;
7925 static unsigned int dwarf_regnames_count
;
7928 /* A marker for a col_type that means this column was never referenced
7929 in the frame info. */
7930 #define DW_CFA_unreferenced (-1)
7932 /* Return 0 if no more space is needed, 1 if more space is needed,
7933 -1 for invalid reg. */
7936 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7938 unsigned int prev
= fc
->ncols
;
7940 if (reg
< (unsigned int) fc
->ncols
)
7943 if (dwarf_regnames_count
> 0
7944 && reg
> dwarf_regnames_count
)
7947 fc
->ncols
= reg
+ 1;
7948 /* PR 17512: file: 10450-2643-0.004.
7949 If reg == -1 then this can happen... */
7953 /* PR 17512: file: 2844a11d. */
7954 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7956 error (_("Unfeasibly large register number: %u\n"), reg
);
7958 /* FIXME: 1024 is an arbitrary limit. Increase it if
7959 we ever encounter a valid binary that exceeds it. */
7963 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7964 sizeof (short int));
7965 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7966 /* PR 17512: file:002-10025-0.005. */
7967 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7969 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7975 while (prev
< fc
->ncols
)
7977 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7978 fc
->col_offset
[prev
] = 0;
7984 static const char *const dwarf_regnames_i386
[] =
7986 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7987 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7988 "eip", "eflags", NULL
, /* 8 - 10 */
7989 "st0", "st1", "st2", "st3", /* 11 - 14 */
7990 "st4", "st5", "st6", "st7", /* 15 - 18 */
7991 NULL
, NULL
, /* 19 - 20 */
7992 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7993 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7994 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7995 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7996 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7997 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7998 "tr", "ldtr", /* 48 - 49 */
7999 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8000 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8001 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8002 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8003 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8004 NULL
, NULL
, NULL
, /* 90 - 92 */
8005 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
8008 static const char *const dwarf_regnames_iamcu
[] =
8010 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8011 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8012 "eip", "eflags", NULL
, /* 8 - 10 */
8013 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
8014 NULL
, NULL
, /* 19 - 20 */
8015 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
8016 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
8017 NULL
, NULL
, NULL
, /* 37 - 39 */
8018 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8019 "tr", "ldtr", /* 48 - 49 */
8020 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8021 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8022 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8023 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8024 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8025 NULL
, NULL
, NULL
, /* 90 - 92 */
8026 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
8030 init_dwarf_regnames_i386 (void)
8032 dwarf_regnames
= dwarf_regnames_i386
;
8033 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
8034 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8038 init_dwarf_regnames_iamcu (void)
8040 dwarf_regnames
= dwarf_regnames_iamcu
;
8041 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
8042 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8045 static const char *const dwarf_regnames_x86_64
[] =
8047 "rax", "rdx", "rcx", "rbx",
8048 "rsi", "rdi", "rbp", "rsp",
8049 "r8", "r9", "r10", "r11",
8050 "r12", "r13", "r14", "r15",
8052 "xmm0", "xmm1", "xmm2", "xmm3",
8053 "xmm4", "xmm5", "xmm6", "xmm7",
8054 "xmm8", "xmm9", "xmm10", "xmm11",
8055 "xmm12", "xmm13", "xmm14", "xmm15",
8056 "st0", "st1", "st2", "st3",
8057 "st4", "st5", "st6", "st7",
8058 "mm0", "mm1", "mm2", "mm3",
8059 "mm4", "mm5", "mm6", "mm7",
8061 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
8062 "fs.base", "gs.base", NULL
, NULL
,
8064 "mxcsr", "fcw", "fsw",
8065 "xmm16", "xmm17", "xmm18", "xmm19",
8066 "xmm20", "xmm21", "xmm22", "xmm23",
8067 "xmm24", "xmm25", "xmm26", "xmm27",
8068 "xmm28", "xmm29", "xmm30", "xmm31",
8069 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
8070 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
8071 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
8072 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
8073 NULL
, NULL
, NULL
, /* 115 - 117 */
8074 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
8078 init_dwarf_regnames_x86_64 (void)
8080 dwarf_regnames
= dwarf_regnames_x86_64
;
8081 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
8082 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8085 static const char *const dwarf_regnames_aarch64
[] =
8087 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
8088 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
8089 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
8090 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
8091 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8092 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
8093 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
8094 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
8095 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
8096 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
8097 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
8098 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
8099 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
8100 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
8101 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
8102 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
8106 init_dwarf_regnames_aarch64 (void)
8108 dwarf_regnames
= dwarf_regnames_aarch64
;
8109 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
8110 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8113 static const char *const dwarf_regnames_s390
[] =
8115 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
8116 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8117 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8118 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
8119 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
8120 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
8121 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
8122 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
8123 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
8126 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
8127 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
8131 init_dwarf_regnames_s390 (void)
8133 dwarf_regnames
= dwarf_regnames_s390
;
8134 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
8135 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8138 static const char *const dwarf_regnames_riscv
[] =
8140 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8141 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8142 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8143 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8144 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8145 "fs0", "fs1", /* 40 - 41 */
8146 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8147 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8148 "fs10", "fs11", /* 58 - 59 */
8149 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8152 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8153 the large number of CSRs. */
8156 regname_internal_riscv (unsigned int regno
)
8158 const char *name
= NULL
;
8160 /* Lookup in the table first, this covers GPR and FPR. */
8161 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8162 name
= dwarf_regnames_riscv
[regno
];
8163 else if (regno
>= 4096 && regno
<= 8191)
8165 /* This might be a CSR, these live in a sparse number space from 4096
8166 to 8191 These numbers are defined in the RISC-V ELF ABI
8170 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8171 case VALUE + 4096: name = #NAME; break;
8172 #include "opcode/riscv-opc.h"
8177 static char csr_name
[10];
8178 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8189 init_dwarf_regnames_riscv (void)
8191 dwarf_regnames
= NULL
;
8192 dwarf_regnames_count
= 8192;
8193 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8197 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8199 dwarf_regnames_lookup_func
= NULL
;
8204 init_dwarf_regnames_i386 ();
8208 init_dwarf_regnames_iamcu ();
8214 init_dwarf_regnames_x86_64 ();
8218 init_dwarf_regnames_aarch64 ();
8222 init_dwarf_regnames_s390 ();
8226 init_dwarf_regnames_riscv ();
8234 /* Initialize the DWARF register name lookup state based on the
8235 architecture and specific machine type of a BFD. */
8238 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8241 dwarf_regnames_lookup_func
= NULL
;
8248 case bfd_mach_x86_64
:
8249 case bfd_mach_x86_64_intel_syntax
:
8250 case bfd_mach_x64_32
:
8251 case bfd_mach_x64_32_intel_syntax
:
8252 init_dwarf_regnames_x86_64 ();
8256 init_dwarf_regnames_i386 ();
8261 case bfd_arch_iamcu
:
8262 init_dwarf_regnames_iamcu ();
8265 case bfd_arch_aarch64
:
8266 init_dwarf_regnames_aarch64();
8270 init_dwarf_regnames_s390 ();
8273 case bfd_arch_riscv
:
8274 init_dwarf_regnames_riscv ();
8283 regname_internal_by_table_only (unsigned int regno
)
8285 if (dwarf_regnames
!= NULL
8286 && regno
< dwarf_regnames_count
8287 && dwarf_regnames
[regno
] != NULL
)
8288 return dwarf_regnames
[regno
];
8294 regname (unsigned int regno
, int name_only_p
)
8296 static char reg
[64];
8298 const char *name
= NULL
;
8300 if (dwarf_regnames_lookup_func
!= NULL
)
8301 name
= dwarf_regnames_lookup_func (regno
);
8307 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8310 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8315 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8320 if (*max_regs
!= fc
->ncols
)
8321 *max_regs
= fc
->ncols
;
8323 if (*need_col_headers
)
8325 *need_col_headers
= 0;
8327 printf ("%-*s CFA ", eh_addr_size
* 2, " LOC");
8329 for (r
= 0; r
< *max_regs
; r
++)
8330 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8335 printf ("%-5s ", regname (r
, 1));
8341 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
8343 strcpy (tmp
, "exp");
8345 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8346 printf ("%-8s ", tmp
);
8348 for (r
= 0; r
< fc
->ncols
; r
++)
8350 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8352 switch (fc
->col_type
[r
])
8354 case DW_CFA_undefined
:
8357 case DW_CFA_same_value
:
8361 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8363 case DW_CFA_val_offset
:
8364 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8366 case DW_CFA_register
:
8367 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8369 case DW_CFA_expression
:
8370 strcpy (tmp
, "exp");
8372 case DW_CFA_val_expression
:
8373 strcpy (tmp
, "vexp");
8376 strcpy (tmp
, "n/a");
8379 printf ("%-5s ", tmp
);
8385 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8387 static unsigned char *
8388 read_cie (unsigned char *start
, unsigned char *end
,
8389 Frame_Chunk
**p_cie
, int *p_version
,
8390 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
8394 unsigned char *augmentation_data
= NULL
;
8395 bfd_size_type augmentation_data_len
= 0;
8398 /* PR 17512: file: 001-228113-0.004. */
8402 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8403 memset (fc
, 0, sizeof (Frame_Chunk
));
8405 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8406 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8410 fc
->augmentation
= (char *) start
;
8411 /* PR 17512: file: 001-228113-0.004.
8412 Skip past augmentation name, but avoid running off the end of the data. */
8414 if (* start
++ == '\0')
8418 warn (_("No terminator for augmentation name\n"));
8422 if (strcmp (fc
->augmentation
, "eh") == 0)
8424 if (eh_addr_size
> (size_t) (end
- start
))
8426 start
+= eh_addr_size
;
8431 if (2 > (size_t) (end
- start
))
8433 GET (fc
->ptr_size
, 1);
8434 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8436 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8440 GET (fc
->segment_size
, 1);
8441 /* PR 17512: file: e99d2804. */
8442 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8444 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8448 eh_addr_size
= fc
->ptr_size
;
8452 fc
->ptr_size
= eh_addr_size
;
8453 fc
->segment_size
= 0;
8456 READ_ULEB (fc
->code_factor
, start
, end
);
8457 READ_SLEB (fc
->data_factor
, start
, end
);
8468 READ_ULEB (fc
->ra
, start
, end
);
8471 if (fc
->augmentation
[0] == 'z')
8475 READ_ULEB (augmentation_data_len
, start
, end
);
8476 augmentation_data
= start
;
8477 /* PR 17512: file: 11042-2589-0.004. */
8478 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8480 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
8481 dwarf_vmatoa ("x", augmentation_data_len
),
8482 (unsigned long) (end
- start
));
8485 start
+= augmentation_data_len
;
8488 if (augmentation_data_len
)
8492 unsigned char *qend
;
8494 p
= (unsigned char *) fc
->augmentation
+ 1;
8495 q
= augmentation_data
;
8496 qend
= q
+ augmentation_data_len
;
8498 while (p
< end
&& q
< qend
)
8503 q
+= 1 + size_of_encoded_value (*q
);
8505 fc
->fde_encoding
= *q
++;
8514 /* Note - it is OK if this loop terminates with q < qend.
8515 Padding may have been inserted to align the end of the CIE. */
8520 *p_version
= version
;
8523 *p_aug_len
= augmentation_data_len
;
8524 *p_aug
= augmentation_data
;
8529 free (fc
->col_offset
);
8530 free (fc
->col_type
);
8535 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8536 If do_wide is not enabled, then formats the output to fit into 80 columns.
8537 PRINTED contains the number of characters already written to the current
8541 display_data (bfd_size_type printed
,
8542 const unsigned char * data
,
8543 const bfd_size_type len
)
8545 if (do_wide
|| len
< ((80 - printed
) / 3))
8546 for (printed
= 0; printed
< len
; ++printed
)
8547 printf (" %02x", data
[printed
]);
8550 for (printed
= 0; printed
< len
; ++printed
)
8552 if (printed
% (80 / 3) == 0)
8554 printf (" %02x", data
[printed
]);
8559 /* Prints out the contents on the augmentation data array.
8560 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8563 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
8567 i
= printf (_(" Augmentation data: "));
8568 display_data (i
, data
, len
);
8572 display_debug_frames (struct dwarf_section
*section
,
8573 void *file ATTRIBUTE_UNUSED
)
8575 unsigned char *start
= section
->start
;
8576 unsigned char *end
= start
+ section
->size
;
8577 unsigned char *section_start
= start
;
8578 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8579 Frame_Chunk
*remembered_state
= NULL
;
8581 bool is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8582 unsigned int max_regs
= 0;
8583 const char *bad_reg
= _("bad register: ");
8584 unsigned int saved_eh_addr_size
= eh_addr_size
;
8586 introduce (section
, false);
8590 unsigned char *saved_start
;
8591 unsigned char *block_end
;
8596 int need_col_headers
= 1;
8597 unsigned char *augmentation_data
= NULL
;
8598 bfd_size_type augmentation_data_len
= 0;
8599 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8600 unsigned int offset_size
;
8602 static Frame_Chunk fde_fc
;
8604 saved_start
= start
;
8606 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8610 printf ("\n%08lx ZERO terminator\n\n",
8611 (unsigned long)(saved_start
- section_start
));
8612 /* Skip any zero terminators that directly follow.
8613 A corrupt section size could have loaded a whole
8614 slew of zero filled memory bytes. eg
8615 PR 17512: file: 070-19381-0.004. */
8616 while (start
< end
&& * start
== 0)
8621 if (length
== 0xffffffff)
8623 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8629 if (length
> (size_t) (end
- start
))
8631 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8632 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8633 (unsigned long) (saved_start
- section_start
));
8637 block_end
= start
+ length
;
8639 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, block_end
);
8641 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8642 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8647 start
= read_cie (start
, block_end
, &cie
, &version
,
8648 &augmentation_data_len
, &augmentation_data
);
8649 /* PR 17512: file: 027-135133-0.005. */
8656 fc
->chunk_start
= saved_start
;
8657 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8660 if (frame_need_space (fc
, mreg
) < 0)
8662 if (fc
->fde_encoding
)
8663 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8665 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8666 print_dwarf_vma (length
, fc
->ptr_size
);
8667 print_dwarf_vma (cie_id
, offset_size
);
8669 if (do_debug_frames_interp
)
8671 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8672 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8677 printf (" Version: %d\n", version
);
8678 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8681 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8682 printf (" Segment Size: %u\n", fc
->segment_size
);
8684 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8685 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8686 printf (" Return address column: %d\n", fc
->ra
);
8688 if (augmentation_data_len
)
8689 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8696 unsigned char *look_for
;
8697 unsigned long segment_selector
;
8703 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8704 cie_off
= (cie_off
^ sign
) - sign
;
8705 cie_off
= start
- 4 - section_start
- cie_off
;
8708 look_for
= section_start
+ cie_off
;
8709 if (cie_off
<= (dwarf_vma
) (saved_start
- section_start
))
8711 for (cie
= chunks
; cie
; cie
= cie
->next
)
8712 if (cie
->chunk_start
== look_for
)
8715 else if (cie_off
>= section
->size
)
8719 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8720 if (cie
->chunk_start
== look_for
)
8724 unsigned int off_size
;
8725 unsigned char *cie_scan
;
8727 cie_scan
= look_for
;
8729 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8730 if (length
== 0xffffffff)
8732 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8735 if (length
!= 0 && length
<= (size_t) (end
- cie_scan
))
8738 unsigned char *cie_end
= cie_scan
+ length
;
8740 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
,
8744 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8745 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8750 read_cie (cie_scan
, cie_end
, &cie
, &version
,
8751 &augmentation_data_len
, &augmentation_data
);
8752 /* PR 17512: file: 3450-2098-0.004. */
8755 warn (_("Failed to read CIE information\n"));
8758 cie
->next
= forward_refs
;
8760 cie
->chunk_start
= look_for
;
8761 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8764 if (frame_need_space (cie
, mreg
) < 0)
8766 warn (_("Invalid max register\n"));
8769 if (cie
->fde_encoding
)
8771 = size_of_encoded_value (cie
->fde_encoding
);
8778 memset (fc
, 0, sizeof (Frame_Chunk
));
8783 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8784 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8785 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8787 warn (_("Invalid max register\n"));
8791 fc
->augmentation
= "";
8792 fc
->fde_encoding
= 0;
8793 fc
->ptr_size
= eh_addr_size
;
8794 fc
->segment_size
= 0;
8798 fc
->ncols
= cie
->ncols
;
8799 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8800 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8801 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8802 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8803 fc
->augmentation
= cie
->augmentation
;
8804 fc
->ptr_size
= cie
->ptr_size
;
8805 eh_addr_size
= cie
->ptr_size
;
8806 fc
->segment_size
= cie
->segment_size
;
8807 fc
->code_factor
= cie
->code_factor
;
8808 fc
->data_factor
= cie
->data_factor
;
8809 fc
->cfa_reg
= cie
->cfa_reg
;
8810 fc
->cfa_offset
= cie
->cfa_offset
;
8812 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8814 warn (_("Invalid max register\n"));
8817 fc
->fde_encoding
= cie
->fde_encoding
;
8820 if (fc
->fde_encoding
)
8821 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8823 segment_selector
= 0;
8824 if (fc
->segment_size
)
8826 if (fc
->segment_size
> sizeof (segment_selector
))
8828 /* PR 17512: file: 9e196b3e. */
8829 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8830 fc
->segment_size
= 4;
8832 SAFE_BYTE_GET_AND_INC (segment_selector
, start
,
8833 fc
->segment_size
, block_end
);
8836 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
8839 /* FIXME: It appears that sometimes the final pc_range value is
8840 encoded in less than encoded_ptr_size bytes. See the x86_64
8841 run of the "objcopy on compressed debug sections" test for an
8843 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
,
8846 if (cie
->augmentation
[0] == 'z')
8848 READ_ULEB (augmentation_data_len
, start
, block_end
);
8849 augmentation_data
= start
;
8850 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8851 if (augmentation_data_len
> (bfd_size_type
) (block_end
- start
))
8853 warn (_("Augmentation data too long: 0x%s, "
8854 "expected at most %#lx\n"),
8855 dwarf_vmatoa ("x", augmentation_data_len
),
8856 (unsigned long) (block_end
- start
));
8858 augmentation_data
= NULL
;
8859 augmentation_data_len
= 0;
8861 start
+= augmentation_data_len
;
8864 printf ("\n%08lx %s %s FDE ",
8865 (unsigned long)(saved_start
- section_start
),
8866 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8867 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
));
8869 if (cie
->chunk_start
)
8870 printf ("cie=%08lx",
8871 (unsigned long) (cie
->chunk_start
- section_start
));
8873 /* Ideally translate "invalid " to 8 chars, trailing space
8875 printf (_("cie=invalid "));
8878 if (fc
->segment_size
)
8879 printf ("%04lx:", segment_selector
);
8882 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8883 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8885 if (! do_debug_frames_interp
&& augmentation_data_len
)
8887 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8892 /* At this point, fc is the current chunk, cie (if any) is set, and
8893 we're about to interpret instructions for the chunk. */
8894 /* ??? At present we need to do this always, since this sizes the
8895 fc->col_type and fc->col_offset arrays, which we write into always.
8896 We should probably split the interpreted and non-interpreted bits
8897 into two different routines, since there's so much that doesn't
8898 really overlap between them. */
8899 if (1 || do_debug_frames_interp
)
8901 /* Start by making a pass over the chunk, allocating storage
8902 and taking note of what registers are used. */
8903 unsigned char *tmp
= start
;
8905 while (start
< block_end
)
8907 unsigned int reg
, op
, opa
;
8915 /* Warning: if you add any more cases to this switch, be
8916 sure to add them to the corresponding switch below. */
8919 case DW_CFA_advance_loc
:
8922 SKIP_ULEB (start
, block_end
);
8923 if (frame_need_space (fc
, opa
) >= 0)
8924 fc
->col_type
[opa
] = DW_CFA_undefined
;
8926 case DW_CFA_restore
:
8927 if (frame_need_space (fc
, opa
) >= 0)
8928 fc
->col_type
[opa
] = DW_CFA_undefined
;
8930 case DW_CFA_set_loc
:
8931 if ((size_t) (block_end
- start
) < encoded_ptr_size
)
8934 start
+= encoded_ptr_size
;
8936 case DW_CFA_advance_loc1
:
8937 if ((size_t) (block_end
- start
) < 1)
8942 case DW_CFA_advance_loc2
:
8943 if ((size_t) (block_end
- start
) < 2)
8948 case DW_CFA_advance_loc4
:
8949 if ((size_t) (block_end
- start
) < 4)
8954 case DW_CFA_offset_extended
:
8955 case DW_CFA_val_offset
:
8956 READ_ULEB (reg
, start
, block_end
);
8957 SKIP_ULEB (start
, block_end
);
8958 if (frame_need_space (fc
, reg
) >= 0)
8959 fc
->col_type
[reg
] = DW_CFA_undefined
;
8961 case DW_CFA_restore_extended
:
8962 READ_ULEB (reg
, start
, block_end
);
8963 if (frame_need_space (fc
, reg
) >= 0)
8964 fc
->col_type
[reg
] = DW_CFA_undefined
;
8966 case DW_CFA_undefined
:
8967 READ_ULEB (reg
, start
, block_end
);
8968 if (frame_need_space (fc
, reg
) >= 0)
8969 fc
->col_type
[reg
] = DW_CFA_undefined
;
8971 case DW_CFA_same_value
:
8972 READ_ULEB (reg
, start
, block_end
);
8973 if (frame_need_space (fc
, reg
) >= 0)
8974 fc
->col_type
[reg
] = DW_CFA_undefined
;
8976 case DW_CFA_register
:
8977 READ_ULEB (reg
, start
, block_end
);
8978 SKIP_ULEB (start
, block_end
);
8979 if (frame_need_space (fc
, reg
) >= 0)
8980 fc
->col_type
[reg
] = DW_CFA_undefined
;
8982 case DW_CFA_def_cfa
:
8983 SKIP_ULEB (start
, block_end
);
8984 SKIP_ULEB (start
, block_end
);
8986 case DW_CFA_def_cfa_register
:
8987 SKIP_ULEB (start
, block_end
);
8989 case DW_CFA_def_cfa_offset
:
8990 SKIP_ULEB (start
, block_end
);
8992 case DW_CFA_def_cfa_expression
:
8993 READ_ULEB (temp
, start
, block_end
);
8994 if ((size_t) (block_end
- start
) < temp
)
8999 case DW_CFA_expression
:
9000 case DW_CFA_val_expression
:
9001 READ_ULEB (reg
, start
, block_end
);
9002 READ_ULEB (temp
, start
, block_end
);
9003 if ((size_t) (block_end
- start
) < temp
)
9007 if (frame_need_space (fc
, reg
) >= 0)
9008 fc
->col_type
[reg
] = DW_CFA_undefined
;
9010 case DW_CFA_offset_extended_sf
:
9011 case DW_CFA_val_offset_sf
:
9012 READ_ULEB (reg
, start
, block_end
);
9013 SKIP_SLEB (start
, block_end
);
9014 if (frame_need_space (fc
, reg
) >= 0)
9015 fc
->col_type
[reg
] = DW_CFA_undefined
;
9017 case DW_CFA_def_cfa_sf
:
9018 SKIP_ULEB (start
, block_end
);
9019 SKIP_SLEB (start
, block_end
);
9021 case DW_CFA_def_cfa_offset_sf
:
9022 SKIP_SLEB (start
, block_end
);
9024 case DW_CFA_MIPS_advance_loc8
:
9025 if ((size_t) (block_end
- start
) < 8)
9030 case DW_CFA_GNU_args_size
:
9031 SKIP_ULEB (start
, block_end
);
9033 case DW_CFA_GNU_negative_offset_extended
:
9034 READ_ULEB (reg
, start
, block_end
);
9035 SKIP_ULEB (start
, block_end
);
9036 if (frame_need_space (fc
, reg
) >= 0)
9037 fc
->col_type
[reg
] = DW_CFA_undefined
;
9048 /* Now we know what registers are used, make a second pass over
9049 the chunk, this time actually printing out the info. */
9051 while (start
< block_end
)
9054 unsigned long ul
, roffs
;
9055 /* Note: It is tempting to use an unsigned long for 'reg' but there
9056 are various functions, notably frame_space_needed() that assume that
9057 reg is an unsigned int. */
9062 const char *reg_prefix
= "";
9069 /* Make a note if something other than DW_CFA_nop happens. */
9070 if (op
!= DW_CFA_nop
)
9073 /* Warning: if you add any more cases to this switch, be
9074 sure to add them to the corresponding switch above. */
9077 case DW_CFA_advance_loc
:
9078 if (do_debug_frames_interp
)
9079 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9081 printf (" DW_CFA_advance_loc: %d to %s\n",
9082 opa
* fc
->code_factor
,
9083 dwarf_vmatoa_1 (NULL
,
9084 fc
->pc_begin
+ opa
* fc
->code_factor
,
9086 fc
->pc_begin
+= opa
* fc
->code_factor
;
9090 READ_ULEB (roffs
, start
, block_end
);
9091 if (opa
>= (unsigned int) fc
->ncols
)
9092 reg_prefix
= bad_reg
;
9093 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9094 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
9095 reg_prefix
, regname (opa
, 0),
9096 roffs
* fc
->data_factor
);
9097 if (*reg_prefix
== '\0')
9099 fc
->col_type
[opa
] = DW_CFA_offset
;
9100 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9104 case DW_CFA_restore
:
9105 if (opa
>= (unsigned int) fc
->ncols
)
9106 reg_prefix
= bad_reg
;
9107 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9108 printf (" DW_CFA_restore: %s%s\n",
9109 reg_prefix
, regname (opa
, 0));
9110 if (*reg_prefix
!= '\0')
9113 if (opa
>= (unsigned int) cie
->ncols
9114 || (do_debug_frames_interp
9115 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
9117 fc
->col_type
[opa
] = DW_CFA_undefined
;
9118 fc
->col_offset
[opa
] = 0;
9122 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9123 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9127 case DW_CFA_set_loc
:
9128 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9130 if (do_debug_frames_interp
)
9131 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9133 printf (" DW_CFA_set_loc: %s\n",
9134 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
9138 case DW_CFA_advance_loc1
:
9139 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, block_end
);
9140 if (do_debug_frames_interp
)
9141 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9143 printf (" DW_CFA_advance_loc1: %ld to %s\n",
9144 (unsigned long) (ofs
* fc
->code_factor
),
9145 dwarf_vmatoa_1 (NULL
,
9146 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9148 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9151 case DW_CFA_advance_loc2
:
9152 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
9153 if (do_debug_frames_interp
)
9154 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9156 printf (" DW_CFA_advance_loc2: %ld to %s\n",
9157 (unsigned long) (ofs
* fc
->code_factor
),
9158 dwarf_vmatoa_1 (NULL
,
9159 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9161 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9164 case DW_CFA_advance_loc4
:
9165 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9166 if (do_debug_frames_interp
)
9167 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9169 printf (" DW_CFA_advance_loc4: %ld to %s\n",
9170 (unsigned long) (ofs
* fc
->code_factor
),
9171 dwarf_vmatoa_1 (NULL
,
9172 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9174 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9177 case DW_CFA_offset_extended
:
9178 READ_ULEB (reg
, start
, block_end
);
9179 READ_ULEB (roffs
, start
, block_end
);
9180 if (reg
>= (unsigned int) fc
->ncols
)
9181 reg_prefix
= bad_reg
;
9182 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9183 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9184 reg_prefix
, regname (reg
, 0),
9185 roffs
* fc
->data_factor
);
9186 if (*reg_prefix
== '\0')
9188 fc
->col_type
[reg
] = DW_CFA_offset
;
9189 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9193 case DW_CFA_val_offset
:
9194 READ_ULEB (reg
, start
, block_end
);
9195 READ_ULEB (roffs
, start
, block_end
);
9196 if (reg
>= (unsigned int) fc
->ncols
)
9197 reg_prefix
= bad_reg
;
9198 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9199 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9200 reg_prefix
, regname (reg
, 0),
9201 roffs
* fc
->data_factor
);
9202 if (*reg_prefix
== '\0')
9204 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9205 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9209 case DW_CFA_restore_extended
:
9210 READ_ULEB (reg
, start
, block_end
);
9211 if (reg
>= (unsigned int) fc
->ncols
)
9212 reg_prefix
= bad_reg
;
9213 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9214 printf (" DW_CFA_restore_extended: %s%s\n",
9215 reg_prefix
, regname (reg
, 0));
9216 if (*reg_prefix
!= '\0')
9219 if (reg
>= (unsigned int) cie
->ncols
)
9221 fc
->col_type
[reg
] = DW_CFA_undefined
;
9222 fc
->col_offset
[reg
] = 0;
9226 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9227 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9231 case DW_CFA_undefined
:
9232 READ_ULEB (reg
, start
, block_end
);
9233 if (reg
>= (unsigned int) fc
->ncols
)
9234 reg_prefix
= bad_reg
;
9235 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9236 printf (" DW_CFA_undefined: %s%s\n",
9237 reg_prefix
, regname (reg
, 0));
9238 if (*reg_prefix
== '\0')
9240 fc
->col_type
[reg
] = DW_CFA_undefined
;
9241 fc
->col_offset
[reg
] = 0;
9245 case DW_CFA_same_value
:
9246 READ_ULEB (reg
, start
, block_end
);
9247 if (reg
>= (unsigned int) fc
->ncols
)
9248 reg_prefix
= bad_reg
;
9249 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9250 printf (" DW_CFA_same_value: %s%s\n",
9251 reg_prefix
, regname (reg
, 0));
9252 if (*reg_prefix
== '\0')
9254 fc
->col_type
[reg
] = DW_CFA_same_value
;
9255 fc
->col_offset
[reg
] = 0;
9259 case DW_CFA_register
:
9260 READ_ULEB (reg
, start
, block_end
);
9261 READ_ULEB (roffs
, start
, block_end
);
9262 if (reg
>= (unsigned int) fc
->ncols
)
9263 reg_prefix
= bad_reg
;
9264 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9266 printf (" DW_CFA_register: %s%s in ",
9267 reg_prefix
, regname (reg
, 0));
9268 puts (regname (roffs
, 0));
9270 if (*reg_prefix
== '\0')
9272 fc
->col_type
[reg
] = DW_CFA_register
;
9273 fc
->col_offset
[reg
] = roffs
;
9277 case DW_CFA_remember_state
:
9278 if (! do_debug_frames_interp
)
9279 printf (" DW_CFA_remember_state\n");
9280 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9281 rs
->cfa_offset
= fc
->cfa_offset
;
9282 rs
->cfa_reg
= fc
->cfa_reg
;
9284 rs
->cfa_exp
= fc
->cfa_exp
;
9285 rs
->ncols
= fc
->ncols
;
9286 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9287 sizeof (* rs
->col_type
));
9288 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9289 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9290 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9291 rs
->next
= remembered_state
;
9292 remembered_state
= rs
;
9295 case DW_CFA_restore_state
:
9296 if (! do_debug_frames_interp
)
9297 printf (" DW_CFA_restore_state\n");
9298 rs
= remembered_state
;
9301 remembered_state
= rs
->next
;
9302 fc
->cfa_offset
= rs
->cfa_offset
;
9303 fc
->cfa_reg
= rs
->cfa_reg
;
9305 fc
->cfa_exp
= rs
->cfa_exp
;
9306 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9308 warn (_("Invalid column number in saved frame state\n"));
9312 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9313 memcpy (fc
->col_offset
, rs
->col_offset
,
9314 rs
->ncols
* sizeof (* rs
->col_offset
));
9315 free (rs
->col_type
);
9316 free (rs
->col_offset
);
9319 else if (do_debug_frames_interp
)
9320 printf ("Mismatched DW_CFA_restore_state\n");
9323 case DW_CFA_def_cfa
:
9324 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9325 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9327 if (! do_debug_frames_interp
)
9328 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9329 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9332 case DW_CFA_def_cfa_register
:
9333 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9335 if (! do_debug_frames_interp
)
9336 printf (" DW_CFA_def_cfa_register: %s\n",
9337 regname (fc
->cfa_reg
, 0));
9340 case DW_CFA_def_cfa_offset
:
9341 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9342 if (! do_debug_frames_interp
)
9343 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9347 if (! do_debug_frames_interp
)
9348 printf (" DW_CFA_nop\n");
9351 case DW_CFA_def_cfa_expression
:
9352 READ_ULEB (ul
, start
, block_end
);
9353 if (ul
> (size_t) (block_end
- start
))
9355 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9358 if (! do_debug_frames_interp
)
9360 printf (" DW_CFA_def_cfa_expression (");
9361 decode_location_expression (start
, eh_addr_size
, 0, -1,
9369 case DW_CFA_expression
:
9370 READ_ULEB (reg
, start
, block_end
);
9371 READ_ULEB (ul
, start
, block_end
);
9372 if (reg
>= (unsigned int) fc
->ncols
)
9373 reg_prefix
= bad_reg
;
9374 /* PR 17512: file: 069-133014-0.006. */
9375 /* PR 17512: file: 98c02eb4. */
9376 if (ul
> (size_t) (block_end
- start
))
9378 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9381 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9383 printf (" DW_CFA_expression: %s%s (",
9384 reg_prefix
, regname (reg
, 0));
9385 decode_location_expression (start
, eh_addr_size
, 0, -1,
9389 if (*reg_prefix
== '\0')
9390 fc
->col_type
[reg
] = DW_CFA_expression
;
9394 case DW_CFA_val_expression
:
9395 READ_ULEB (reg
, start
, block_end
);
9396 READ_ULEB (ul
, start
, block_end
);
9397 if (reg
>= (unsigned int) fc
->ncols
)
9398 reg_prefix
= bad_reg
;
9399 if (ul
> (size_t) (block_end
- start
))
9401 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9404 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9406 printf (" DW_CFA_val_expression: %s%s (",
9407 reg_prefix
, regname (reg
, 0));
9408 decode_location_expression (start
, eh_addr_size
, 0, -1,
9412 if (*reg_prefix
== '\0')
9413 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9417 case DW_CFA_offset_extended_sf
:
9418 READ_ULEB (reg
, start
, block_end
);
9419 READ_SLEB (l
, start
, block_end
);
9420 if (frame_need_space (fc
, reg
) < 0)
9421 reg_prefix
= bad_reg
;
9422 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9423 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
9424 reg_prefix
, regname (reg
, 0),
9425 (long)(l
* fc
->data_factor
));
9426 if (*reg_prefix
== '\0')
9428 fc
->col_type
[reg
] = DW_CFA_offset
;
9429 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9433 case DW_CFA_val_offset_sf
:
9434 READ_ULEB (reg
, start
, block_end
);
9435 READ_SLEB (l
, start
, block_end
);
9436 if (frame_need_space (fc
, reg
) < 0)
9437 reg_prefix
= bad_reg
;
9438 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9439 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
9440 reg_prefix
, regname (reg
, 0),
9441 (long)(l
* fc
->data_factor
));
9442 if (*reg_prefix
== '\0')
9444 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9445 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9449 case DW_CFA_def_cfa_sf
:
9450 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9451 READ_SLEB (l
, start
, block_end
);
9452 l
*= fc
->data_factor
;
9455 if (! do_debug_frames_interp
)
9456 printf (" DW_CFA_def_cfa_sf: %s ofs %ld\n",
9457 regname (fc
->cfa_reg
, 0), (long) l
);
9460 case DW_CFA_def_cfa_offset_sf
:
9461 READ_SLEB (l
, start
, block_end
);
9462 l
*= fc
->data_factor
;
9464 if (! do_debug_frames_interp
)
9465 printf (" DW_CFA_def_cfa_offset_sf: %ld\n", (long) l
);
9468 case DW_CFA_MIPS_advance_loc8
:
9469 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9470 if (do_debug_frames_interp
)
9471 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9473 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
9474 (unsigned long) (ofs
* fc
->code_factor
),
9475 dwarf_vmatoa_1 (NULL
,
9476 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9478 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9481 case DW_CFA_GNU_window_save
:
9482 if (! do_debug_frames_interp
)
9483 printf (" DW_CFA_GNU_window_save\n");
9486 case DW_CFA_GNU_args_size
:
9487 READ_ULEB (ul
, start
, block_end
);
9488 if (! do_debug_frames_interp
)
9489 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9492 case DW_CFA_GNU_negative_offset_extended
:
9493 READ_ULEB (reg
, start
, block_end
);
9494 READ_SLEB (l
, start
, block_end
);
9496 if (frame_need_space (fc
, reg
) < 0)
9497 reg_prefix
= bad_reg
;
9498 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9499 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
9500 reg_prefix
, regname (reg
, 0),
9501 (long)(l
* fc
->data_factor
));
9502 if (*reg_prefix
== '\0')
9504 fc
->col_type
[reg
] = DW_CFA_offset
;
9505 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9510 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9511 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9513 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9518 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9519 if (do_debug_frames_interp
&& ! all_nops
)
9520 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9522 if (fde_fc
.col_type
!= NULL
)
9524 free (fde_fc
.col_type
);
9525 fde_fc
.col_type
= NULL
;
9527 if (fde_fc
.col_offset
!= NULL
)
9529 free (fde_fc
.col_offset
);
9530 fde_fc
.col_offset
= NULL
;
9534 eh_addr_size
= saved_eh_addr_size
;
9539 while (remembered_state
!= NULL
)
9541 rs
= remembered_state
;
9542 remembered_state
= rs
->next
;
9543 free (rs
->col_type
);
9544 free (rs
->col_offset
);
9545 rs
->next
= NULL
; /* Paranoia. */
9549 while (chunks
!= NULL
)
9553 free (rs
->col_type
);
9554 free (rs
->col_offset
);
9555 rs
->next
= NULL
; /* Paranoia. */
9559 while (forward_refs
!= NULL
)
9562 forward_refs
= rs
->next
;
9563 free (rs
->col_type
);
9564 free (rs
->col_offset
);
9565 rs
->next
= NULL
; /* Paranoia. */
9575 display_debug_names (struct dwarf_section
*section
, void *file
)
9577 unsigned char *hdrptr
= section
->start
;
9578 dwarf_vma unit_length
;
9579 unsigned char *unit_start
;
9580 const unsigned char *const section_end
= section
->start
+ section
->size
;
9581 unsigned char *unit_end
;
9583 introduce (section
, false);
9585 load_debug_section_with_follow (str
, file
);
9587 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9589 unsigned int offset_size
;
9590 uint16_t dwarf_version
, padding
;
9591 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9592 uint64_t bucket_count
, name_count
, abbrev_table_size
;
9593 uint32_t augmentation_string_size
;
9595 bool augmentation_printable
;
9596 const char *augmentation_string
;
9599 unit_start
= hdrptr
;
9601 /* Get and check the length of the block. */
9602 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9604 if (unit_length
== 0xffffffff)
9606 /* This section is 64-bit DWARF. */
9607 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9613 if (unit_length
> (size_t) (section_end
- hdrptr
)
9614 || unit_length
< 2 + 2 + 4 * 7)
9617 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9619 (unsigned long) (unit_start
- section
->start
),
9620 dwarf_vmatoa ("x", unit_length
));
9623 unit_end
= hdrptr
+ unit_length
;
9625 /* Get and check the version number. */
9626 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9627 printf (_("Version %ld\n"), (long) dwarf_version
);
9629 /* Prior versions did not exist, and future versions may not be
9630 backwards compatible. */
9631 if (dwarf_version
!= 5)
9633 warn (_("Only DWARF version 5 .debug_names "
9634 "is currently supported.\n"));
9638 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9640 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9643 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9644 if (comp_unit_count
== 0)
9645 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9647 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9648 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9649 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9650 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9651 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9653 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9654 if (augmentation_string_size
% 4 != 0)
9656 warn (_("Augmentation string length %u must be rounded up "
9657 "to a multiple of 4 in .debug_names.\n"),
9658 augmentation_string_size
);
9659 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9661 if (augmentation_string_size
> (size_t) (unit_end
- hdrptr
))
9664 printf (_("Augmentation string:"));
9666 augmentation_printable
= true;
9667 augmentation_string
= (const char *) hdrptr
;
9669 for (i
= 0; i
< augmentation_string_size
; i
++)
9673 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9674 printf (" %02x", uc
);
9676 if (uc
!= 0 && !ISPRINT (uc
))
9677 augmentation_printable
= false;
9680 if (augmentation_printable
)
9684 i
< augmentation_string_size
&& augmentation_string
[i
];
9686 putchar (augmentation_string
[i
]);
9691 printf (_("CU table:\n"));
9692 if (_mul_overflow (comp_unit_count
, offset_size
, &total
)
9693 || total
> (size_t) (unit_end
- hdrptr
))
9695 for (i
= 0; i
< comp_unit_count
; i
++)
9699 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9700 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9704 printf (_("TU table:\n"));
9705 if (_mul_overflow (local_type_unit_count
, offset_size
, &total
)
9706 || total
> (size_t) (unit_end
- hdrptr
))
9708 for (i
= 0; i
< local_type_unit_count
; i
++)
9712 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9713 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9717 printf (_("Foreign TU table:\n"));
9718 if (_mul_overflow (foreign_type_unit_count
, 8, &total
)
9719 || total
> (size_t) (unit_end
- hdrptr
))
9721 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9725 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9726 printf (_("[%3u] "), i
);
9727 print_dwarf_vma (signature
, 8);
9732 uint64_t xtra
= (bucket_count
* sizeof (uint32_t)
9733 + name_count
* (sizeof (uint32_t) + 2 * offset_size
)
9734 + abbrev_table_size
);
9735 if (xtra
> (size_t) (unit_end
- hdrptr
))
9737 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9738 "for unit 0x%lx in the debug_names\n"),
9740 (long) (unit_end
- unit_start
),
9741 (long) (unit_start
- section
->start
));
9744 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9745 hdrptr
+= bucket_count
* sizeof (uint32_t);
9746 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9747 hdrptr
+= name_count
* sizeof (uint32_t);
9748 unsigned char *const name_table_string_offsets
= hdrptr
;
9749 hdrptr
+= name_count
* offset_size
;
9750 unsigned char *const name_table_entry_offsets
= hdrptr
;
9751 hdrptr
+= name_count
* offset_size
;
9752 unsigned char *const abbrev_table
= hdrptr
;
9753 hdrptr
+= abbrev_table_size
;
9754 const unsigned char *const abbrev_table_end
= hdrptr
;
9755 unsigned char *const entry_pool
= hdrptr
;
9757 size_t buckets_filled
= 0;
9759 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9761 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9766 printf (ngettext ("Used %zu of %lu bucket.\n",
9767 "Used %zu of %lu buckets.\n",
9769 buckets_filled
, (unsigned long) bucket_count
);
9771 uint32_t hash_prev
= 0;
9772 size_t hash_clash_count
= 0;
9773 size_t longest_clash
= 0;
9774 size_t this_length
= 0;
9776 for (hashi
= 0; hashi
< name_count
; hashi
++)
9778 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9782 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9786 longest_clash
= MAX (longest_clash
, this_length
);
9791 hash_prev
= hash_this
;
9793 printf (_("Out of %lu items there are %zu bucket clashes"
9794 " (longest of %zu entries).\n"),
9795 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9796 assert (name_count
== buckets_filled
+ hash_clash_count
);
9798 struct abbrev_lookup_entry
9800 dwarf_vma abbrev_tag
;
9801 unsigned char *abbrev_lookup_ptr
;
9803 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9804 size_t abbrev_lookup_used
= 0;
9805 size_t abbrev_lookup_allocated
= 0;
9807 unsigned char *abbrevptr
= abbrev_table
;
9810 dwarf_vma abbrev_tag
;
9812 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9813 if (abbrev_tag
== 0)
9815 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9817 abbrev_lookup_allocated
= MAX (0x100,
9818 abbrev_lookup_allocated
* 2);
9819 abbrev_lookup
= xrealloc (abbrev_lookup
,
9820 (abbrev_lookup_allocated
9821 * sizeof (*abbrev_lookup
)));
9823 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9824 struct abbrev_lookup_entry
*entry
;
9825 for (entry
= abbrev_lookup
;
9826 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9828 if (entry
->abbrev_tag
== abbrev_tag
)
9830 warn (_("Duplicate abbreviation tag %lu "
9831 "in unit 0x%lx in the debug_names\n"),
9832 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9835 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9836 entry
->abbrev_tag
= abbrev_tag
;
9837 entry
->abbrev_lookup_ptr
= abbrevptr
;
9839 /* Skip DWARF tag. */
9840 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9843 dwarf_vma xindex
, form
;
9845 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9846 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9847 if (xindex
== 0 && form
== 0)
9852 printf (_("\nSymbol table:\n"));
9854 for (namei
= 0; namei
< name_count
; ++namei
)
9856 uint64_t string_offset
, entry_offset
;
9859 p
= name_table_string_offsets
+ namei
* offset_size
;
9860 SAFE_BYTE_GET (string_offset
, p
, offset_size
, unit_end
);
9861 p
= name_table_entry_offsets
+ namei
* offset_size
;
9862 SAFE_BYTE_GET (entry_offset
, p
, offset_size
, unit_end
);
9864 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9865 fetch_indirect_string (string_offset
));
9867 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9869 /* We need to scan first whether there is a single or multiple
9870 entries. TAGNO is -2 for the first entry, it is -1 for the
9871 initial tag read of the second entry, then it becomes 0 for the
9872 first entry for real printing etc. */
9874 /* Initialize it due to a false compiler warning. */
9875 dwarf_vma second_abbrev_tag
= -1;
9878 dwarf_vma abbrev_tag
;
9879 dwarf_vma dwarf_tag
;
9880 const struct abbrev_lookup_entry
*entry
;
9882 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9885 second_abbrev_tag
= abbrev_tag
;
9887 entryptr
= entry_pool
+ entry_offset
;
9890 if (abbrev_tag
== 0)
9894 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9895 (unsigned long) abbrev_tag
);
9897 for (entry
= abbrev_lookup
;
9898 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9900 if (entry
->abbrev_tag
== abbrev_tag
)
9902 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9904 warn (_("Undefined abbreviation tag %lu "
9905 "in unit 0x%lx in the debug_names\n"),
9907 (long) (unit_start
- section
->start
));
9910 abbrevptr
= entry
->abbrev_lookup_ptr
;
9911 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9913 printf (" %s", get_TAG_name (dwarf_tag
));
9916 dwarf_vma xindex
, form
;
9918 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9919 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9920 if (xindex
== 0 && form
== 0)
9924 printf (" %s", get_IDX_name (xindex
));
9925 entryptr
= read_and_display_attr_value (0, form
, 0,
9926 unit_start
, entryptr
, unit_end
,
9928 dwarf_version
, NULL
,
9935 printf (_(" <no entries>"));
9939 free (abbrev_lookup
);
9946 display_debug_links (struct dwarf_section
* section
,
9947 void * file ATTRIBUTE_UNUSED
)
9949 const unsigned char * filename
;
9950 unsigned int filelen
;
9952 introduce (section
, false);
9954 /* The .gnu_debuglink section is formatted as:
9955 (c-string) Filename.
9956 (padding) If needed to reach a 4 byte boundary.
9957 (uint32_t) CRC32 value.
9959 The .gun_debugaltlink section is formatted as:
9960 (c-string) Filename.
9961 (binary) Build-ID. */
9963 filename
= section
->start
;
9964 filelen
= strnlen ((const char *) filename
, section
->size
);
9965 if (filelen
== section
->size
)
9967 warn (_("The debuglink filename is corrupt/missing\n"));
9971 printf (_(" Separate debug info file: %s\n"), filename
);
9973 if (startswith (section
->name
, ".gnu_debuglink"))
9976 unsigned int crc_offset
;
9978 crc_offset
= filelen
+ 1;
9979 crc_offset
= (crc_offset
+ 3) & ~3;
9980 if (crc_offset
+ 4 > section
->size
)
9982 warn (_("CRC offset missing/truncated\n"));
9986 crc32
= byte_get (filename
+ crc_offset
, 4);
9988 printf (_(" CRC value: %#x\n"), crc32
);
9990 if (crc_offset
+ 4 < section
->size
)
9992 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9993 (long)(section
->size
- (crc_offset
+ 4)));
9997 else /* startswith (section->name, ".gnu_debugaltlink") */
9999 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
10000 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
10001 bfd_size_type printed
;
10003 /* FIXME: Should we support smaller build-id notes ? */
10004 if (build_id_len
< 0x14)
10006 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
10010 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
10011 display_data (printed
, build_id
, build_id_len
);
10020 display_gdb_index (struct dwarf_section
*section
,
10021 void *file ATTRIBUTE_UNUSED
)
10023 unsigned char *start
= section
->start
;
10025 uint32_t cu_list_offset
, tu_list_offset
;
10026 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
10027 unsigned int cu_list_elements
, tu_list_elements
;
10028 unsigned int address_table_size
, symbol_table_slots
;
10029 unsigned char *cu_list
, *tu_list
;
10030 unsigned char *address_table
, *symbol_table
, *constant_pool
;
10033 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
10035 introduce (section
, false);
10037 if (section
->size
< 6 * sizeof (uint32_t))
10039 warn (_("Truncated header in the %s section.\n"), section
->name
);
10043 version
= byte_get_little_endian (start
, 4);
10044 printf (_("Version %ld\n"), (long) version
);
10046 /* Prior versions are obsolete, and future versions may not be
10047 backwards compatible. */
10048 if (version
< 3 || version
> 8)
10050 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
10054 warn (_("The address table data in version 3 may be wrong.\n"));
10056 warn (_("Version 4 does not support case insensitive lookups.\n"));
10058 warn (_("Version 5 does not include inlined functions.\n"));
10060 warn (_("Version 6 does not include symbol attributes.\n"));
10061 /* Version 7 indices generated by Gold have bad type unit references,
10062 PR binutils/15021. But we don't know if the index was generated by
10063 Gold or not, so to avoid worrying users with gdb-generated indices
10064 we say nothing for version 7 here. */
10066 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
10067 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
10068 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
10069 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
10070 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
10072 if (cu_list_offset
> section
->size
10073 || tu_list_offset
> section
->size
10074 || address_table_offset
> section
->size
10075 || symbol_table_offset
> section
->size
10076 || constant_pool_offset
> section
->size
)
10078 warn (_("Corrupt header in the %s section.\n"), section
->name
);
10082 /* PR 17531: file: 418d0a8a. */
10083 if (tu_list_offset
< cu_list_offset
)
10085 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
10086 tu_list_offset
, cu_list_offset
);
10090 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
10092 if (address_table_offset
< tu_list_offset
)
10094 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
10095 address_table_offset
, tu_list_offset
);
10099 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
10101 /* PR 17531: file: 18a47d3d. */
10102 if (symbol_table_offset
< address_table_offset
)
10104 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
10105 symbol_table_offset
, address_table_offset
);
10109 address_table_size
= symbol_table_offset
- address_table_offset
;
10111 if (constant_pool_offset
< symbol_table_offset
)
10113 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
10114 constant_pool_offset
, symbol_table_offset
);
10118 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
10120 cu_list
= start
+ cu_list_offset
;
10121 tu_list
= start
+ tu_list_offset
;
10122 address_table
= start
+ address_table_offset
;
10123 symbol_table
= start
+ symbol_table_offset
;
10124 constant_pool
= start
+ constant_pool_offset
;
10126 if (address_table_offset
+ address_table_size
> section
->size
)
10128 warn (_("Address table extends beyond end of section.\n"));
10132 printf (_("\nCU table:\n"));
10133 for (i
= 0; i
< cu_list_elements
; i
+= 2)
10135 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
10136 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
10138 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
10139 (unsigned long) cu_offset
,
10140 (unsigned long) (cu_offset
+ cu_length
- 1));
10143 printf (_("\nTU table:\n"));
10144 for (i
= 0; i
< tu_list_elements
; i
+= 3)
10146 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
10147 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
10148 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
10150 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
10151 (unsigned long) tu_offset
,
10152 (unsigned long) type_offset
);
10153 print_dwarf_vma (signature
, 8);
10157 printf (_("\nAddress table:\n"));
10158 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
10161 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
10162 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
10163 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
10165 print_dwarf_vma (low
, 8);
10166 print_dwarf_vma (high
, 8);
10167 printf (_("%lu\n"), (unsigned long) cu_index
);
10170 printf (_("\nSymbol table:\n"));
10171 for (i
= 0; i
< symbol_table_slots
; ++i
)
10173 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10174 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10175 uint32_t num_cus
, cu
;
10177 if (name_offset
!= 0
10178 || cu_vector_offset
!= 0)
10182 /* PR 17531: file: 5b7b07ad. */
10183 if (name_offset
>= section
->size
- constant_pool_offset
)
10185 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10186 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10190 printf ("[%3u] %.*s:", i
,
10191 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10192 constant_pool
+ name_offset
);
10194 if (section
->size
- constant_pool_offset
< 4
10195 || cu_vector_offset
> section
->size
- constant_pool_offset
- 4)
10197 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10198 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10199 cu_vector_offset
, i
);
10203 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
10205 if ((uint64_t) num_cus
* 4 > section
->size
- (constant_pool_offset
10206 + cu_vector_offset
+ 4))
10208 printf ("<invalid number of CUs: %d>\n", num_cus
);
10209 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10217 for (j
= 0; j
< num_cus
; ++j
)
10220 gdb_index_symbol_kind kind
;
10222 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10223 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10224 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10225 cu
= GDB_INDEX_CU_VALUE (cu
);
10226 /* Convert to TU number if it's for a type unit. */
10227 if (cu
>= cu_list_elements
/ 2)
10228 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10229 (unsigned long) (cu
- cu_list_elements
/ 2));
10231 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10233 printf (" [%s, %s]",
10234 is_static
? _("static") : _("global"),
10235 get_gdb_index_symbol_kind_name (kind
));
10247 /* Pre-allocate enough space for the CU/TU sets needed. */
10250 prealloc_cu_tu_list (unsigned int nshndx
)
10252 if (shndx_pool
== NULL
)
10254 shndx_pool_size
= nshndx
;
10255 shndx_pool_used
= 0;
10256 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10257 sizeof (unsigned int));
10261 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10262 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10263 sizeof (unsigned int));
10268 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10270 if (shndx_pool_used
>= shndx_pool_size
)
10272 error (_("Internal error: out of space in the shndx pool.\n"));
10275 shndx_pool
[shndx_pool_used
++] = shndx
;
10279 end_cu_tu_entry (void)
10281 if (shndx_pool_used
>= shndx_pool_size
)
10283 error (_("Internal error: out of space in the shndx pool.\n"));
10286 shndx_pool
[shndx_pool_used
++] = 0;
10289 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10291 static const char *
10292 get_DW_SECT_short_name (unsigned int dw_sect
)
10294 static char buf
[16];
10300 case DW_SECT_TYPES
:
10302 case DW_SECT_ABBREV
:
10308 case DW_SECT_STR_OFFSETS
:
10310 case DW_SECT_MACINFO
:
10312 case DW_SECT_MACRO
:
10318 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10322 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10323 These sections are extensions for Fission.
10324 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10327 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10329 unsigned char *phdr
= section
->start
;
10330 unsigned char *limit
= phdr
+ section
->size
;
10331 unsigned char *phash
;
10332 unsigned char *pindex
;
10333 unsigned char *ppool
;
10334 unsigned int version
;
10335 unsigned int ncols
= 0;
10336 unsigned int nused
;
10337 unsigned int nslots
;
10340 dwarf_vma signature
;
10343 /* PR 17512: file: 002-168123-0.004. */
10346 warn (_("Section %s is empty\n"), section
->name
);
10349 /* PR 17512: file: 002-376-0.004. */
10350 if (section
->size
< 24)
10352 warn (_("Section %s is too small to contain a CU/TU header\n"),
10358 SAFE_BYTE_GET_AND_INC (version
, phash
, 4, limit
);
10360 SAFE_BYTE_GET_AND_INC (ncols
, phash
, 4, limit
);
10361 SAFE_BYTE_GET_AND_INC (nused
, phash
, 4, limit
);
10362 SAFE_BYTE_GET_AND_INC (nslots
, phash
, 4, limit
);
10364 pindex
= phash
+ (size_t) nslots
* 8;
10365 ppool
= pindex
+ (size_t) nslots
* 4;
10369 introduce (section
, false);
10371 printf (_(" Version: %u\n"), version
);
10373 printf (_(" Number of columns: %u\n"), ncols
);
10374 printf (_(" Number of used entries: %u\n"), nused
);
10375 printf (_(" Number of slots: %u\n\n"), nslots
);
10378 /* PR 17531: file: 45d69832. */
10379 if (_mul_overflow ((size_t) nslots
, 12, &total
)
10380 || total
> (size_t) (limit
- phash
))
10382 warn (ngettext ("Section %s is too small for %u slot\n",
10383 "Section %s is too small for %u slots\n",
10385 section
->name
, nslots
);
10392 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10393 for (i
= 0; i
< nslots
; i
++)
10395 unsigned char *shndx_list
;
10396 unsigned int shndx
;
10398 SAFE_BYTE_GET (signature
, phash
, 8, limit
);
10399 if (signature
!= 0)
10401 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10402 shndx_list
= ppool
+ j
* 4;
10403 /* PR 17531: file: 705e010d. */
10404 if (shndx_list
< ppool
)
10406 warn (_("Section index pool located before start of section\n"));
10411 printf (_(" [%3d] Signature: 0x%s Sections: "),
10412 i
, dwarf_vmatoa ("x", signature
));
10415 if (shndx_list
>= limit
)
10417 warn (_("Section %s too small for shndx pool\n"),
10421 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10425 printf (" %d", shndx
);
10427 add_shndx_to_cu_tu_entry (shndx
);
10433 end_cu_tu_entry ();
10439 else if (version
== 2)
10442 unsigned int dw_sect
;
10443 unsigned char *ph
= phash
;
10444 unsigned char *pi
= pindex
;
10445 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10446 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10448 struct cu_tu_set
*this_set
= NULL
;
10450 unsigned char *prow
;
10453 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10455 /* PR 17531: file: 0dd159bf.
10456 Check for integer overflow (can occur when size_t is 32-bit)
10457 with overlarge ncols or nused values. */
10459 || _mul_overflow ((size_t) ncols
, 4, &temp
)
10460 || _mul_overflow ((size_t) nused
+ 1, temp
, &total
)
10461 || total
> (size_t) (limit
- ppool
))
10463 warn (_("Section %s too small for offset and size tables\n"),
10470 printf (_(" Offset table\n"));
10471 printf (" slot %-16s ",
10472 is_tu_index
? _("signature") : _("dwo_id"));
10479 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10480 this_set
= tu_sets
;
10485 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10486 this_set
= cu_sets
;
10492 for (j
= 0; j
< ncols
; j
++)
10494 unsigned char *p
= ppool
+ j
* 4;
10495 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10496 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10501 for (i
= 0; i
< nslots
; i
++)
10503 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10505 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10508 /* PR 17531: file: a05f6ab3. */
10511 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10518 size_t num_copy
= sizeof (uint64_t);
10520 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10523 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10525 printf (_(" [%3d] 0x%s"),
10526 i
, dwarf_vmatoa ("x", signature
));
10527 for (j
= 0; j
< ncols
; j
++)
10529 unsigned char *p
= prow
+ j
* 4;
10530 SAFE_BYTE_GET (val
, p
, 4, limit
);
10532 printf (" %8d", val
);
10536 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10538 /* PR 17531: file: 10796eb3. */
10539 if (dw_sect
>= DW_SECT_MAX
)
10540 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10542 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10558 printf (_(" Size table\n"));
10559 printf (" slot %-16s ",
10560 is_tu_index
? _("signature") : _("dwo_id"));
10563 for (j
= 0; j
< ncols
; j
++)
10565 unsigned char *p
= ppool
+ j
* 4;
10566 SAFE_BYTE_GET (val
, p
, 4, limit
);
10568 printf (" %8s", get_DW_SECT_short_name (val
));
10574 for (i
= 0; i
< nslots
; i
++)
10576 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10578 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10581 prow
= psizes
+ (row
- 1) * ncols
* 4;
10584 printf (_(" [%3d] 0x%s"),
10585 i
, dwarf_vmatoa ("x", signature
));
10587 for (j
= 0; j
< ncols
; j
++)
10589 unsigned char *p
= prow
+ j
* 4;
10590 SAFE_BYTE_GET (val
, p
, 4, limit
);
10592 printf (" %8d", val
);
10596 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10597 if (dw_sect
>= DW_SECT_MAX
)
10598 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10600 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10612 else if (do_display
)
10613 printf (_(" Unsupported version (%d)\n"), version
);
10621 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10623 /* Load the CU and TU indexes if present. This will build a list of
10624 section sets that we can use to associate a .debug_info.dwo section
10625 with its associated .debug_abbrev.dwo section in a .dwp file. */
10628 load_cu_tu_indexes (void *file
)
10630 /* If we have already loaded (or tried to load) the CU and TU indexes
10631 then do not bother to repeat the task. */
10632 if (cu_tu_indexes_read
== -1)
10634 cu_tu_indexes_read
= true;
10636 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10637 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10638 cu_tu_indexes_read
= false;
10640 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10641 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10642 cu_tu_indexes_read
= false;
10645 return (bool) cu_tu_indexes_read
;
10648 /* Find the set of sections that includes section SHNDX. */
10651 find_cu_tu_set (void *file
, unsigned int shndx
)
10655 if (! load_cu_tu_indexes (file
))
10658 /* Find SHNDX in the shndx pool. */
10659 for (i
= 0; i
< shndx_pool_used
; i
++)
10660 if (shndx_pool
[i
] == shndx
)
10663 if (i
>= shndx_pool_used
)
10666 /* Now backup to find the first entry in the set. */
10667 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10670 return shndx_pool
+ i
;
10673 /* Display a .debug_cu_index or .debug_tu_index section. */
10676 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10678 return process_cu_tu_index (section
, 1);
10682 display_debug_not_supported (struct dwarf_section
*section
,
10683 void *file ATTRIBUTE_UNUSED
)
10685 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10691 /* Like malloc, but takes two parameters like calloc.
10692 Verifies that the first parameter is not too large.
10693 Note: does *not* initialise the allocated memory to zero. */
10696 cmalloc (size_t nmemb
, size_t size
)
10698 /* Check for overflow. */
10699 if (nmemb
>= ~(size_t) 0 / size
)
10702 return xmalloc (nmemb
* size
);
10705 /* Like xmalloc, but takes two parameters like calloc.
10706 Verifies that the first parameter is not too large.
10707 Note: does *not* initialise the allocated memory to zero. */
10710 xcmalloc (size_t nmemb
, size_t size
)
10712 /* Check for overflow. */
10713 if (nmemb
>= ~(size_t) 0 / size
)
10716 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10721 return xmalloc (nmemb
* size
);
10724 /* Like xrealloc, but takes three parameters.
10725 Verifies that the second parameter is not too large.
10726 Note: does *not* initialise any new memory to zero. */
10729 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10731 /* Check for overflow. */
10732 if (nmemb
>= ~(size_t) 0 / size
)
10734 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10739 return xrealloc (ptr
, nmemb
* size
);
10742 /* Like xcalloc, but verifies that the first parameter is not too large. */
10745 xcalloc2 (size_t nmemb
, size_t size
)
10747 /* Check for overflow. */
10748 if (nmemb
>= ~(size_t) 0 / size
)
10750 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10755 return xcalloc (nmemb
, size
);
10758 static unsigned long
10759 calc_gnu_debuglink_crc32 (unsigned long crc
,
10760 const unsigned char * buf
,
10763 static const unsigned long crc32_table
[256] =
10765 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10766 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10767 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10768 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10769 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10770 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10771 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10772 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10773 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10774 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10775 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10776 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10777 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10778 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10779 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10780 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10781 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10782 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10783 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10784 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10785 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10786 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10787 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10788 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10789 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10790 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10791 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10792 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10793 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10794 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10795 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10796 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10797 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10798 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10799 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10800 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10801 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10802 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10803 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10804 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10805 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10806 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10807 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10808 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10809 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10810 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10811 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10812 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10813 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10814 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10815 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10818 const unsigned char *end
;
10820 crc
= ~crc
& 0xffffffff;
10821 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10822 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10823 return ~crc
& 0xffffffff;
10826 typedef bool (*check_func_type
) (const char *, void *);
10827 typedef const char *(* parse_func_type
) (struct dwarf_section
*, void *);
10830 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10832 static unsigned char buffer
[8 * 1024];
10834 bfd_size_type count
;
10835 unsigned long crc
= 0;
10838 sep_data
= open_debug_file (pathname
);
10839 if (sep_data
== NULL
)
10842 /* Yes - we are opening the file twice... */
10843 f
= fopen (pathname
, "rb");
10846 /* Paranoia: This should never happen. */
10847 close_debug_file (sep_data
);
10848 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10852 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10853 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10857 if (crc
!= * (unsigned long *) crc_pointer
)
10859 close_debug_file (sep_data
);
10860 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10868 static const char *
10869 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10872 unsigned int crc_offset
;
10873 unsigned long * crc32
= (unsigned long *) data
;
10875 /* The name is first.
10876 The CRC value is stored after the filename, aligned up to 4 bytes. */
10877 name
= (const char *) section
->start
;
10879 crc_offset
= strnlen (name
, section
->size
) + 1;
10880 if (crc_offset
== 1)
10882 crc_offset
= (crc_offset
+ 3) & ~3;
10883 if (crc_offset
+ 4 > section
->size
)
10886 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10891 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10893 void * sep_data
= open_debug_file (filename
);
10895 if (sep_data
== NULL
)
10898 /* FIXME: We should now extract the build-id in the separate file
10904 typedef struct build_id_data
10907 const unsigned char * data
;
10910 static const char *
10911 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10914 bfd_size_type namelen
;
10915 bfd_size_type id_len
;
10916 Build_id_data
* build_id_data
;
10918 /* The name is first.
10919 The build-id follows immediately, with no padding, up to the section's end. */
10921 name
= (const char *) section
->start
;
10922 namelen
= strnlen (name
, section
->size
) + 1;
10925 if (namelen
>= section
->size
)
10928 id_len
= section
->size
- namelen
;
10932 build_id_data
= (Build_id_data
*) data
;
10933 build_id_data
->len
= id_len
;
10934 build_id_data
->data
= section
->start
+ namelen
;
10940 add_separate_debug_file (const char * filename
, void * handle
)
10942 separate_info
* i
= xmalloc (sizeof * i
);
10944 i
->filename
= filename
;
10945 i
->handle
= handle
;
10946 i
->next
= first_separate_info
;
10947 first_separate_info
= i
;
10950 #if HAVE_LIBDEBUGINFOD
10951 /* Query debuginfod servers for the target debuglink or debugaltlink
10952 file. If successful, store the path of the file in filename and
10953 return TRUE, otherwise return FALSE. */
10956 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10960 size_t build_id_len
;
10961 unsigned char * build_id
;
10963 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10965 /* Get the build-id of file. */
10966 build_id
= get_build_id (file
);
10969 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10971 /* Get the build-id of the debugaltlink file. */
10972 unsigned int filelen
;
10974 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10975 if (filelen
== section
->size
)
10976 /* Corrupt debugaltlink. */
10979 build_id
= section
->start
+ filelen
+ 1;
10980 build_id_len
= section
->size
- (filelen
+ 1);
10982 if (build_id_len
== 0)
10991 debuginfod_client
* client
;
10993 client
= debuginfod_begin ();
10994 if (client
== NULL
)
10997 /* Query debuginfod servers for the target file. If found its path
10998 will be stored in filename. */
10999 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
11000 debuginfod_end (client
);
11002 /* Only free build_id if we allocated space for a hex string
11003 in get_build_id (). */
11004 if (build_id_len
== 0)
11009 /* File successfully retrieved. Close fd since we want to
11010 use open_debug_file () on filename instead. */
11021 load_separate_debug_info (const char * main_filename
,
11022 struct dwarf_section
* xlink
,
11023 parse_func_type parse_func
,
11024 check_func_type check_func
,
11026 void * file ATTRIBUTE_UNUSED
)
11028 const char * separate_filename
;
11029 char * debug_filename
;
11031 size_t canon_dirlen
;
11034 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
11036 warn (_("Corrupt debuglink section: %s\n"),
11037 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
11041 /* Attempt to locate the separate file.
11042 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
11044 canon_dir
= lrealpath (main_filename
);
11046 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
11047 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
11049 canon_dir
[canon_dirlen
] = '\0';
11052 #define DEBUGDIR "/lib/debug"
11054 #ifndef EXTRA_DEBUG_ROOT1
11055 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
11057 #ifndef EXTRA_DEBUG_ROOT2
11058 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
11061 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
11063 + strlen (".debug/")
11064 #ifdef EXTRA_DEBUG_ROOT1
11065 + strlen (EXTRA_DEBUG_ROOT1
)
11067 #ifdef EXTRA_DEBUG_ROOT2
11068 + strlen (EXTRA_DEBUG_ROOT2
)
11070 + strlen (separate_filename
)
11072 if (debug_filename
== NULL
)
11074 warn (_("Out of memory"));
11079 /* First try in the current directory. */
11080 sprintf (debug_filename
, "%s", separate_filename
);
11081 if (check_func (debug_filename
, func_data
))
11084 /* Then try in a subdirectory called .debug. */
11085 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11086 if (check_func (debug_filename
, func_data
))
11089 /* Then try in the same directory as the original file. */
11090 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11091 if (check_func (debug_filename
, func_data
))
11094 /* And the .debug subdirectory of that directory. */
11095 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11096 if (check_func (debug_filename
, func_data
))
11099 #ifdef EXTRA_DEBUG_ROOT1
11100 /* Try the first extra debug file root. */
11101 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11102 if (check_func (debug_filename
, func_data
))
11105 /* Try the first extra debug file root. */
11106 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
11107 if (check_func (debug_filename
, func_data
))
11111 #ifdef EXTRA_DEBUG_ROOT2
11112 /* Try the second extra debug file root. */
11113 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
11114 if (check_func (debug_filename
, func_data
))
11118 /* Then try in the global debug_filename directory. */
11119 strcpy (debug_filename
, DEBUGDIR
);
11120 dirlen
= strlen (DEBUGDIR
) - 1;
11121 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
11122 strcat (debug_filename
, "/");
11123 strcat (debug_filename
, (const char *) separate_filename
);
11125 if (check_func (debug_filename
, func_data
))
11128 #if HAVE_LIBDEBUGINFOD
11130 char * tmp_filename
;
11132 if (debuginfod_fetch_separate_debug_info (xlink
,
11136 /* File successfully downloaded from server, replace
11137 debug_filename with the file's path. */
11138 free (debug_filename
);
11139 debug_filename
= tmp_filename
;
11145 if (do_debug_links
)
11147 /* Failed to find the file. */
11148 warn (_("could not find separate debug file '%s'\n"),
11149 separate_filename
);
11150 warn (_("tried: %s\n"), debug_filename
);
11152 #ifdef EXTRA_DEBUG_ROOT2
11153 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
,
11154 separate_filename
);
11155 warn (_("tried: %s\n"), debug_filename
);
11158 #ifdef EXTRA_DEBUG_ROOT1
11159 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
,
11160 canon_dir
, separate_filename
);
11161 warn (_("tried: %s\n"), debug_filename
);
11163 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
,
11164 separate_filename
);
11165 warn (_("tried: %s\n"), debug_filename
);
11168 sprintf (debug_filename
, "%s.debug/%s", canon_dir
,
11169 separate_filename
);
11170 warn (_("tried: %s\n"), debug_filename
);
11172 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11173 warn (_("tried: %s\n"), debug_filename
);
11175 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11176 warn (_("tried: %s\n"), debug_filename
);
11178 sprintf (debug_filename
, "%s", separate_filename
);
11179 warn (_("tried: %s\n"), debug_filename
);
11181 #if HAVE_LIBDEBUGINFOD
11183 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11187 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11193 free (debug_filename
);
11199 void * debug_handle
;
11201 /* Now open the file.... */
11202 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11204 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11205 free (debug_filename
);
11209 /* FIXME: We do not check to see if there are any other separate debug info
11210 files that would also match. */
11212 if (do_debug_links
)
11213 printf (_("\n%s: Found separate debug info file: %s\n"), main_filename
, debug_filename
);
11214 add_separate_debug_file (debug_filename
, debug_handle
);
11216 /* Do not free debug_filename - it might be referenced inside
11217 the structure returned by open_debug_file(). */
11218 return debug_handle
;
11221 /* Attempt to load a separate dwarf object file. */
11224 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11226 char * separate_filename
;
11227 void * separate_handle
;
11229 if (IS_ABSOLUTE_PATH (name
))
11230 separate_filename
= strdup (name
);
11232 /* FIXME: Skip adding / if dwo_dir ends in /. */
11233 separate_filename
= concat (dir
, "/", name
, NULL
);
11234 if (separate_filename
== NULL
)
11236 warn (_("Out of memory allocating dwo filename\n"));
11240 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11242 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11243 free (separate_filename
);
11247 /* FIXME: We should check the dwo_id. */
11249 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11251 add_separate_debug_file (separate_filename
, separate_handle
);
11252 /* Note - separate_filename will be freed in free_debug_memory(). */
11253 return separate_handle
;
11257 load_debug_sup_file (const char * main_filename
, void * file
)
11259 if (! load_debug_section (debug_sup
, file
))
11260 return; /* No .debug_sup section. */
11262 struct dwarf_section
* section
;
11263 section
= & debug_displays
[debug_sup
].section
;
11264 assert (section
!= NULL
);
11266 if (section
->start
== NULL
|| section
->size
< 5)
11268 warn (_(".debug_sup section is corrupt/empty\n"));
11272 if (section
->start
[2] != 0)
11273 return; /* This is a supplementary file. */
11275 const char * filename
= (const char *) section
->start
+ 3;
11276 if (strnlen (filename
, section
->size
- 3) == section
->size
- 3)
11278 warn (_("filename in .debug_sup section is corrupt\n"));
11282 if (filename
[0] != '/' && strchr (main_filename
, '/'))
11287 new_len
= asprintf (& new_name
, "%.*s/%s",
11288 (int) (strrchr (main_filename
, '/') - main_filename
),
11293 warn (_("unable to construct path for supplementary debug file"));
11298 filename
= new_name
;
11302 /* PR 27796: Make sure that we pass a filename that can be free'd to
11303 add_separate_debug_file(). */
11304 filename
= strdup (filename
);
11305 if (filename
== NULL
)
11307 warn (_("out of memory constructing filename for .debug_sup link\n"));
11312 void * handle
= open_debug_file (filename
);
11313 if (handle
== NULL
)
11315 warn (_("unable to open file '%s' referenced from .debug_sup section\n"), filename
);
11316 free ((void *) filename
);
11320 printf (_("%s: Found supplementary debug file: %s\n\n"), main_filename
, filename
);
11322 /* FIXME: Compare the checksums, if present. */
11323 add_separate_debug_file (filename
, handle
);
11326 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11327 Recursively check the loaded files for more of these sections.
11328 Also follow any links in .debug_sup sections.
11329 FIXME: Should also check for DWO_* entries in the newly loaded files. */
11332 check_for_and_load_links (void * file
, const char * filename
)
11334 void * handle
= NULL
;
11336 if (load_debug_section (gnu_debugaltlink
, file
))
11338 Build_id_data build_id_data
;
11340 handle
= load_separate_debug_info (filename
,
11341 & debug_displays
[gnu_debugaltlink
].section
,
11342 parse_gnu_debugaltlink
,
11343 check_gnu_debugaltlink
,
11348 assert (handle
== first_separate_info
->handle
);
11349 check_for_and_load_links (first_separate_info
->handle
,
11350 first_separate_info
->filename
);
11354 if (load_debug_section (gnu_debuglink
, file
))
11356 unsigned long crc32
;
11358 handle
= load_separate_debug_info (filename
,
11359 & debug_displays
[gnu_debuglink
].section
,
11360 parse_gnu_debuglink
,
11361 check_gnu_debuglink
,
11366 assert (handle
== first_separate_info
->handle
);
11367 check_for_and_load_links (first_separate_info
->handle
,
11368 first_separate_info
->filename
);
11372 load_debug_sup_file (filename
, file
);
11375 /* Load the separate debug info file(s) attached to FILE, if any exist.
11376 Returns TRUE if any were found, FALSE otherwise.
11377 If TRUE is returned then the linked list starting at first_separate_info
11378 will be populated with open file handles. */
11381 load_separate_debug_files (void * file
, const char * filename
)
11383 /* Skip this operation if we are not interested in debug links. */
11384 if (! do_follow_links
&& ! do_debug_links
)
11387 /* See if there are any dwo links. */
11388 if (load_debug_section (str
, file
)
11389 && load_debug_section (abbrev
, file
)
11390 && load_debug_section (info
, file
))
11394 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
,
11397 bool introduced
= false;
11399 const char *dir
= NULL
;
11400 const char *id
= NULL
;
11401 const char *name
= NULL
;
11403 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11405 /* Accumulate NAME, DIR and ID fields. */
11406 switch (dwinfo
->type
)
11410 warn (_("Multiple DWO_NAMEs encountered for the same CU\n"));
11411 name
= dwinfo
->value
;
11415 /* There can be multiple DW_AT_comp_dir entries in a CU,
11416 so do not complain. */
11417 dir
= dwinfo
->value
;
11422 warn (_("multiple DWO_IDs encountered for the same CU\n"));
11423 id
= dwinfo
->value
;
11427 error (_("Unexpected DWO INFO type"));
11431 /* If we have reached the end of our list, or we are changing
11432 CUs, then display the information that we have accumulated
11435 && (dwinfo
->next
== NULL
11436 || dwinfo
->next
->cu_offset
!= dwinfo
->cu_offset
))
11438 if (do_debug_links
)
11442 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11443 debug_displays
[info
].section
.uncompressed_name
);
11447 printf (_(" Name: %s\n"), name
);
11448 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11450 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11452 printf (_(" ID: <not specified>\n"));
11456 if (do_follow_links
)
11457 load_dwo_file (filename
, name
, dir
, id
);
11459 name
= dir
= id
= NULL
;
11465 if (! do_follow_links
)
11466 /* The other debug links will be displayed by display_debug_links()
11467 so we do not need to do any further processing here. */
11470 /* FIXME: We do not check for the presence of both link sections in the same file. */
11471 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11472 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11474 check_for_and_load_links (file
, filename
);
11475 if (first_separate_info
!= NULL
)
11478 do_follow_links
= 0;
11483 free_debug_memory (void)
11487 free_all_abbrevs ();
11489 free (cu_abbrev_map
);
11490 cu_abbrev_map
= NULL
;
11491 next_free_abbrev_map_entry
= 0;
11495 shndx_pool_size
= 0;
11496 shndx_pool_used
= 0;
11504 memset (level_type_signed
, 0, sizeof level_type_signed
);
11505 cu_tu_indexes_read
= -1;
11507 for (i
= 0; i
< max
; i
++)
11508 free_debug_section ((enum dwarf_section_display_enum
) i
);
11510 if (debug_information
!= NULL
)
11512 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
11514 if (debug_information
[i
].max_loc_offsets
)
11516 free (debug_information
[i
].loc_offsets
);
11517 free (debug_information
[i
].have_frame_base
);
11519 if (debug_information
[i
].max_range_lists
)
11520 free (debug_information
[i
].range_lists
);
11522 free (debug_information
);
11523 debug_information
= NULL
;
11524 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
11528 separate_info
* next
;
11530 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
11532 close_debug_file (d
->handle
);
11533 free ((void *) d
->filename
);
11537 first_separate_info
= NULL
;
11543 dwarf_select_sections_by_names (const char *names
)
11547 const char * option
;
11551 debug_dump_long_opts
;
11553 static const debug_dump_long_opts opts_table
[] =
11555 /* Please keep this table alpha- sorted. */
11556 { "Ranges", & do_debug_ranges
, 1 },
11557 { "abbrev", & do_debug_abbrevs
, 1 },
11558 { "addr", & do_debug_addr
, 1 },
11559 { "aranges", & do_debug_aranges
, 1 },
11560 { "cu_index", & do_debug_cu_index
, 1 },
11561 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
11562 { "follow-links", & do_follow_links
, 1 },
11563 { "frames", & do_debug_frames
, 1 },
11564 { "frames-interp", & do_debug_frames_interp
, 1 },
11565 /* The special .gdb_index section. */
11566 { "gdb_index", & do_gdb_index
, 1 },
11567 { "info", & do_debug_info
, 1 },
11568 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
11569 { "links", & do_debug_links
, 1 },
11570 { "loc", & do_debug_loc
, 1 },
11571 { "macro", & do_debug_macinfo
, 1 },
11572 { "no-follow-links", & do_follow_links
, 0 },
11573 { "pubnames", & do_debug_pubnames
, 1 },
11574 { "pubtypes", & do_debug_pubtypes
, 1 },
11575 /* This entry is for compatibility
11576 with earlier versions of readelf. */
11577 { "ranges", & do_debug_aranges
, 1 },
11578 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
11579 { "str", & do_debug_str
, 1 },
11580 { "str-offsets", & do_debug_str_offsets
, 1 },
11581 /* These trace_* sections are used by Itanium VMS. */
11582 { "trace_abbrev", & do_trace_abbrevs
, 1 },
11583 { "trace_aranges", & do_trace_aranges
, 1 },
11584 { "trace_info", & do_trace_info
, 1 },
11593 const debug_dump_long_opts
* entry
;
11595 for (entry
= opts_table
; entry
->option
; entry
++)
11597 size_t len
= strlen (entry
->option
);
11599 if (strncmp (p
, entry
->option
, len
) == 0
11600 && (p
[len
] == ',' || p
[len
] == '\0'))
11602 * entry
->variable
= entry
->val
;
11604 /* The --debug-dump=frames-interp option also
11605 enables the --debug-dump=frames option. */
11606 if (do_debug_frames_interp
)
11607 do_debug_frames
= 1;
11614 if (entry
->option
== NULL
)
11616 warn (_("Unrecognized debug option '%s'\n"), p
);
11617 p
= strchr (p
, ',');
11628 dwarf_select_sections_by_letters (const char *letters
)
11630 unsigned int lindex
= 0;
11632 while (letters
[lindex
])
11633 switch (letters
[lindex
++])
11635 case 'A': do_debug_addr
= 1; break;
11636 case 'a': do_debug_abbrevs
= 1; break;
11637 case 'c': do_debug_cu_index
= 1; break;
11638 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
11639 case 'f': do_debug_frames
= 1; break;
11640 case 'g': do_gdb_index
= 1; break;
11641 case 'i': do_debug_info
= 1; break;
11642 case 'K': do_follow_links
= 1; break;
11643 case 'N': do_follow_links
= 0; break;
11644 case 'k': do_debug_links
= 1; break;
11645 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
11646 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
11647 case 'm': do_debug_macinfo
= 1; break;
11648 case 'O': do_debug_str_offsets
= 1; break;
11649 case 'o': do_debug_loc
= 1; break;
11650 case 'p': do_debug_pubnames
= 1; break;
11651 case 'R': do_debug_ranges
= 1; break;
11652 case 'r': do_debug_aranges
= 1; break;
11653 case 's': do_debug_str
= 1; break;
11654 case 'T': do_trace_aranges
= 1; break;
11655 case 't': do_debug_pubtypes
= 1; break;
11656 case 'U': do_trace_info
= 1; break;
11657 case 'u': do_trace_abbrevs
= 1; break;
11660 warn (_("Unrecognized debug option '%s'\n"), letters
);
11666 dwarf_select_sections_all (void)
11669 do_debug_abbrevs
= 1;
11670 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
11671 do_debug_pubnames
= 1;
11672 do_debug_pubtypes
= 1;
11673 do_debug_aranges
= 1;
11674 do_debug_ranges
= 1;
11675 do_debug_frames
= 1;
11676 do_debug_macinfo
= 1;
11681 do_trace_abbrevs
= 1;
11682 do_trace_aranges
= 1;
11684 do_debug_cu_index
= 1;
11685 do_follow_links
= 1;
11686 do_debug_links
= 1;
11687 do_debug_str_offsets
= 1;
11690 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0
11691 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0
11693 /* N.B. The order here must match the order in section_display_enum. */
11695 struct dwarf_section_display debug_displays
[] =
11697 { { ".debug_abbrev", ".zdebug_abbrev", ".dwabrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11698 { { ".debug_aranges", ".zdebug_aranges", ".dwarnge", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, true },
11699 { { ".debug_frame", ".zdebug_frame", ".dwframe", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11700 { { ".debug_info", ".zdebug_info", ".dwinfo", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, true },
11701 { { ".debug_line", ".zdebug_line", ".dwline", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11702 { { ".debug_pubnames", ".zdebug_pubnames", ".dwpbnms", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, false },
11703 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, false },
11704 { { ".eh_frame", "", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11705 { { ".debug_macinfo", ".zdebug_macinfo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11706 { { ".debug_macro", ".zdebug_macro", ".dwmac", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11707 { { ".debug_str", ".zdebug_str", ".dwstr", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11708 { { ".debug_line_str", ".zdebug_line_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11709 { { ".debug_loc", ".zdebug_loc", ".dwloc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11710 { { ".debug_loclists", ".zdebug_loclists", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11711 { { ".debug_pubtypes", ".zdebug_pubtypes", ".dwpbtyp", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, false },
11712 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, false },
11713 { { ".debug_ranges", ".zdebug_ranges", ".dwrnges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11714 { { ".debug_rnglists", ".zdebug_rnglists", "", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11715 { { ".debug_static_func", ".zdebug_static_func", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11716 { { ".debug_static_vars", ".zdebug_static_vars", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11717 { { ".debug_types", ".zdebug_types", "", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, true },
11718 { { ".debug_weaknames", ".zdebug_weaknames", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11719 { { ".gdb_index", "", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, false },
11720 { { ".debug_names", "", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, false },
11721 { { ".trace_info", "", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, true },
11722 { { ".trace_abbrev", "", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, false },
11723 { { ".trace_aranges", "", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, false },
11724 { { ".debug_info.dwo", ".zdebug_info.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, true },
11725 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", "", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11726 { { ".debug_types.dwo", ".zdebug_types.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, true },
11727 { { ".debug_line.dwo", ".zdebug_line.dwo", "", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11728 { { ".debug_loc.dwo", ".zdebug_loc.dwo", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11729 { { ".debug_macro.dwo", ".zdebug_macro.dwo", "", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11730 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11731 { { ".debug_str.dwo", ".zdebug_str.dwo", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, true },
11732 { { ".debug_str_offsets", ".zdebug_str_offsets", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11733 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11734 { { ".debug_addr", ".zdebug_addr", "", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, true },
11735 { { ".debug_cu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11736 { { ".debug_tu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11737 { { ".gnu_debuglink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11738 { { ".gnu_debugaltlink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11739 { { ".debug_sup", "", "", NO_ABBREVS
}, display_debug_sup
, &do_debug_links
, false },
11740 /* Separate debug info files can containt their own .debug_str section,
11741 and this might be in *addition* to a .debug_str section already present
11742 in the main file. Hence we need to have two entries for .debug_str. */
11743 { { ".debug_str", ".zdebug_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11746 /* A static assertion. */
11747 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];