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
);
2749 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2750 && num_debug_info_entries
== 0
2751 && debug_info_p
!= NULL
)
2755 case DW_AT_frame_base
:
2756 have_frame_base
= 1;
2758 case DW_AT_location
:
2759 case DW_AT_GNU_locviews
:
2760 case DW_AT_string_length
:
2761 case DW_AT_return_addr
:
2762 case DW_AT_data_member_location
:
2763 case DW_AT_vtable_elem_location
:
2765 case DW_AT_static_link
:
2766 case DW_AT_use_location
:
2767 case DW_AT_call_value
:
2768 case DW_AT_GNU_call_site_value
:
2769 case DW_AT_call_data_value
:
2770 case DW_AT_GNU_call_site_data_value
:
2771 case DW_AT_call_target
:
2772 case DW_AT_GNU_call_site_target
:
2773 case DW_AT_call_target_clobbered
:
2774 case DW_AT_GNU_call_site_target_clobbered
:
2775 if ((dwarf_version
< 4
2776 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2777 || form
== DW_FORM_sec_offset
)
2779 /* Process location list. */
2780 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2781 unsigned int num
= debug_info_p
->num_loc_offsets
;
2783 if (lmax
== 0 || num
>= lmax
)
2786 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2787 xcrealloc (debug_info_p
->loc_offsets
,
2788 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2789 debug_info_p
->loc_views
= (dwarf_vma
*)
2790 xcrealloc (debug_info_p
->loc_views
,
2791 lmax
, sizeof (*debug_info_p
->loc_views
));
2792 debug_info_p
->have_frame_base
= (int *)
2793 xcrealloc (debug_info_p
->have_frame_base
,
2794 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2795 debug_info_p
->max_loc_offsets
= lmax
;
2797 if (this_set
!= NULL
)
2798 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2799 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2800 if (attribute
!= DW_AT_GNU_locviews
)
2802 /* Corrupt DWARF info can produce more offsets than views.
2803 See PR 23062 for an example. */
2804 if (debug_info_p
->num_loc_offsets
2805 > debug_info_p
->num_loc_views
)
2806 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2809 debug_info_p
->loc_offsets
[num
] = uvalue
;
2810 debug_info_p
->num_loc_offsets
++;
2815 assert (debug_info_p
->num_loc_views
<= num
);
2816 num
= debug_info_p
->num_loc_views
;
2817 if (num
> debug_info_p
->num_loc_offsets
)
2818 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2821 debug_info_p
->loc_views
[num
] = uvalue
;
2822 debug_info_p
->num_loc_views
++;
2829 if (need_base_address
)
2830 debug_info_p
->base_address
= uvalue
;
2833 case DW_AT_GNU_addr_base
:
2834 case DW_AT_addr_base
:
2835 debug_info_p
->addr_base
= uvalue
;
2838 case DW_AT_GNU_ranges_base
:
2839 debug_info_p
->ranges_base
= uvalue
;
2843 if ((dwarf_version
< 4
2844 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2845 || form
== DW_FORM_sec_offset
)
2847 /* Process range list. */
2848 unsigned int lmax
= debug_info_p
->max_range_lists
;
2849 unsigned int num
= debug_info_p
->num_range_lists
;
2851 if (lmax
== 0 || num
>= lmax
)
2854 debug_info_p
->range_lists
= (dwarf_vma
*)
2855 xcrealloc (debug_info_p
->range_lists
,
2856 lmax
, sizeof (*debug_info_p
->range_lists
));
2857 debug_info_p
->max_range_lists
= lmax
;
2859 debug_info_p
->range_lists
[num
] = uvalue
;
2860 debug_info_p
->num_range_lists
++;
2864 case DW_AT_GNU_dwo_name
:
2865 case DW_AT_dwo_name
:
2870 add_dwo_name ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2872 case DW_FORM_GNU_strp_alt
:
2873 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
), cu_offset
);
2875 case DW_FORM_GNU_str_index
:
2881 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2883 case DW_FORM_string
:
2884 add_dwo_name ((const char *) orig_data
, cu_offset
);
2887 warn (_("Unsupported form (%s) for attribute %s\n"),
2888 get_FORM_name (form
), get_AT_name (attribute
));
2893 case DW_AT_comp_dir
:
2894 /* FIXME: Also extract a build-id in a CU/TU. */
2899 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
), cu_offset
);
2901 case DW_FORM_GNU_strp_alt
:
2902 add_dwo_dir (fetch_alt_indirect_string (uvalue
), cu_offset
);
2904 case DW_FORM_line_strp
:
2905 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
), cu_offset
);
2907 case DW_FORM_GNU_str_index
:
2913 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, false), cu_offset
);
2915 case DW_FORM_string
:
2916 add_dwo_dir ((const char *) orig_data
, cu_offset
);
2919 warn (_("Unsupported form (%s) for attribute %s\n"),
2920 get_FORM_name (form
), get_AT_name (attribute
));
2925 case DW_AT_GNU_dwo_id
:
2930 /* FIXME: Record the length of the ID as well ? */
2931 add_dwo_id ((const char *) (data
- 8), cu_offset
);
2934 warn (_("Unsupported form (%s) for attribute %s\n"),
2935 get_FORM_name (form
), get_AT_name (attribute
));
2945 if (do_loc
|| attribute
== 0)
2948 /* For some attributes we can display further information. */
2952 if (level
>= 0 && level
< MAX_CU_NESTING
2953 && uvalue
< (size_t) (end
- start
))
2955 bool is_signed
= false;
2956 abbrev_entry
*type_abbrev
;
2957 unsigned char *type_data
;
2960 type_abbrev
= get_type_abbrev_from_form (form
, uvalue
,
2964 if (type_abbrev
!= NULL
)
2966 get_type_signedness (type_abbrev
, section
, type_data
,
2967 map
? section
->start
+ map
->end
: end
,
2968 map
? map
->start
: cu_offset
,
2969 pointer_size
, offset_size
, dwarf_version
,
2972 level_type_signed
[level
] = is_signed
;
2980 case DW_INL_not_inlined
:
2981 printf (_("(not inlined)"));
2983 case DW_INL_inlined
:
2984 printf (_("(inlined)"));
2986 case DW_INL_declared_not_inlined
:
2987 printf (_("(declared as inline but ignored)"));
2989 case DW_INL_declared_inlined
:
2990 printf (_("(declared as inline and inlined)"));
2993 printf (_(" (Unknown inline attribute value: %s)"),
2994 dwarf_vmatoa ("x", uvalue
));
2999 case DW_AT_language
:
3003 /* Ordered by the numeric value of these constants. */
3004 case DW_LANG_C89
: printf ("(ANSI C)"); break;
3005 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
3006 case DW_LANG_Ada83
: printf ("(Ada)"); break;
3007 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
3008 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
3009 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
3010 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
3011 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
3012 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
3013 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
3014 /* DWARF 2.1 values. */
3015 case DW_LANG_Java
: printf ("(Java)"); break;
3016 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
3017 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
3018 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
3019 /* DWARF 3 values. */
3020 case DW_LANG_PLI
: printf ("(PLI)"); break;
3021 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
3022 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
3023 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
3024 case DW_LANG_D
: printf ("(D)"); break;
3025 /* DWARF 4 values. */
3026 case DW_LANG_Python
: printf ("(Python)"); break;
3027 /* DWARF 5 values. */
3028 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
3029 case DW_LANG_Go
: printf ("(Go)"); break;
3030 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
3031 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
3032 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
3033 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
3034 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
3035 case DW_LANG_Rust
: printf ("(Rust)"); break;
3036 case DW_LANG_C11
: printf ("(C11)"); break;
3037 case DW_LANG_Swift
: printf ("(Swift)"); break;
3038 case DW_LANG_Julia
: printf ("(Julia)"); break;
3039 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
3040 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
3041 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
3042 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
3043 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
3044 /* MIPS extension. */
3045 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
3046 /* UPC extension. */
3047 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
3049 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
3050 printf (_("(implementation defined: %s)"),
3051 dwarf_vmatoa ("x", uvalue
));
3053 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
3058 case DW_AT_encoding
:
3062 case DW_ATE_void
: printf ("(void)"); break;
3063 case DW_ATE_address
: printf ("(machine address)"); break;
3064 case DW_ATE_boolean
: printf ("(boolean)"); break;
3065 case DW_ATE_complex_float
: printf ("(complex float)"); break;
3066 case DW_ATE_float
: printf ("(float)"); break;
3067 case DW_ATE_signed
: printf ("(signed)"); break;
3068 case DW_ATE_signed_char
: printf ("(signed char)"); break;
3069 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
3070 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
3071 /* DWARF 2.1 values: */
3072 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
3073 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
3074 /* DWARF 3 values: */
3075 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
3076 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
3077 case DW_ATE_edited
: printf ("(edited)"); break;
3078 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
3079 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
3080 /* DWARF 4 values: */
3081 case DW_ATE_UTF
: printf ("(unicode string)"); break;
3082 /* DWARF 5 values: */
3083 case DW_ATE_UCS
: printf ("(UCS)"); break;
3084 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
3086 /* HP extensions: */
3087 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
3088 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
3089 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
3090 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
3091 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
3092 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
3093 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
3096 if (uvalue
>= DW_ATE_lo_user
3097 && uvalue
<= DW_ATE_hi_user
)
3098 printf (_("(user defined type)"));
3100 printf (_("(unknown type)"));
3105 case DW_AT_accessibility
:
3109 case DW_ACCESS_public
: printf ("(public)"); break;
3110 case DW_ACCESS_protected
: printf ("(protected)"); break;
3111 case DW_ACCESS_private
: printf ("(private)"); break;
3113 printf (_("(unknown accessibility)"));
3118 case DW_AT_visibility
:
3122 case DW_VIS_local
: printf ("(local)"); break;
3123 case DW_VIS_exported
: printf ("(exported)"); break;
3124 case DW_VIS_qualified
: printf ("(qualified)"); break;
3125 default: printf (_("(unknown visibility)")); break;
3129 case DW_AT_endianity
:
3133 case DW_END_default
: printf ("(default)"); break;
3134 case DW_END_big
: printf ("(big)"); break;
3135 case DW_END_little
: printf ("(little)"); break;
3137 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
3138 printf (_("(user specified)"));
3140 printf (_("(unknown endianity)"));
3145 case DW_AT_virtuality
:
3149 case DW_VIRTUALITY_none
: printf ("(none)"); break;
3150 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
3151 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
3152 default: printf (_("(unknown virtuality)")); break;
3156 case DW_AT_identifier_case
:
3160 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
3161 case DW_ID_up_case
: printf ("(up_case)"); break;
3162 case DW_ID_down_case
: printf ("(down_case)"); break;
3163 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
3164 default: printf (_("(unknown case)")); break;
3168 case DW_AT_calling_convention
:
3172 case DW_CC_normal
: printf ("(normal)"); break;
3173 case DW_CC_program
: printf ("(program)"); break;
3174 case DW_CC_nocall
: printf ("(nocall)"); break;
3175 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
3176 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
3177 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
3178 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
3180 if (uvalue
>= DW_CC_lo_user
3181 && uvalue
<= DW_CC_hi_user
)
3182 printf (_("(user defined)"));
3184 printf (_("(unknown convention)"));
3188 case DW_AT_ordering
:
3193 case -1: printf (_("(undefined)")); break;
3194 case 0: printf ("(row major)"); break;
3195 case 1: printf ("(column major)"); break;
3199 case DW_AT_decimal_sign
:
3203 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
3204 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
3205 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
3206 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
3207 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
3208 default: printf (_("(unrecognised)")); break;
3212 case DW_AT_defaulted
:
3216 case DW_DEFAULTED_no
: printf (_("(no)")); break;
3217 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
3218 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
3219 default: printf (_("(unrecognised)")); break;
3223 case DW_AT_discr_list
:
3225 display_discr_list (form
, uvalue
, data
, level
);
3228 case DW_AT_frame_base
:
3229 have_frame_base
= 1;
3231 case DW_AT_location
:
3232 case DW_AT_string_length
:
3233 case DW_AT_return_addr
:
3234 case DW_AT_data_member_location
:
3235 case DW_AT_vtable_elem_location
:
3237 case DW_AT_static_link
:
3238 case DW_AT_use_location
:
3239 case DW_AT_call_value
:
3240 case DW_AT_GNU_call_site_value
:
3241 case DW_AT_call_data_value
:
3242 case DW_AT_GNU_call_site_data_value
:
3243 case DW_AT_call_target
:
3244 case DW_AT_GNU_call_site_target
:
3245 case DW_AT_call_target_clobbered
:
3246 case DW_AT_GNU_call_site_target_clobbered
:
3247 if ((dwarf_version
< 4
3248 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3249 || form
== DW_FORM_sec_offset
)
3250 printf (_(" (location list)"));
3252 case DW_AT_allocated
:
3253 case DW_AT_associated
:
3254 case DW_AT_data_location
:
3256 case DW_AT_upper_bound
:
3257 case DW_AT_lower_bound
:
3260 int need_frame_base
;
3263 need_frame_base
= decode_location_expression (block_start
,
3268 cu_offset
, section
);
3270 if (need_frame_base
&& !have_frame_base
)
3271 printf (_(" [without DW_AT_frame_base]"));
3275 case DW_AT_data_bit_offset
:
3276 case DW_AT_byte_size
:
3277 case DW_AT_bit_size
:
3278 case DW_AT_string_length_byte_size
:
3279 case DW_AT_string_length_bit_size
:
3280 case DW_AT_bit_stride
:
3281 if (form
== DW_FORM_exprloc
)
3284 (void) decode_location_expression (block_start
, pointer_size
,
3285 offset_size
, dwarf_version
,
3286 uvalue
, cu_offset
, section
);
3293 unsigned long abbrev_number
;
3294 abbrev_entry
*entry
;
3296 entry
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
, end
,
3297 section
, & abbrev_number
, NULL
, NULL
);
3300 if (form
!= DW_FORM_GNU_ref_alt
)
3301 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
3302 dwarf_vmatoa ("x", uvalue
),
3303 (unsigned long) (orig_data
- section
->start
));
3307 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3308 printf (" (%s)", get_TAG_name (entry
->tag
));
3321 static unsigned char *
3322 read_and_display_attr (unsigned long attribute
,
3324 dwarf_signed_vma implicit_const
,
3325 unsigned char * start
,
3326 unsigned char * data
,
3327 unsigned char * end
,
3328 dwarf_vma cu_offset
,
3329 dwarf_vma pointer_size
,
3330 dwarf_vma offset_size
,
3332 debug_info
* debug_info_p
,
3334 struct dwarf_section
* section
,
3335 struct cu_tu_set
* this_set
,
3339 printf (" %-18s:", get_AT_name (attribute
));
3340 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3342 cu_offset
, pointer_size
, offset_size
,
3343 dwarf_version
, debug_info_p
,
3344 do_loc
, section
, this_set
, ' ', level
);
3350 /* Like load_debug_section, but if the ordinary call fails, and we are
3351 following debug links, then attempt to load the requested section
3352 from one of the separate debug info files. */
3355 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3358 if (load_debug_section (sec_enum
, handle
))
3360 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3362 /* See if we can associate a filename with this section. */
3365 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3366 if (i
->handle
== handle
)
3368 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3376 if (do_follow_links
)
3380 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3382 if (load_debug_section (sec_enum
, i
->handle
))
3384 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3386 /* FIXME: We should check to see if any of the remaining debug info
3387 files also contain this section, and, umm, do something about it. */
3397 introduce (struct dwarf_section
* section
, bool raw
)
3401 if (do_follow_links
&& section
->filename
)
3402 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3403 section
->name
, section
->filename
);
3405 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3409 if (do_follow_links
&& section
->filename
)
3410 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3411 section
->name
, section
->filename
);
3413 printf (_("Contents of the %s section:\n\n"), section
->name
);
3417 /* Process the contents of a .debug_info section.
3418 If do_loc is TRUE then we are scanning for location lists and dwo tags
3419 and we do not want to display anything to the user.
3420 If do_types is TRUE, we are processing a .debug_types section instead of
3421 a .debug_info section.
3422 The information displayed is restricted by the values in DWARF_START_DIE
3423 and DWARF_CUTOFF_LEVEL.
3424 Returns TRUE upon success. Otherwise an error or warning message is
3425 printed and FALSE is returned. */
3428 process_debug_info (struct dwarf_section
* section
,
3430 enum dwarf_section_display_enum abbrev_sec
,
3434 unsigned char *start
= section
->start
;
3435 unsigned char *end
= start
+ section
->size
;
3436 unsigned char *section_begin
;
3438 unsigned int num_units
= 0;
3440 /* First scan the section to get the number of comp units.
3441 Length sanity checks are done here. */
3442 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3447 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3448 will be the length. For a 64-bit DWARF section, it'll be
3449 the escape code 0xffffffff followed by an 8 byte length. */
3450 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 4, end
);
3452 if (length
== 0xffffffff)
3453 SAFE_BYTE_GET_AND_INC (length
, section_begin
, 8, end
);
3454 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3456 warn (_("Reserved length value (0x%s) found in section %s\n"),
3457 dwarf_vmatoa ("x", length
), section
->name
);
3461 /* Negative values are illegal, they may even cause infinite
3462 looping. This can happen if we can't accurately apply
3463 relocations to an object file, or if the file is corrupt. */
3464 if (length
> (size_t) (end
- section_begin
))
3466 warn (_("Corrupt unit length (got 0x%s expected at most 0x%s) in section %s\n"),
3467 dwarf_vmatoa ("x", length
),
3468 dwarf_vmatoa ("x", end
- section_begin
),
3472 section_begin
+= length
;
3477 error (_("No comp units in %s section ?\n"), section
->name
);
3481 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3482 && num_debug_info_entries
== 0
3486 /* Then allocate an array to hold the information. */
3487 debug_information
= (debug_info
*) cmalloc (num_units
,
3488 sizeof (* debug_information
));
3489 if (debug_information
== NULL
)
3491 error (_("Not enough memory for a debug info array of %u entries\n"),
3493 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3497 /* PR 17531: file: 92ca3797.
3498 We cannot rely upon the debug_information array being initialised
3499 before it is used. A corrupt file could easily contain references
3500 to a unit for which information has not been made available. So
3501 we ensure that the array is zeroed here. */
3502 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3504 alloc_num_debug_info_entries
= num_units
;
3509 load_debug_section_with_follow (str
, file
);
3510 load_debug_section_with_follow (line_str
, file
);
3511 load_debug_section_with_follow (str_dwo
, file
);
3512 load_debug_section_with_follow (str_index
, file
);
3513 load_debug_section_with_follow (str_index_dwo
, file
);
3514 load_debug_section_with_follow (debug_addr
, file
);
3517 load_debug_section_with_follow (abbrev_sec
, file
);
3518 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3520 warn (_("Unable to locate %s section!\n"),
3521 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3525 if (!do_loc
&& dwarf_start_die
== 0)
3526 introduce (section
, false);
3528 free_all_abbrevs ();
3529 free (cu_abbrev_map
);
3530 cu_abbrev_map
= NULL
;
3531 next_free_abbrev_map_entry
= 0;
3533 /* In order to be able to resolve DW_FORM_ref_attr forms we need
3534 to load *all* of the abbrevs for all CUs in this .debug_info
3535 section. This does effectively mean that we (partially) read
3536 every CU header twice. */
3537 for (section_begin
= start
; start
< end
;)
3539 DWARF2_Internal_CompUnit compunit
;
3540 unsigned char * hdrptr
;
3541 dwarf_vma abbrev_base
;
3543 dwarf_vma cu_offset
;
3544 unsigned int offset_size
;
3545 struct cu_tu_set
* this_set
;
3547 unsigned char *end_cu
;
3550 cu_offset
= start
- section_begin
;
3552 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3554 if (compunit
.cu_length
== 0xffffffff)
3556 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3561 end_cu
= hdrptr
+ compunit
.cu_length
;
3563 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3565 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3567 if (compunit
.cu_version
< 5)
3569 compunit
.cu_unit_type
= DW_UT_compile
;
3570 /* Initialize it due to a false compiler warning. */
3571 compunit
.cu_pointer_size
= -1;
3575 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3576 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3578 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3581 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
,
3584 if (compunit
.cu_unit_type
== DW_UT_split_compile
3585 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3588 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3591 if (this_set
== NULL
)
3594 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3598 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3599 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3602 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3603 compunit
.cu_abbrev_offset
);
3606 unsigned char * next
;
3608 list
= new_abbrev_list (abbrev_base
,
3609 compunit
.cu_abbrev_offset
);
3610 next
= process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3611 abbrev_base
, abbrev_size
,
3612 compunit
.cu_abbrev_offset
, list
);
3613 list
->start_of_next_abbrevs
= next
;
3617 record_abbrev_list_for_cu (cu_offset
, start
- section_begin
, list
);
3620 for (start
= section_begin
, unit
= 0; start
< end
; unit
++)
3622 DWARF2_Internal_CompUnit compunit
;
3623 unsigned char *hdrptr
;
3624 unsigned char *tags
;
3625 int level
, last_level
, saved_level
;
3626 dwarf_vma cu_offset
;
3627 unsigned int offset_size
;
3628 dwarf_vma signature
= 0;
3629 dwarf_vma type_offset
= 0;
3630 struct cu_tu_set
*this_set
;
3631 dwarf_vma abbrev_base
;
3633 abbrev_list
* list
= NULL
;
3634 unsigned char *end_cu
;
3637 cu_offset
= start
- section_begin
;
3639 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3641 if (compunit
.cu_length
== 0xffffffff)
3643 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3648 end_cu
= hdrptr
+ compunit
.cu_length
;
3650 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end_cu
);
3652 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3654 if (compunit
.cu_version
< 5)
3656 compunit
.cu_unit_type
= DW_UT_compile
;
3657 /* Initialize it due to a false compiler warning. */
3658 compunit
.cu_pointer_size
= -1;
3662 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end_cu
);
3663 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3665 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3668 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end_cu
);
3670 if (this_set
== NULL
)
3673 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3677 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3678 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3681 if (compunit
.cu_version
< 5)
3682 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end_cu
);
3684 bool do_dwo_id
= false;
3685 uint64_t dwo_id
= 0;
3686 if (compunit
.cu_unit_type
== DW_UT_split_compile
3687 || compunit
.cu_unit_type
== DW_UT_skeleton
)
3689 SAFE_BYTE_GET_AND_INC (dwo_id
, hdrptr
, 8, end_cu
);
3693 /* PR 17512: file: 001-108546-0.001:0.1. */
3694 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3696 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3697 compunit
.cu_pointer_size
, offset_size
);
3698 compunit
.cu_pointer_size
= offset_size
;
3703 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, end_cu
);
3704 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end_cu
);
3707 if (dwarf_start_die
>= (size_t) (end_cu
- section_begin
))
3713 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3714 && num_debug_info_entries
== 0
3715 && alloc_num_debug_info_entries
> unit
3718 debug_information
[unit
].cu_offset
= cu_offset
;
3719 debug_information
[unit
].pointer_size
3720 = compunit
.cu_pointer_size
;
3721 debug_information
[unit
].offset_size
= offset_size
;
3722 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3723 debug_information
[unit
].base_address
= 0;
3724 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3725 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3726 debug_information
[unit
].loc_offsets
= NULL
;
3727 debug_information
[unit
].have_frame_base
= NULL
;
3728 debug_information
[unit
].max_loc_offsets
= 0;
3729 debug_information
[unit
].num_loc_offsets
= 0;
3730 debug_information
[unit
].range_lists
= NULL
;
3731 debug_information
[unit
].max_range_lists
= 0;
3732 debug_information
[unit
].num_range_lists
= 0;
3735 if (!do_loc
&& dwarf_start_die
== 0)
3737 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3738 dwarf_vmatoa ("x", cu_offset
));
3739 printf (_(" Length: 0x%s (%s)\n"),
3740 dwarf_vmatoa ("x", compunit
.cu_length
),
3741 offset_size
== 8 ? "64-bit" : "32-bit");
3742 printf (_(" Version: %d\n"), compunit
.cu_version
);
3743 if (compunit
.cu_version
>= 5)
3745 const char *name
= get_DW_UT_name (compunit
.cu_unit_type
);
3747 printf (_(" Unit Type: %s (%x)\n"),
3748 name
? name
: "???",
3749 compunit
.cu_unit_type
);
3751 printf (_(" Abbrev Offset: 0x%s\n"),
3752 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3753 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3756 printf (_(" Signature: 0x%s\n"),
3757 dwarf_vmatoa ("x", signature
));
3758 printf (_(" Type Offset: 0x%s\n"),
3759 dwarf_vmatoa ("x", type_offset
));
3762 printf (_(" DWO ID: 0x%s\n"), dwarf_vmatoa ("x", dwo_id
));
3763 if (this_set
!= NULL
)
3765 dwarf_vma
*offsets
= this_set
->section_offsets
;
3766 size_t *sizes
= this_set
->section_sizes
;
3768 printf (_(" Section contributions:\n"));
3769 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3770 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3771 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3772 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3773 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3774 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3775 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3776 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3777 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3778 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3779 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3780 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3787 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3789 warn (_("CU at offset %s contains corrupt or "
3790 "unsupported version number: %d.\n"),
3791 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3795 if (compunit
.cu_unit_type
!= DW_UT_compile
3796 && compunit
.cu_unit_type
!= DW_UT_partial
3797 && compunit
.cu_unit_type
!= DW_UT_type
3798 && compunit
.cu_unit_type
!= DW_UT_split_compile
3799 && compunit
.cu_unit_type
!= DW_UT_skeleton
)
3801 warn (_("CU at offset %s contains corrupt or "
3802 "unsupported unit type: %d.\n"),
3803 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3807 /* Process the abbrevs used by this compilation unit. */
3808 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3809 compunit
.cu_abbrev_offset
);
3812 unsigned char *next
;
3814 list
= new_abbrev_list (abbrev_base
,
3815 compunit
.cu_abbrev_offset
);
3816 next
= process_abbrev_set (&debug_displays
[abbrev_sec
].section
,
3817 abbrev_base
, abbrev_size
,
3818 compunit
.cu_abbrev_offset
, list
);
3819 list
->start_of_next_abbrevs
= next
;
3825 while (tags
< start
)
3827 unsigned long abbrev_number
;
3828 unsigned long die_offset
;
3829 abbrev_entry
*entry
;
3831 int do_printing
= 1;
3833 die_offset
= tags
- section_begin
;
3835 READ_ULEB (abbrev_number
, tags
, start
);
3837 /* A null DIE marks the end of a list of siblings or it may also be
3838 a section padding. */
3839 if (abbrev_number
== 0)
3841 /* Check if it can be a section padding for the last CU. */
3842 if (level
== 0 && start
== end
)
3846 for (chk
= tags
; chk
< start
; chk
++)
3853 if (!do_loc
&& die_offset
>= dwarf_start_die
3854 && (dwarf_cutoff_level
== -1
3855 || level
< dwarf_cutoff_level
))
3856 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3862 static unsigned num_bogus_warns
= 0;
3864 if (num_bogus_warns
< 3)
3866 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3867 die_offset
, section
->name
);
3869 if (num_bogus_warns
== 3)
3870 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3873 if (dwarf_start_die
!= 0 && level
< saved_level
)
3880 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3884 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3885 saved_level
= level
;
3886 do_printing
= (dwarf_cutoff_level
== -1
3887 || level
< dwarf_cutoff_level
);
3889 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3890 level
, die_offset
, abbrev_number
);
3891 else if (dwarf_cutoff_level
== -1
3892 || last_level
< dwarf_cutoff_level
)
3893 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3898 /* Scan through the abbreviation list until we reach the
3903 for (entry
= list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
3904 if (entry
->number
== abbrev_number
)
3909 if (!do_loc
&& do_printing
)
3914 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3915 die_offset
, abbrev_number
);
3919 if (!do_loc
&& do_printing
)
3920 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3925 need_base_address
= 0;
3927 case DW_TAG_compile_unit
:
3928 need_base_address
= 1;
3929 need_dwo_info
= do_loc
;
3931 case DW_TAG_entry_point
:
3932 case DW_TAG_subprogram
:
3933 need_base_address
= 0;
3934 /* Assuming that there is no DW_AT_frame_base. */
3935 have_frame_base
= 0;
3939 debug_info
*debug_info_p
=
3940 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3941 ? debug_information
+ unit
: NULL
;
3943 assert (!debug_info_p
3944 || (debug_info_p
->num_loc_offsets
3945 == debug_info_p
->num_loc_views
));
3947 for (attr
= entry
->first_attr
;
3948 attr
&& attr
->attribute
;
3951 if (! do_loc
&& do_printing
)
3952 /* Show the offset from where the tag was extracted. */
3953 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3954 tags
= read_and_display_attr (attr
->attribute
,
3956 attr
->implicit_const
,
3961 compunit
.cu_pointer_size
,
3963 compunit
.cu_version
,
3965 do_loc
|| ! do_printing
,
3971 /* If a locview attribute appears before a location one,
3972 make sure we don't associate it with an earlier
3975 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3978 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3979 debug_info_p
->num_loc_views
++;
3980 assert (debug_info_p
->num_loc_views
3981 == debug_info_p
->num_loc_offsets
);
3988 warn(_("DIE has locviews without loclist\n"));
3989 debug_info_p
->num_loc_views
--;
3996 if (entry
->children
)
4001 /* Set num_debug_info_entries here so that it can be used to check if
4002 we need to process .debug_loc and .debug_ranges sections. */
4003 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
4004 && num_debug_info_entries
== 0
4007 if (num_units
> alloc_num_debug_info_entries
)
4008 num_debug_info_entries
= alloc_num_debug_info_entries
;
4010 num_debug_info_entries
= num_units
;
4019 /* Locate and scan the .debug_info section in the file and record the pointer
4020 sizes and offsets for the compilation units in it. Usually an executable
4021 will have just one pointer size, but this is not guaranteed, and so we try
4022 not to make any assumptions. Returns zero upon failure, or the number of
4023 compilation units upon success. */
4026 load_debug_info (void * file
)
4028 /* If we have already tried and failed to load the .debug_info
4029 section then do not bother to repeat the task. */
4030 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4033 /* If we already have the information there is nothing else to do. */
4034 if (num_debug_info_entries
> 0)
4035 return num_debug_info_entries
;
4037 /* If this is a DWARF package file, load the CU and TU indexes. */
4038 (void) load_cu_tu_indexes (file
);
4040 if (load_debug_section_with_follow (info
, file
)
4041 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, true, false))
4042 return num_debug_info_entries
;
4044 if (load_debug_section_with_follow (info_dwo
, file
)
4045 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
4046 abbrev_dwo
, true, false))
4047 return num_debug_info_entries
;
4049 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
4053 /* Read a DWARF .debug_line section header starting at DATA.
4054 Upon success returns an updated DATA pointer and the LINFO
4055 structure and the END_OF_SEQUENCE pointer will be filled in.
4056 Otherwise returns NULL. */
4058 static unsigned char *
4059 read_debug_line_header (struct dwarf_section
* section
,
4060 unsigned char * data
,
4061 unsigned char * end
,
4062 DWARF2_Internal_LineInfo
* linfo
,
4063 unsigned char ** end_of_sequence
)
4065 unsigned char *hdrptr
;
4067 /* Extract information from the Line Number Program Header.
4068 (section 6.2.4 in the Dwarf3 doc). */
4071 /* Get and check the length of the block. */
4072 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
4074 if (linfo
->li_length
== 0xffffffff)
4076 /* This section is 64-bit DWARF 3. */
4077 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
4078 linfo
->li_offset_size
= 8;
4081 linfo
->li_offset_size
= 4;
4083 if (linfo
->li_length
> (size_t) (end
- hdrptr
))
4085 /* If the length field has a relocation against it, then we should
4086 not complain if it is inaccurate (and probably negative). This
4087 happens in object files when the .debug_line section is actually
4088 comprised of several different .debug_line.* sections, (some of
4089 which may be removed by linker garbage collection), and a relocation
4090 is used to compute the correct length once that is done. */
4091 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
4093 linfo
->li_length
= end
- hdrptr
;
4097 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
4098 (long) linfo
->li_length
);
4102 end
= hdrptr
+ linfo
->li_length
;
4104 /* Get and check the version number. */
4105 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
4107 if (linfo
->li_version
!= 2
4108 && linfo
->li_version
!= 3
4109 && linfo
->li_version
!= 4
4110 && linfo
->li_version
!= 5)
4112 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
4113 "is currently supported.\n"));
4117 if (linfo
->li_version
>= 5)
4119 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
4121 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
4122 if (linfo
->li_segment_size
!= 0)
4124 warn (_("The %s section contains "
4125 "unsupported segment selector size: %d.\n"),
4126 section
->name
, linfo
->li_segment_size
);
4131 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
4132 linfo
->li_offset_size
, end
);
4133 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
4135 if (linfo
->li_version
>= 4)
4137 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
4139 if (linfo
->li_max_ops_per_insn
== 0)
4141 warn (_("Invalid maximum operations per insn.\n"));
4146 linfo
->li_max_ops_per_insn
= 1;
4148 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
4149 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
4150 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
4151 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
4153 *end_of_sequence
= end
;
4157 static unsigned char *
4158 display_formatted_table (unsigned char *data
,
4159 unsigned char *start
,
4161 const DWARF2_Internal_LineInfo
*linfo
,
4162 struct dwarf_section
*section
,
4165 unsigned char *format_start
, format_count
, *format
, formati
;
4166 dwarf_vma data_count
, datai
;
4167 unsigned int namepass
, last_entry
= 0;
4168 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
4170 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4171 if (do_checks
&& format_count
> 5)
4172 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
4173 table_name
, format_count
);
4175 format_start
= data
;
4176 for (formati
= 0; formati
< format_count
; formati
++)
4178 SKIP_ULEB (data
, end
);
4179 SKIP_ULEB (data
, end
);
4182 warn (_("%s: Corrupt format description entry\n"), table_name
);
4187 READ_ULEB (data_count
, data
, end
);
4188 if (data_count
== 0)
4190 printf (_("\n The %s is empty.\n"), table_name
);
4193 else if (data
>= end
)
4195 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
4196 table_name
, dwarf_vmatoa ("x", data_count
));
4200 else if (format_count
== 0)
4202 warn (_("%s: format count is zero, but the table is not empty\n"),
4207 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
4208 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
4211 printf (_(" Entry"));
4212 /* Delay displaying name as the last entry for better screen layout. */
4213 for (namepass
= 0; namepass
< 2; namepass
++)
4215 format
= format_start
;
4216 for (formati
= 0; formati
< format_count
; formati
++)
4218 dwarf_vma content_type
;
4220 READ_ULEB (content_type
, format
, end
);
4221 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
4222 switch (content_type
)
4225 printf (_("\tName"));
4227 case DW_LNCT_directory_index
:
4228 printf (_("\tDir"));
4230 case DW_LNCT_timestamp
:
4231 printf (_("\tTime"));
4234 printf (_("\tSize"));
4237 printf (_("\tMD5\t\t\t"));
4240 printf (_("\t(Unknown format content type %s)"),
4241 dwarf_vmatoa ("u", content_type
));
4243 SKIP_ULEB (format
, end
);
4248 for (datai
= 0; datai
< data_count
; datai
++)
4250 unsigned char *datapass
= data
;
4252 printf (" %d", last_entry
++);
4253 /* Delay displaying name as the last entry for better screen layout. */
4254 for (namepass
= 0; namepass
< 2; namepass
++)
4256 format
= format_start
;
4258 for (formati
= 0; formati
< format_count
; formati
++)
4260 dwarf_vma content_type
, form
;
4262 READ_ULEB (content_type
, format
, end
);
4263 READ_ULEB (form
, format
, end
);
4264 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4265 0, 0, linfo
->li_offset_size
,
4266 linfo
->li_version
, NULL
,
4267 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
4268 section
, NULL
, '\t', -1);
4272 if (data
>= end
&& (datai
< data_count
- 1))
4274 warn (_("\n%s: Corrupt entries list\n"), table_name
);
4283 display_debug_sup (struct dwarf_section
* section
,
4284 void * file ATTRIBUTE_UNUSED
)
4286 unsigned char * start
= section
->start
;
4287 unsigned char * end
= section
->start
+ section
->size
;
4288 unsigned int version
;
4289 char is_supplementary
;
4290 const unsigned char * sup_filename
;
4291 size_t sup_filename_len
;
4292 unsigned int num_read
;
4294 dwarf_vma checksum_len
;
4297 introduce (section
, true);
4298 if (section
->size
< 4)
4300 error (_("corrupt .debug_sup section: size is too small\n"));
4304 /* Read the data. */
4305 SAFE_BYTE_GET_AND_INC (version
, start
, 2, end
);
4307 warn (_("corrupt .debug_sup section: version < 5"));
4309 SAFE_BYTE_GET_AND_INC (is_supplementary
, start
, 1, end
);
4310 if (is_supplementary
!= 0 && is_supplementary
!= 1)
4311 warn (_("corrupt .debug_sup section: is_supplementary not 0 or 1\n"));
4313 sup_filename
= start
;
4314 if (is_supplementary
&& sup_filename
[0] != 0)
4315 warn (_("corrupt .debug_sup section: filename not empty in supplementary section\n"));
4317 sup_filename_len
= strnlen ((const char *) start
, end
- start
);
4318 if (sup_filename_len
== (size_t) (end
- start
))
4320 error (_("corrupt .debug_sup section: filename is not NUL terminated\n"));
4323 start
+= sup_filename_len
+ 1;
4325 checksum_len
= read_leb128 (start
, end
, false /* unsigned */, & num_read
, & status
);
4328 error (_("corrupt .debug_sup section: bad LEB128 field for checksum length\n"));
4332 if (checksum_len
> (dwarf_vma
) (end
- start
))
4334 error (_("corrupt .debug_sup section: checksum length is longer than the remaining section length\n"));
4335 checksum_len
= end
- start
;
4337 else if (checksum_len
< (dwarf_vma
) (end
- start
))
4339 warn (_("corrupt .debug_sup section: there are 0x%lx extra, unused bytes at the end of the section\n"),
4340 (long) ((end
- start
) - checksum_len
));
4343 printf (_(" Version: %u\n"), version
);
4344 printf (_(" Is Supp: %u\n"), is_supplementary
);
4345 printf (_(" Filename: %s\n"), sup_filename
);
4346 printf (_(" Checksum Len: %lu\n"), (long) checksum_len
);
4347 if (checksum_len
> 0)
4349 printf (_(" Checksum: "));
4350 while (checksum_len
--)
4351 printf ("0x%x ", * start
++ );
4358 display_debug_lines_raw (struct dwarf_section
* section
,
4359 unsigned char * data
,
4360 unsigned char * end
,
4363 unsigned char *start
= section
->start
;
4364 int verbose_view
= 0;
4366 introduce (section
, true);
4370 static DWARF2_Internal_LineInfo saved_linfo
;
4371 DWARF2_Internal_LineInfo linfo
;
4372 unsigned char *standard_opcodes
;
4373 unsigned char *end_of_sequence
;
4376 if (startswith (section
->name
, ".debug_line.")
4377 /* Note: the following does not apply to .debug_line.dwo sections.
4378 These are full debug_line sections. */
4379 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4381 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4382 section containing just the Line Number Statements. They are
4383 created by the assembler and intended to be used alongside gcc's
4384 -ffunction-sections command line option. When the linker's
4385 garbage collection decides to discard a .text.<foo> section it
4386 can then also discard the line number information in .debug_line.<foo>.
4388 Since the section is a fragment it does not have the details
4389 needed to fill out a LineInfo structure, so instead we use the
4390 details from the last full debug_line section that we processed. */
4391 end_of_sequence
= end
;
4392 standard_opcodes
= NULL
;
4393 linfo
= saved_linfo
;
4394 /* PR 17531: file: 0522b371. */
4395 if (linfo
.li_line_range
== 0)
4397 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4400 reset_state_machine (linfo
.li_default_is_stmt
);
4404 unsigned char * hdrptr
;
4406 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4407 & end_of_sequence
)) == NULL
)
4410 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
4411 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
4412 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4413 if (linfo
.li_version
>= 5)
4415 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
4416 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
4418 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4419 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4420 if (linfo
.li_version
>= 4)
4421 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4422 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4423 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4424 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4425 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4427 /* PR 17512: file: 1665-6428-0.004. */
4428 if (linfo
.li_line_range
== 0)
4430 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4431 linfo
.li_line_range
= 1;
4434 reset_state_machine (linfo
.li_default_is_stmt
);
4436 /* Display the contents of the Opcodes table. */
4437 standard_opcodes
= hdrptr
;
4439 /* PR 17512: file: 002-417945-0.004. */
4440 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4442 warn (_("Line Base extends beyond end of section\n"));
4446 printf (_("\n Opcodes:\n"));
4448 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4449 printf (ngettext (" Opcode %d has %d arg\n",
4450 " Opcode %d has %d args\n",
4451 standard_opcodes
[i
- 1]),
4452 i
, standard_opcodes
[i
- 1]);
4454 /* Display the contents of the Directory table. */
4455 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4457 if (linfo
.li_version
>= 5)
4459 load_debug_section_with_follow (line_str
, file
);
4461 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4463 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4469 printf (_("\n The Directory Table is empty.\n"));
4472 unsigned int last_dir_entry
= 0;
4474 printf (_("\n The Directory Table (offset 0x%lx):\n"),
4475 (long)(data
- start
));
4477 while (data
< end
&& *data
!= 0)
4479 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4481 data
+= strnlen ((char *) data
, end
- data
);
4486 /* PR 17512: file: 002-132094-0.004. */
4487 if (data
>= end
- 1)
4491 /* Skip the NUL at the end of the table. */
4495 /* Display the contents of the File Name table. */
4496 if (data
>= end
|| *data
== 0)
4497 printf (_("\n The File Name Table is empty.\n"));
4500 printf (_("\n The File Name Table (offset 0x%lx):\n"),
4501 (long)(data
- start
));
4502 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4504 while (data
< end
&& *data
!= 0)
4506 unsigned char *name
;
4509 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4511 data
+= strnlen ((char *) data
, end
- data
);
4515 READ_ULEB (val
, data
, end
);
4516 printf ("%s\t", dwarf_vmatoa ("u", val
));
4517 READ_ULEB (val
, data
, end
);
4518 printf ("%s\t", dwarf_vmatoa ("u", val
));
4519 READ_ULEB (val
, data
, end
);
4520 printf ("%s\t", dwarf_vmatoa ("u", val
));
4521 printf ("%.*s\n", (int)(end
- name
), name
);
4525 warn (_("Corrupt file name table entry\n"));
4531 /* Skip the NUL at the end of the table. */
4537 saved_linfo
= linfo
;
4540 /* Now display the statements. */
4541 if (data
>= end_of_sequence
)
4542 printf (_(" No Line Number Statements.\n"));
4545 printf (_(" Line Number Statements:\n"));
4547 while (data
< end_of_sequence
)
4549 unsigned char op_code
;
4550 dwarf_signed_vma adv
;
4553 printf (" [0x%08lx]", (long)(data
- start
));
4557 if (op_code
>= linfo
.li_opcode_base
)
4559 op_code
-= linfo
.li_opcode_base
;
4560 uladv
= (op_code
/ linfo
.li_line_range
);
4561 if (linfo
.li_max_ops_per_insn
== 1)
4563 uladv
*= linfo
.li_min_insn_length
;
4564 state_machine_regs
.address
+= uladv
;
4566 state_machine_regs
.view
= 0;
4567 printf (_(" Special opcode %d: "
4568 "advance Address by %s to 0x%s%s"),
4569 op_code
, dwarf_vmatoa ("u", uladv
),
4570 dwarf_vmatoa ("x", state_machine_regs
.address
),
4571 verbose_view
&& uladv
4572 ? _(" (reset view)") : "");
4577 = ((state_machine_regs
.op_index
+ uladv
)
4578 / linfo
.li_max_ops_per_insn
)
4579 * linfo
.li_min_insn_length
;
4581 state_machine_regs
.address
+= addrdelta
;
4582 state_machine_regs
.op_index
4583 = (state_machine_regs
.op_index
+ uladv
)
4584 % linfo
.li_max_ops_per_insn
;
4586 state_machine_regs
.view
= 0;
4587 printf (_(" Special opcode %d: "
4588 "advance Address by %s to 0x%s[%d]%s"),
4589 op_code
, dwarf_vmatoa ("u", uladv
),
4590 dwarf_vmatoa ("x", state_machine_regs
.address
),
4591 state_machine_regs
.op_index
,
4592 verbose_view
&& addrdelta
4593 ? _(" (reset view)") : "");
4595 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4596 state_machine_regs
.line
+= adv
;
4597 printf (_(" and Line by %s to %d"),
4598 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4599 if (verbose_view
|| state_machine_regs
.view
)
4600 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4603 state_machine_regs
.view
++;
4608 case DW_LNS_extended_op
:
4609 data
+= process_extended_line_op (data
,
4610 linfo
.li_default_is_stmt
,
4615 printf (_(" Copy"));
4616 if (verbose_view
|| state_machine_regs
.view
)
4617 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4620 state_machine_regs
.view
++;
4623 case DW_LNS_advance_pc
:
4624 READ_ULEB (uladv
, data
, end
);
4625 if (linfo
.li_max_ops_per_insn
== 1)
4627 uladv
*= linfo
.li_min_insn_length
;
4628 state_machine_regs
.address
+= uladv
;
4630 state_machine_regs
.view
= 0;
4631 printf (_(" Advance PC by %s to 0x%s%s\n"),
4632 dwarf_vmatoa ("u", uladv
),
4633 dwarf_vmatoa ("x", state_machine_regs
.address
),
4634 verbose_view
&& uladv
4635 ? _(" (reset view)") : "");
4640 = ((state_machine_regs
.op_index
+ uladv
)
4641 / linfo
.li_max_ops_per_insn
)
4642 * linfo
.li_min_insn_length
;
4643 state_machine_regs
.address
4645 state_machine_regs
.op_index
4646 = (state_machine_regs
.op_index
+ uladv
)
4647 % linfo
.li_max_ops_per_insn
;
4649 state_machine_regs
.view
= 0;
4650 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4651 dwarf_vmatoa ("u", uladv
),
4652 dwarf_vmatoa ("x", state_machine_regs
.address
),
4653 state_machine_regs
.op_index
,
4654 verbose_view
&& addrdelta
4655 ? _(" (reset view)") : "");
4659 case DW_LNS_advance_line
:
4660 READ_SLEB (adv
, data
, end
);
4661 state_machine_regs
.line
+= adv
;
4662 printf (_(" Advance Line by %s to %d\n"),
4663 dwarf_vmatoa ("d", adv
),
4664 state_machine_regs
.line
);
4667 case DW_LNS_set_file
:
4668 READ_ULEB (uladv
, data
, end
);
4669 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4670 dwarf_vmatoa ("u", uladv
));
4671 state_machine_regs
.file
= uladv
;
4674 case DW_LNS_set_column
:
4675 READ_ULEB (uladv
, data
, end
);
4676 printf (_(" Set column to %s\n"),
4677 dwarf_vmatoa ("u", uladv
));
4678 state_machine_regs
.column
= uladv
;
4681 case DW_LNS_negate_stmt
:
4682 adv
= state_machine_regs
.is_stmt
;
4684 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4685 state_machine_regs
.is_stmt
= adv
;
4688 case DW_LNS_set_basic_block
:
4689 printf (_(" Set basic block\n"));
4690 state_machine_regs
.basic_block
= 1;
4693 case DW_LNS_const_add_pc
:
4694 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4695 if (linfo
.li_max_ops_per_insn
)
4697 uladv
*= linfo
.li_min_insn_length
;
4698 state_machine_regs
.address
+= uladv
;
4700 state_machine_regs
.view
= 0;
4701 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4702 dwarf_vmatoa ("u", uladv
),
4703 dwarf_vmatoa ("x", state_machine_regs
.address
),
4704 verbose_view
&& uladv
4705 ? _(" (reset view)") : "");
4710 = ((state_machine_regs
.op_index
+ uladv
)
4711 / linfo
.li_max_ops_per_insn
)
4712 * linfo
.li_min_insn_length
;
4713 state_machine_regs
.address
4715 state_machine_regs
.op_index
4716 = (state_machine_regs
.op_index
+ uladv
)
4717 % linfo
.li_max_ops_per_insn
;
4719 state_machine_regs
.view
= 0;
4720 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4721 dwarf_vmatoa ("u", uladv
),
4722 dwarf_vmatoa ("x", state_machine_regs
.address
),
4723 state_machine_regs
.op_index
,
4724 verbose_view
&& addrdelta
4725 ? _(" (reset view)") : "");
4729 case DW_LNS_fixed_advance_pc
:
4730 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4731 state_machine_regs
.address
+= uladv
;
4732 state_machine_regs
.op_index
= 0;
4733 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4734 dwarf_vmatoa ("u", uladv
),
4735 dwarf_vmatoa ("x", state_machine_regs
.address
));
4736 /* Do NOT reset view. */
4739 case DW_LNS_set_prologue_end
:
4740 printf (_(" Set prologue_end to true\n"));
4743 case DW_LNS_set_epilogue_begin
:
4744 printf (_(" Set epilogue_begin to true\n"));
4747 case DW_LNS_set_isa
:
4748 READ_ULEB (uladv
, data
, end
);
4749 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4753 printf (_(" Unknown opcode %d with operands: "), op_code
);
4755 if (standard_opcodes
!= NULL
)
4756 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4758 READ_ULEB (uladv
, data
, end
);
4759 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4760 i
== 1 ? "" : ", ");
4775 unsigned char *name
;
4776 unsigned int directory_index
;
4777 unsigned int modification_date
;
4778 unsigned int length
;
4781 /* Output a decoded representation of the .debug_line section. */
4784 display_debug_lines_decoded (struct dwarf_section
* section
,
4785 unsigned char * start
,
4786 unsigned char * data
,
4787 unsigned char * end
,
4790 static DWARF2_Internal_LineInfo saved_linfo
;
4792 introduce (section
, false);
4796 /* This loop amounts to one iteration per compilation unit. */
4797 DWARF2_Internal_LineInfo linfo
;
4798 unsigned char *standard_opcodes
;
4799 unsigned char *end_of_sequence
;
4801 File_Entry
*file_table
= NULL
;
4802 unsigned int n_files
= 0;
4803 unsigned char **directory_table
= NULL
;
4804 dwarf_vma n_directories
= 0;
4806 if (startswith (section
->name
, ".debug_line.")
4807 /* Note: the following does not apply to .debug_line.dwo sections.
4808 These are full debug_line sections. */
4809 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4811 /* See comment in display_debug_lines_raw(). */
4812 end_of_sequence
= end
;
4813 standard_opcodes
= NULL
;
4814 linfo
= saved_linfo
;
4815 /* PR 17531: file: 0522b371. */
4816 if (linfo
.li_line_range
== 0)
4818 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4821 reset_state_machine (linfo
.li_default_is_stmt
);
4825 unsigned char *hdrptr
;
4827 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4828 & end_of_sequence
)) == NULL
)
4831 /* PR 17531: file: 0522b371. */
4832 if (linfo
.li_line_range
== 0)
4834 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4835 linfo
.li_line_range
= 1;
4837 reset_state_machine (linfo
.li_default_is_stmt
);
4839 /* Save a pointer to the contents of the Opcodes table. */
4840 standard_opcodes
= hdrptr
;
4842 /* Traverse the Directory table just to count entries. */
4843 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4847 warn (_("opcode base of %d extends beyond end of section\n"),
4848 linfo
.li_opcode_base
);
4852 if (linfo
.li_version
>= 5)
4854 unsigned char *format_start
, format_count
, *format
;
4855 dwarf_vma formati
, entryi
;
4857 load_debug_section_with_follow (line_str
, fileptr
);
4859 /* Skip directories format. */
4860 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4861 if (do_checks
&& format_count
> 1)
4862 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4864 format_start
= data
;
4865 for (formati
= 0; formati
< format_count
; formati
++)
4867 SKIP_ULEB (data
, end
);
4868 SKIP_ULEB (data
, end
);
4871 READ_ULEB (n_directories
, data
, end
);
4874 warn (_("Corrupt directories list\n"));
4878 if (n_directories
== 0)
4879 directory_table
= NULL
;
4881 directory_table
= (unsigned char **)
4882 xmalloc (n_directories
* sizeof (unsigned char *));
4884 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4886 unsigned char **pathp
= &directory_table
[entryi
];
4888 format
= format_start
;
4889 for (formati
= 0; formati
< format_count
; formati
++)
4891 dwarf_vma content_type
, form
;
4894 READ_ULEB (content_type
, format
, end
);
4895 READ_ULEB (form
, format
, end
);
4898 warn (_("Corrupt directories list\n"));
4901 switch (content_type
)
4906 case DW_FORM_string
:
4909 case DW_FORM_line_strp
:
4910 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4912 /* Remove const by the cast. */
4913 *pathp
= (unsigned char *)
4914 fetch_indirect_line_string (uvalue
);
4919 data
= read_and_display_attr_value (0, form
, 0, start
,
4921 linfo
.li_offset_size
,
4928 warn (_("Corrupt directories list\n"));
4933 /* Skip files format. */
4934 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4935 if (do_checks
&& format_count
> 5)
4936 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
4938 format_start
= data
;
4939 for (formati
= 0; formati
< format_count
; formati
++)
4941 SKIP_ULEB (data
, end
);
4942 SKIP_ULEB (data
, end
);
4945 READ_ULEB (n_files
, data
, end
);
4946 if (data
>= end
&& n_files
> 0)
4948 warn (_("Corrupt file name list\n"));
4955 file_table
= (File_Entry
*) xcalloc (1, n_files
4956 * sizeof (File_Entry
));
4958 for (entryi
= 0; entryi
< n_files
; entryi
++)
4960 File_Entry
*file
= &file_table
[entryi
];
4962 format
= format_start
;
4963 for (formati
= 0; formati
< format_count
; formati
++)
4965 dwarf_vma content_type
, form
;
4969 READ_ULEB (content_type
, format
, end
);
4970 READ_ULEB (form
, format
, end
);
4973 warn (_("Corrupt file name list\n"));
4976 switch (content_type
)
4981 case DW_FORM_string
:
4984 case DW_FORM_line_strp
:
4985 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4987 /* Remove const by the cast. */
4988 file
->name
= (unsigned char *)
4989 fetch_indirect_line_string (uvalue
);
4993 case DW_LNCT_directory_index
:
4997 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
5001 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
5006 READ_ULEB (file
->directory_index
, tmp
, end
);
5011 data
= read_and_display_attr_value (0, form
, 0, start
,
5013 linfo
.li_offset_size
,
5020 warn (_("Corrupt file name list\n"));
5029 unsigned char *ptr_directory_table
= data
;
5031 while (data
< end
&& *data
!= 0)
5033 data
+= strnlen ((char *) data
, end
- data
);
5042 warn (_("directory table ends unexpectedly\n"));
5047 /* Go through the directory table again to save the directories. */
5048 directory_table
= (unsigned char **)
5049 xmalloc (n_directories
* sizeof (unsigned char *));
5052 while (*ptr_directory_table
!= 0)
5054 directory_table
[i
] = ptr_directory_table
;
5056 += strlen ((char *) ptr_directory_table
) + 1;
5060 /* Skip the NUL at the end of the table. */
5063 /* Traverse the File Name table just to count the entries. */
5064 if (data
< end
&& *data
!= 0)
5066 unsigned char *ptr_file_name_table
= data
;
5068 while (data
< end
&& *data
!= 0)
5070 /* Skip Name, directory index, last modification
5071 time and length of file. */
5072 data
+= strnlen ((char *) data
, end
- data
);
5075 SKIP_ULEB (data
, end
);
5076 SKIP_ULEB (data
, end
);
5077 SKIP_ULEB (data
, end
);
5083 warn (_("file table ends unexpectedly\n"));
5088 /* Go through the file table again to save the strings. */
5089 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
5092 while (*ptr_file_name_table
!= 0)
5094 file_table
[i
].name
= ptr_file_name_table
;
5096 += strlen ((char *) ptr_file_name_table
) + 1;
5098 /* We are not interested in directory, time or size. */
5099 READ_ULEB (file_table
[i
].directory_index
,
5100 ptr_file_name_table
, end
);
5101 READ_ULEB (file_table
[i
].modification_date
,
5102 ptr_file_name_table
, end
);
5103 READ_ULEB (file_table
[i
].length
,
5104 ptr_file_name_table
, end
);
5110 /* Skip the NUL at the end of the table. */
5114 /* Print the Compilation Unit's name and a header. */
5115 if (file_table
== NULL
)
5116 printf (_("CU: No directory table\n"));
5117 else if (directory_table
== NULL
)
5118 printf (_("CU: %s:\n"), file_table
[0].name
);
5121 unsigned int ix
= file_table
[0].directory_index
;
5122 const char *directory
;
5127 else if (n_directories
== 0)
5128 directory
= _("<unknown>");
5129 else if (ix
> n_directories
)
5131 warn (_("directory index %u > number of directories %s\n"),
5132 ix
, dwarf_vmatoa ("u", n_directories
));
5133 directory
= _("<corrupt>");
5136 directory
= (char *) directory_table
[ix
- 1];
5138 if (do_wide
|| strlen (directory
) < 76)
5139 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
5141 printf ("%s:\n", file_table
[0].name
);
5145 printf (_("File name Line number Starting address View Stmt\n"));
5147 printf (_("CU: Empty file name table\n"));
5148 saved_linfo
= linfo
;
5151 /* This loop iterates through the Dwarf Line Number Program. */
5152 while (data
< end_of_sequence
)
5154 unsigned char op_code
;
5157 unsigned long int uladv
;
5158 int is_special_opcode
= 0;
5163 if (op_code
>= linfo
.li_opcode_base
)
5165 op_code
-= linfo
.li_opcode_base
;
5166 uladv
= (op_code
/ linfo
.li_line_range
);
5167 if (linfo
.li_max_ops_per_insn
== 1)
5169 uladv
*= linfo
.li_min_insn_length
;
5170 state_machine_regs
.address
+= uladv
;
5172 state_machine_regs
.view
= 0;
5177 = ((state_machine_regs
.op_index
+ uladv
)
5178 / linfo
.li_max_ops_per_insn
)
5179 * linfo
.li_min_insn_length
;
5180 state_machine_regs
.address
5182 state_machine_regs
.op_index
5183 = (state_machine_regs
.op_index
+ uladv
)
5184 % linfo
.li_max_ops_per_insn
;
5186 state_machine_regs
.view
= 0;
5189 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
5190 state_machine_regs
.line
+= adv
;
5191 is_special_opcode
= 1;
5192 /* Increment view after printing this row. */
5197 case DW_LNS_extended_op
:
5199 unsigned int ext_op_code_len
;
5200 unsigned char ext_op_code
;
5201 unsigned char *op_code_end
;
5202 unsigned char *op_code_data
= data
;
5204 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
5205 op_code_end
= op_code_data
+ ext_op_code_len
;
5206 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
5208 warn (_("Badly formed extended line op encountered!\n"));
5211 ext_op_code
= *op_code_data
++;
5215 switch (ext_op_code
)
5217 case DW_LNE_end_sequence
:
5218 /* Reset stuff after printing this row. */
5220 case DW_LNE_set_address
:
5221 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
5223 op_code_end
- op_code_data
,
5225 state_machine_regs
.op_index
= 0;
5226 state_machine_regs
.view
= 0;
5228 case DW_LNE_define_file
:
5229 file_table
= (File_Entry
*) xrealloc
5230 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
5232 ++state_machine_regs
.last_file_entry
;
5233 /* Source file name. */
5234 file_table
[n_files
].name
= op_code_data
;
5235 op_code_data
+= strlen ((char *) op_code_data
) + 1;
5236 /* Directory index. */
5237 READ_ULEB (file_table
[n_files
].directory_index
,
5238 op_code_data
, op_code_end
);
5239 /* Last modification time. */
5240 READ_ULEB (file_table
[n_files
].modification_date
,
5241 op_code_data
, op_code_end
);
5243 READ_ULEB (file_table
[n_files
].length
,
5244 op_code_data
, op_code_end
);
5248 case DW_LNE_set_discriminator
:
5249 case DW_LNE_HP_set_sequence
:
5250 /* Simply ignored. */
5254 printf (_("UNKNOWN (%u): length %ld\n"),
5255 ext_op_code
, (long int) (op_code_data
- data
));
5262 /* Increment view after printing this row. */
5265 case DW_LNS_advance_pc
:
5266 READ_ULEB (uladv
, data
, end
);
5267 if (linfo
.li_max_ops_per_insn
== 1)
5269 uladv
*= linfo
.li_min_insn_length
;
5270 state_machine_regs
.address
+= uladv
;
5272 state_machine_regs
.view
= 0;
5277 = ((state_machine_regs
.op_index
+ uladv
)
5278 / linfo
.li_max_ops_per_insn
)
5279 * linfo
.li_min_insn_length
;
5280 state_machine_regs
.address
5282 state_machine_regs
.op_index
5283 = (state_machine_regs
.op_index
+ uladv
)
5284 % linfo
.li_max_ops_per_insn
;
5286 state_machine_regs
.view
= 0;
5290 case DW_LNS_advance_line
:
5291 READ_SLEB (adv
, data
, end
);
5292 state_machine_regs
.line
+= adv
;
5295 case DW_LNS_set_file
:
5296 READ_ULEB (uladv
, data
, end
);
5297 state_machine_regs
.file
= uladv
;
5300 unsigned file
= state_machine_regs
.file
- 1;
5303 if (file_table
== NULL
|| n_files
== 0)
5304 printf (_("\n [Use file table entry %d]\n"), file
);
5306 else if (file
>= n_files
)
5308 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
5309 printf (_("\n <over large file table index %u>"), file
);
5311 else if ((dir
= file_table
[file
].directory_index
) == 0)
5312 /* If directory index is 0, that means current directory. */
5313 printf ("\n./%s:[++]\n", file_table
[file
].name
);
5314 else if (directory_table
== NULL
|| n_directories
== 0)
5315 printf (_("\n [Use file %s in directory table entry %d]\n"),
5316 file_table
[file
].name
, dir
);
5318 else if (dir
> n_directories
)
5320 warn (_("directory index %u > number of directories %s\n"),
5321 dir
, dwarf_vmatoa ("u", n_directories
));
5322 printf (_("\n <over large directory table entry %u>\n"), dir
);
5325 printf ("\n%s/%s:\n",
5326 /* The directory index starts counting at 1. */
5327 directory_table
[dir
- 1], file_table
[file
].name
);
5331 case DW_LNS_set_column
:
5332 READ_ULEB (uladv
, data
, end
);
5333 state_machine_regs
.column
= uladv
;
5336 case DW_LNS_negate_stmt
:
5337 adv
= state_machine_regs
.is_stmt
;
5339 state_machine_regs
.is_stmt
= adv
;
5342 case DW_LNS_set_basic_block
:
5343 state_machine_regs
.basic_block
= 1;
5346 case DW_LNS_const_add_pc
:
5347 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5348 if (linfo
.li_max_ops_per_insn
== 1)
5350 uladv
*= linfo
.li_min_insn_length
;
5351 state_machine_regs
.address
+= uladv
;
5353 state_machine_regs
.view
= 0;
5358 = ((state_machine_regs
.op_index
+ uladv
)
5359 / linfo
.li_max_ops_per_insn
)
5360 * linfo
.li_min_insn_length
;
5361 state_machine_regs
.address
5363 state_machine_regs
.op_index
5364 = (state_machine_regs
.op_index
+ uladv
)
5365 % linfo
.li_max_ops_per_insn
;
5367 state_machine_regs
.view
= 0;
5371 case DW_LNS_fixed_advance_pc
:
5372 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5373 state_machine_regs
.address
+= uladv
;
5374 state_machine_regs
.op_index
= 0;
5375 /* Do NOT reset view. */
5378 case DW_LNS_set_prologue_end
:
5381 case DW_LNS_set_epilogue_begin
:
5384 case DW_LNS_set_isa
:
5385 READ_ULEB (uladv
, data
, end
);
5386 printf (_(" Set ISA to %lu\n"), uladv
);
5390 printf (_(" Unknown opcode %d with operands: "), op_code
);
5392 if (standard_opcodes
!= NULL
)
5393 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5397 READ_ULEB (val
, data
, end
);
5398 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
5399 i
== 1 ? "" : ", ");
5405 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5406 to the DWARF address/line matrix. */
5407 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5408 || (xop
== DW_LNS_copy
))
5410 const unsigned int MAX_FILENAME_LENGTH
= 35;
5412 char *newFileName
= NULL
;
5413 size_t fileNameLength
;
5417 unsigned indx
= state_machine_regs
.file
- 1;
5419 if (indx
>= n_files
)
5421 warn (_("corrupt file index %u encountered\n"), indx
);
5422 fileName
= _("<corrupt>");
5425 fileName
= (char *) file_table
[indx
].name
;
5428 fileName
= _("<unknown>");
5430 fileNameLength
= strlen (fileName
);
5431 newFileName
= fileName
;
5432 if (fileNameLength
> MAX_FILENAME_LENGTH
&& !do_wide
)
5434 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5435 /* Truncate file name */
5436 memcpy (newFileName
,
5437 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5438 MAX_FILENAME_LENGTH
);
5439 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5442 /* A row with end_seq set to true has a meaningful address, but
5443 the other information in the same row is not significant.
5444 In such a row, print line as "-", and don't print
5446 if (!do_wide
|| fileNameLength
<= MAX_FILENAME_LENGTH
)
5448 if (linfo
.li_max_ops_per_insn
== 1)
5450 if (xop
== -DW_LNE_end_sequence
)
5451 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x",
5453 state_machine_regs
.address
);
5455 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
5456 newFileName
, state_machine_regs
.line
,
5457 state_machine_regs
.address
);
5461 if (xop
== -DW_LNE_end_sequence
)
5462 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5464 state_machine_regs
.address
,
5465 state_machine_regs
.op_index
);
5467 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5468 newFileName
, state_machine_regs
.line
,
5469 state_machine_regs
.address
,
5470 state_machine_regs
.op_index
);
5475 if (linfo
.li_max_ops_per_insn
== 1)
5477 if (xop
== -DW_LNE_end_sequence
)
5478 printf ("%s %11s %#18" DWARF_VMA_FMT
"x",
5480 state_machine_regs
.address
);
5482 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5483 newFileName
, state_machine_regs
.line
,
5484 state_machine_regs
.address
);
5488 if (xop
== -DW_LNE_end_sequence
)
5489 printf ("%s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5491 state_machine_regs
.address
,
5492 state_machine_regs
.op_index
);
5494 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5495 newFileName
, state_machine_regs
.line
,
5496 state_machine_regs
.address
,
5497 state_machine_regs
.op_index
);
5501 if (xop
!= -DW_LNE_end_sequence
)
5503 if (state_machine_regs
.view
)
5504 printf (" %6u", state_machine_regs
.view
);
5508 if (state_machine_regs
.is_stmt
)
5513 state_machine_regs
.view
++;
5515 if (xop
== -DW_LNE_end_sequence
)
5517 reset_state_machine (linfo
.li_default_is_stmt
);
5521 if (newFileName
!= fileName
)
5533 if (directory_table
)
5535 free (directory_table
);
5536 directory_table
= NULL
;
5547 display_debug_lines (struct dwarf_section
*section
, void *file
)
5549 unsigned char *data
= section
->start
;
5550 unsigned char *end
= data
+ section
->size
;
5552 int retValDecoded
= 1;
5554 if (do_debug_lines
== 0)
5555 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5557 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5558 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5560 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5561 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5563 if (!retValRaw
|| !retValDecoded
)
5570 find_debug_info_for_offset (unsigned long offset
)
5574 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5577 for (i
= 0; i
< num_debug_info_entries
; i
++)
5578 if (debug_information
[i
].cu_offset
== offset
)
5579 return debug_information
+ i
;
5585 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5587 /* See gdb/gdb-index.h. */
5588 static const char * const kinds
[] =
5600 return _ (kinds
[kind
]);
5604 display_debug_pubnames_worker (struct dwarf_section
*section
,
5605 void *file ATTRIBUTE_UNUSED
,
5608 DWARF2_Internal_PubNames names
;
5609 unsigned char *start
= section
->start
;
5610 unsigned char *end
= start
+ section
->size
;
5612 /* It does not matter if this load fails,
5613 we test for that later on. */
5614 load_debug_info (file
);
5616 introduce (section
, false);
5620 unsigned char *data
;
5621 unsigned long sec_off
= start
- section
->start
;
5622 unsigned int offset_size
;
5624 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5625 if (names
.pn_length
== 0xffffffff)
5627 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5633 if (names
.pn_length
> (size_t) (end
- start
))
5635 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5638 dwarf_vmatoa ("x", names
.pn_length
));
5643 start
+= names
.pn_length
;
5645 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, start
);
5646 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, start
);
5648 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5649 && num_debug_info_entries
> 0
5650 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5651 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5652 (unsigned long) names
.pn_offset
, section
->name
);
5654 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, start
);
5656 printf (_(" Length: %ld\n"),
5657 (long) names
.pn_length
);
5658 printf (_(" Version: %d\n"),
5660 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5661 (unsigned long) names
.pn_offset
);
5662 printf (_(" Size of area in .debug_info section: %ld\n"),
5663 (long) names
.pn_size
);
5665 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5667 static int warned
= 0;
5671 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5679 printf (_("\n Offset Kind Name\n"));
5681 printf (_("\n Offset\tName\n"));
5685 bfd_size_type maxprint
;
5688 SAFE_BYTE_GET_AND_INC (offset
, data
, offset_size
, start
);
5695 maxprint
= (start
- data
) - 1;
5699 unsigned int kind_data
;
5700 gdb_index_symbol_kind kind
;
5701 const char *kind_name
;
5704 SAFE_BYTE_GET_AND_INC (kind_data
, data
, 1, start
);
5706 /* GCC computes the kind as the upper byte in the CU index
5707 word, and then right shifts it by the CU index size.
5708 Left shift KIND to where the gdb-index.h accessor macros
5710 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5711 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5712 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5713 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5714 printf (" %-6lx %s,%-10s %.*s\n",
5715 (unsigned long) offset
, is_static
? _("s") : _("g"),
5716 kind_name
, (int) maxprint
, data
);
5719 printf (" %-6lx\t%.*s\n",
5720 (unsigned long) offset
, (int) maxprint
, data
);
5722 data
+= strnlen ((char *) data
, maxprint
);
5735 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5737 return display_debug_pubnames_worker (section
, file
, 0);
5741 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5743 return display_debug_pubnames_worker (section
, file
, 1);
5747 display_debug_macinfo (struct dwarf_section
*section
,
5748 void *file ATTRIBUTE_UNUSED
)
5750 unsigned char *start
= section
->start
;
5751 unsigned char *end
= start
+ section
->size
;
5752 unsigned char *curr
= start
;
5753 enum dwarf_macinfo_record_type op
;
5755 introduce (section
, false);
5759 unsigned int lineno
;
5760 const unsigned char *string
;
5762 op
= (enum dwarf_macinfo_record_type
) *curr
;
5767 case DW_MACINFO_start_file
:
5769 unsigned int filenum
;
5771 READ_ULEB (lineno
, curr
, end
);
5772 READ_ULEB (filenum
, curr
, end
);
5773 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5778 case DW_MACINFO_end_file
:
5779 printf (_(" DW_MACINFO_end_file\n"));
5782 case DW_MACINFO_define
:
5783 READ_ULEB (lineno
, curr
, end
);
5785 curr
+= strnlen ((char *) string
, end
- string
);
5786 printf (_(" DW_MACINFO_define - lineno : %d macro : %*s\n"),
5787 lineno
, (int) (curr
- string
), string
);
5792 case DW_MACINFO_undef
:
5793 READ_ULEB (lineno
, curr
, end
);
5795 curr
+= strnlen ((char *) string
, end
- string
);
5796 printf (_(" DW_MACINFO_undef - lineno : %d macro : %*s\n"),
5797 lineno
, (int) (curr
- string
), string
);
5802 case DW_MACINFO_vendor_ext
:
5804 unsigned int constant
;
5806 READ_ULEB (constant
, curr
, end
);
5808 curr
+= strnlen ((char *) string
, end
- string
);
5809 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %*s\n"),
5810 constant
, (int) (curr
- string
), string
);
5821 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5822 filename and dirname corresponding to file name table entry with index
5823 FILEIDX. Return NULL on failure. */
5825 static unsigned char *
5826 get_line_filename_and_dirname (dwarf_vma line_offset
,
5828 unsigned char **dir_name
)
5830 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5831 unsigned char *hdrptr
, *dirtable
, *file_name
;
5832 unsigned int offset_size
;
5833 unsigned int version
, opcode_base
;
5834 dwarf_vma length
, diridx
;
5835 const unsigned char * end
;
5838 if (section
->start
== NULL
5839 || line_offset
>= section
->size
5843 hdrptr
= section
->start
+ line_offset
;
5844 end
= section
->start
+ section
->size
;
5846 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5847 if (length
== 0xffffffff)
5849 /* This section is 64-bit DWARF 3. */
5850 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5856 if (length
> (size_t) (end
- hdrptr
)
5857 || length
< 2 + offset_size
+ 1 + 3 + 1)
5859 end
= hdrptr
+ length
;
5861 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5862 if (version
!= 2 && version
!= 3 && version
!= 4)
5864 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5866 hdrptr
++; /* Skip max_ops_per_insn. */
5867 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5869 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5870 if (opcode_base
== 0
5871 || opcode_base
- 1 >= (size_t) (end
- hdrptr
))
5874 hdrptr
+= opcode_base
- 1;
5877 /* Skip over dirname table. */
5878 while (*hdrptr
!= '\0')
5880 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5886 hdrptr
++; /* Skip the NUL at the end of the table. */
5888 /* Now skip over preceding filename table entries. */
5889 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5891 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5894 SKIP_ULEB (hdrptr
, end
);
5895 SKIP_ULEB (hdrptr
, end
);
5896 SKIP_ULEB (hdrptr
, end
);
5898 if (hdrptr
>= end
|| *hdrptr
== '\0')
5902 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
);
5907 READ_ULEB (diridx
, hdrptr
, end
);
5910 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5912 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
);
5916 if (dirtable
>= end
|| *dirtable
== '\0')
5918 *dir_name
= dirtable
;
5923 display_debug_macro (struct dwarf_section
*section
,
5926 unsigned char *start
= section
->start
;
5927 unsigned char *end
= start
+ section
->size
;
5928 unsigned char *curr
= start
;
5929 unsigned char *extended_op_buf
[256];
5930 bool is_dwo
= false;
5931 const char *suffix
= strrchr (section
->name
, '.');
5933 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
5936 load_debug_section_with_follow (str
, file
);
5937 load_debug_section_with_follow (line
, file
);
5938 load_debug_section_with_follow (str_index
, file
);
5940 introduce (section
, false);
5944 unsigned int lineno
, version
, flags
;
5945 unsigned int offset_size
;
5946 const unsigned char *string
;
5947 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5948 unsigned char **extended_ops
= NULL
;
5950 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5951 if (version
!= 4 && version
!= 5)
5953 error (_("Expected to find a version number of 4 or 5 in section %s but found %d instead\n"),
5954 section
->name
, version
);
5958 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5959 offset_size
= (flags
& 1) ? 8 : 4;
5960 printf (_(" Offset: 0x%lx\n"),
5961 (unsigned long) sec_offset
);
5962 printf (_(" Version: %d\n"), version
);
5963 printf (_(" Offset size: %d\n"), offset_size
);
5966 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5967 printf (_(" Offset into .debug_line: 0x%lx\n"),
5968 (unsigned long) line_offset
);
5972 unsigned int i
, count
, op
;
5975 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5977 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5978 extended_ops
= extended_op_buf
;
5981 printf (_(" Extension opcode arguments:\n"));
5982 for (i
= 0; i
< count
; i
++)
5984 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5985 extended_ops
[op
] = curr
;
5986 READ_ULEB (nargs
, curr
, end
);
5988 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5991 printf (_(" DW_MACRO_%02x arguments: "), op
);
5992 for (n
= 0; n
< nargs
; n
++)
5996 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5997 printf ("%s%s", get_FORM_name (form
),
5998 n
== nargs
- 1 ? "\n" : ", ");
6008 case DW_FORM_block1
:
6009 case DW_FORM_block2
:
6010 case DW_FORM_block4
:
6012 case DW_FORM_string
:
6014 case DW_FORM_sec_offset
:
6017 error (_("Invalid extension opcode form %s\n"),
6018 get_FORM_name (form
));
6034 error (_(".debug_macro section not zero terminated\n"));
6038 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
6044 case DW_MACRO_define
:
6045 READ_ULEB (lineno
, curr
, end
);
6047 curr
+= strnlen ((char *) string
, end
- string
);
6048 printf (_(" DW_MACRO_define - lineno : %d macro : %*s\n"),
6049 lineno
, (int) (curr
- string
), string
);
6054 case DW_MACRO_undef
:
6055 READ_ULEB (lineno
, curr
, end
);
6057 curr
+= strnlen ((char *) string
, end
- string
);
6058 printf (_(" DW_MACRO_undef - lineno : %d macro : %*s\n"),
6059 lineno
, (int) (curr
- string
), string
);
6064 case DW_MACRO_start_file
:
6066 unsigned int filenum
;
6067 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6069 READ_ULEB (lineno
, curr
, end
);
6070 READ_ULEB (filenum
, curr
, end
);
6072 if ((flags
& 2) == 0)
6073 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6076 = get_line_filename_and_dirname (line_offset
, filenum
,
6078 if (file_name
== NULL
)
6079 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6082 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6084 dir_name
!= NULL
? (const char *) dir_name
: "",
6085 dir_name
!= NULL
? "/" : "", file_name
);
6089 case DW_MACRO_end_file
:
6090 printf (_(" DW_MACRO_end_file\n"));
6093 case DW_MACRO_define_strp
:
6094 READ_ULEB (lineno
, curr
, end
);
6095 if (version
== 4 && is_dwo
)
6096 READ_ULEB (offset
, curr
, end
);
6098 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6099 string
= fetch_indirect_string (offset
);
6100 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6104 case DW_MACRO_undef_strp
:
6105 READ_ULEB (lineno
, curr
, end
);
6106 if (version
== 4 && is_dwo
)
6107 READ_ULEB (offset
, curr
, end
);
6109 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6110 string
= fetch_indirect_string (offset
);
6111 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6115 case DW_MACRO_import
:
6116 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6117 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
6118 (unsigned long) offset
);
6121 case DW_MACRO_define_sup
:
6122 READ_ULEB (lineno
, curr
, end
);
6123 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6124 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
6125 lineno
, (unsigned long) offset
);
6128 case DW_MACRO_undef_sup
:
6129 READ_ULEB (lineno
, curr
, end
);
6130 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6131 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
6132 lineno
, (unsigned long) offset
);
6135 case DW_MACRO_import_sup
:
6136 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6137 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
6138 (unsigned long) offset
);
6141 case DW_MACRO_define_strx
:
6142 case DW_MACRO_undef_strx
:
6143 READ_ULEB (lineno
, curr
, end
);
6144 READ_ULEB (offset
, curr
, end
);
6145 string
= (const unsigned char *)
6146 fetch_indexed_string (offset
, NULL
, offset_size
, false);
6147 if (op
== DW_MACRO_define_strx
)
6148 printf (" DW_MACRO_define_strx ");
6150 printf (" DW_MACRO_undef_strx ");
6152 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
6153 printf (_("lineno : %d macro : %s\n"),
6158 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6160 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6164 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6166 error (_(" Unknown macro opcode %02x seen\n"), op
);
6171 /* Skip over unhandled opcodes. */
6173 unsigned char *desc
= extended_ops
[op
];
6174 READ_ULEB (nargs
, desc
, end
);
6177 printf (_(" DW_MACRO_%02x\n"), op
);
6180 printf (_(" DW_MACRO_%02x -"), op
);
6181 for (n
= 0; n
< nargs
; n
++)
6185 /* DW_FORM_implicit_const is not expected here. */
6186 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6188 = read_and_display_attr_value (0, val
, 0,
6189 start
, curr
, end
, 0, 0, offset_size
,
6190 version
, NULL
, 0, NULL
,
6208 display_debug_abbrev (struct dwarf_section
*section
,
6209 void *file ATTRIBUTE_UNUSED
)
6211 abbrev_entry
*entry
;
6212 unsigned char *start
= section
->start
;
6214 introduce (section
, false);
6221 offset
= start
- section
->start
;
6222 list
= find_abbrev_list_by_abbrev_offset (0, offset
);
6225 list
= new_abbrev_list (0, offset
);
6226 start
= process_abbrev_set (section
, 0, section
->size
, offset
, list
);
6227 list
->start_of_next_abbrevs
= start
;
6230 start
= list
->start_of_next_abbrevs
;
6232 if (list
->first_abbrev
== NULL
)
6235 printf (_(" Number TAG (0x%lx)\n"), (long) offset
);
6237 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6241 printf (" %ld %s [%s]\n",
6243 get_TAG_name (entry
->tag
),
6244 entry
->children
? _("has children") : _("no children"));
6246 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6248 printf (" %-18s %s",
6249 get_AT_name (attr
->attribute
),
6250 get_FORM_name (attr
->form
));
6251 if (attr
->form
== DW_FORM_implicit_const
)
6252 printf (": %s", dwarf_vmatoa ("d", attr
->implicit_const
));
6264 /* Return true when ADDR is the maximum address, when addresses are
6265 POINTER_SIZE bytes long. */
6268 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
6270 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
6271 return ((addr
& mask
) == mask
);
6274 /* Display a view pair list starting at *VSTART_PTR and ending at
6275 VLISTEND within SECTION. */
6278 display_view_pair_list (struct dwarf_section
*section
,
6279 unsigned char **vstart_ptr
,
6280 unsigned int debug_info_entry
,
6281 unsigned char *vlistend
)
6283 unsigned char *vstart
= *vstart_ptr
;
6284 unsigned char *section_end
= section
->start
+ section
->size
;
6285 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6287 if (vlistend
< section_end
)
6288 section_end
= vlistend
;
6292 while (vstart
< section_end
)
6294 dwarf_vma off
= vstart
- section
->start
;
6295 dwarf_vma vbegin
, vend
;
6297 READ_ULEB (vbegin
, vstart
, section_end
);
6298 if (vstart
== section_end
)
6301 READ_ULEB (vend
, vstart
, section_end
);
6302 printf (" %8.8lx ", (unsigned long) off
);
6304 print_dwarf_view (vbegin
, pointer_size
, 1);
6305 print_dwarf_view (vend
, pointer_size
, 1);
6306 printf (_("location view pair\n"));
6310 *vstart_ptr
= vstart
;
6313 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6316 display_loc_list (struct dwarf_section
*section
,
6317 unsigned char **start_ptr
,
6318 unsigned int debug_info_entry
,
6320 dwarf_vma base_address
,
6321 unsigned char **vstart_ptr
,
6324 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6325 unsigned char *section_end
= section
->start
+ section
->size
;
6326 unsigned long cu_offset
;
6327 unsigned int pointer_size
;
6328 unsigned int offset_size
;
6333 unsigned short length
;
6334 int need_frame_base
;
6336 if (debug_info_entry
>= num_debug_info_entries
)
6338 warn (_("No debug information available for loc lists of entry: %u\n"),
6343 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6344 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6345 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6346 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6348 if (pointer_size
< 2 || pointer_size
> 8)
6350 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6351 pointer_size
, debug_info_entry
);
6357 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6358 dwarf_vma vbegin
= vm1
, vend
= vm1
;
6360 if (2 * pointer_size
> (size_t) (section_end
- start
))
6362 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6363 (unsigned long) offset
);
6367 printf (" %8.8lx ", (unsigned long) off
);
6369 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6370 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6372 if (begin
== 0 && end
== 0)
6374 /* PR 18374: In a object file we can have a location list that
6375 starts with a begin and end of 0 because there are relocations
6376 that need to be applied to the addresses. Actually applying
6377 the relocations now does not help as they will probably resolve
6378 to 0, since the object file has not been fully linked. Real
6379 end of list markers will not have any relocations against them. */
6380 if (! reloc_at (section
, off
)
6381 && ! reloc_at (section
, off
+ pointer_size
))
6383 printf (_("<End of list>\n"));
6388 /* Check base address specifiers. */
6389 if (is_max_address (begin
, pointer_size
)
6390 && !is_max_address (end
, pointer_size
))
6393 print_dwarf_vma (begin
, pointer_size
);
6394 print_dwarf_vma (end
, pointer_size
);
6395 printf (_("(base address)\n"));
6401 off
= offset
+ (vstart
- *start_ptr
);
6403 READ_ULEB (vbegin
, vstart
, section_end
);
6404 print_dwarf_view (vbegin
, pointer_size
, 1);
6406 READ_ULEB (vend
, vstart
, section_end
);
6407 print_dwarf_view (vend
, pointer_size
, 1);
6409 printf (_("views at %8.8lx for:\n %*s "),
6410 (unsigned long) off
, 8, "");
6413 if (2 > (size_t) (section_end
- start
))
6415 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6416 (unsigned long) offset
);
6420 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6422 if (length
> (size_t) (section_end
- start
))
6424 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6425 (unsigned long) offset
);
6429 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6430 print_dwarf_vma (end
+ base_address
, pointer_size
);
6433 need_frame_base
= decode_location_expression (start
,
6438 cu_offset
, section
);
6441 if (need_frame_base
&& !has_frame_base
)
6442 printf (_(" [without DW_AT_frame_base]"));
6444 if (begin
== end
&& vbegin
== vend
)
6445 fputs (_(" (start == end)"), stdout
);
6446 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6447 fputs (_(" (start > end)"), stdout
);
6455 *vstart_ptr
= vstart
;
6458 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6461 display_loclists_list (struct dwarf_section
*section
,
6462 unsigned char **start_ptr
,
6463 unsigned int debug_info_entry
,
6465 dwarf_vma base_address
,
6466 unsigned char **vstart_ptr
,
6469 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6470 unsigned char *section_end
= section
->start
+ section
->size
;
6471 unsigned long cu_offset
;
6472 unsigned int pointer_size
;
6473 unsigned int offset_size
;
6476 /* Initialize it due to a false compiler warning. */
6477 dwarf_vma begin
= -1, vbegin
= -1;
6478 dwarf_vma end
= -1, vend
= -1;
6480 int need_frame_base
;
6482 if (debug_info_entry
>= num_debug_info_entries
)
6484 warn (_("No debug information available for "
6485 "loclists lists of entry: %u\n"),
6490 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6491 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6492 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6493 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6495 if (pointer_size
< 2 || pointer_size
> 8)
6497 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6498 pointer_size
, debug_info_entry
);
6504 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6505 enum dwarf_location_list_entry_type llet
;
6507 if (start
+ 1 > section_end
)
6509 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6510 (unsigned long) offset
);
6514 printf (" %8.8lx ", (unsigned long) off
);
6516 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6518 if (vstart
&& (llet
== DW_LLE_offset_pair
6519 || llet
== DW_LLE_start_end
6520 || llet
== DW_LLE_start_length
))
6522 off
= offset
+ (vstart
- *start_ptr
);
6524 READ_ULEB (vbegin
, vstart
, section_end
);
6525 print_dwarf_view (vbegin
, pointer_size
, 1);
6527 READ_ULEB (vend
, vstart
, section_end
);
6528 print_dwarf_view (vend
, pointer_size
, 1);
6530 printf (_("views at %8.8lx for:\n %*s "),
6531 (unsigned long) off
, 8, "");
6536 case DW_LLE_end_of_list
:
6537 printf (_("<End of list>\n"));
6539 case DW_LLE_offset_pair
:
6540 READ_ULEB (begin
, start
, section_end
);
6541 begin
+= base_address
;
6542 READ_ULEB (end
, start
, section_end
);
6543 end
+= base_address
;
6545 case DW_LLE_start_end
:
6546 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6547 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6549 case DW_LLE_start_length
:
6550 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6551 READ_ULEB (end
, start
, section_end
);
6554 case DW_LLE_base_address
:
6555 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6557 print_dwarf_vma (base_address
, pointer_size
);
6558 printf (_("(base address)\n"));
6560 #ifdef DW_LLE_view_pair
6561 case DW_LLE_view_pair
:
6563 printf (_("View pair entry in loclist with locviews attribute\n"));
6564 READ_ULEB (vbegin
, start
, section_end
);
6565 print_dwarf_view (vbegin
, pointer_size
, 1);
6567 READ_ULEB (vend
, start
, section_end
);
6568 print_dwarf_view (vend
, pointer_size
, 1);
6570 printf (_("views for:\n"));
6574 error (_("Invalid location list entry type %d\n"), llet
);
6577 if (llet
== DW_LLE_end_of_list
)
6579 if (llet
!= DW_LLE_offset_pair
6580 && llet
!= DW_LLE_start_end
6581 && llet
!= DW_LLE_start_length
)
6584 if (start
== section_end
)
6586 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6587 (unsigned long) offset
);
6590 READ_ULEB (length
, start
, section_end
);
6592 if (length
> (size_t) (section_end
- start
))
6594 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6595 (unsigned long) offset
);
6599 print_dwarf_vma (begin
, pointer_size
);
6600 print_dwarf_vma (end
, pointer_size
);
6603 need_frame_base
= decode_location_expression (start
,
6608 cu_offset
, section
);
6611 if (need_frame_base
&& !has_frame_base
)
6612 printf (_(" [without DW_AT_frame_base]"));
6614 if (begin
== end
&& vbegin
== vend
)
6615 fputs (_(" (start == end)"), stdout
);
6616 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6617 fputs (_(" (start > end)"), stdout
);
6625 if (vbegin
!= vm1
|| vend
!= vm1
)
6626 printf (_("Trailing view pair not used in a range"));
6629 *vstart_ptr
= vstart
;
6632 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6633 right-adjusted in a field of length LEN, and followed by a space. */
6636 print_addr_index (unsigned int idx
, unsigned int len
)
6638 static char buf
[15];
6639 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6640 printf ("%*s ", len
, buf
);
6643 /* Display a location list from a .dwo section. It uses address indexes rather
6644 than embedded addresses. This code closely follows display_loc_list, but the
6645 two are sufficiently different that combining things is very ugly. */
6648 display_loc_list_dwo (struct dwarf_section
*section
,
6649 unsigned char **start_ptr
,
6650 unsigned int debug_info_entry
,
6652 unsigned char **vstart_ptr
,
6655 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6656 unsigned char *section_end
= section
->start
+ section
->size
;
6657 unsigned long cu_offset
;
6658 unsigned int pointer_size
;
6659 unsigned int offset_size
;
6662 unsigned short length
;
6663 int need_frame_base
;
6666 if (debug_info_entry
>= num_debug_info_entries
)
6668 warn (_("No debug information for loc lists of entry: %u\n"),
6673 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6674 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6675 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6676 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6678 if (pointer_size
< 2 || pointer_size
> 8)
6680 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6681 pointer_size
, debug_info_entry
);
6687 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6689 if (start
>= section_end
)
6691 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6692 (unsigned long) offset
);
6696 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6709 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6711 READ_ULEB (view
, vstart
, section_end
);
6712 print_dwarf_view (view
, 8, 1);
6714 READ_ULEB (view
, vstart
, section_end
);
6715 print_dwarf_view (view
, 8, 1);
6717 printf (_("views at %8.8lx for:\n %*s "),
6718 (unsigned long) off
, 8, "");
6726 case 0: /* A terminating entry. */
6728 *vstart_ptr
= vstart
;
6729 printf (_("<End of list>\n"));
6731 case 1: /* A base-address entry. */
6732 READ_ULEB (idx
, start
, section_end
);
6733 print_addr_index (idx
, 8);
6734 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6735 printf (_("(base address selection entry)\n"));
6737 case 2: /* A start/end entry. */
6738 READ_ULEB (idx
, start
, section_end
);
6739 print_addr_index (idx
, 8);
6740 READ_ULEB (idx
, start
, section_end
);
6741 print_addr_index (idx
, 8);
6743 case 3: /* A start/length entry. */
6744 READ_ULEB (idx
, start
, section_end
);
6745 print_addr_index (idx
, 8);
6746 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6747 printf ("%08x ", idx
);
6749 case 4: /* An offset pair entry. */
6750 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6751 printf ("%08x ", idx
);
6752 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6753 printf ("%08x ", idx
);
6756 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6758 *vstart_ptr
= vstart
;
6762 if (2 > (size_t) (section_end
- start
))
6764 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6765 (unsigned long) offset
);
6769 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6770 if (length
> (size_t) (section_end
- start
))
6772 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6773 (unsigned long) offset
);
6778 need_frame_base
= decode_location_expression (start
,
6783 cu_offset
, section
);
6786 if (need_frame_base
&& !has_frame_base
)
6787 printf (_(" [without DW_AT_frame_base]"));
6795 *vstart_ptr
= vstart
;
6798 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6801 static dwarf_vma
*loc_offsets
, *loc_views
;
6804 loc_offsets_compar (const void *ap
, const void *bp
)
6806 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6807 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6809 int ret
= (a
> b
) - (b
> a
);
6813 a
= loc_views
[*(const unsigned int *) ap
];
6814 b
= loc_views
[*(const unsigned int *) bp
];
6816 ret
= (a
> b
) - (b
> a
);
6822 display_debug_loc (struct dwarf_section
*section
, void *file
)
6824 unsigned char *start
= section
->start
, *vstart
= NULL
;
6825 unsigned long bytes
;
6826 unsigned char *section_begin
= start
;
6827 unsigned int num_loc_list
= 0;
6828 unsigned long last_offset
= 0;
6829 unsigned long last_view
= 0;
6830 unsigned int first
= 0;
6833 int seen_first_offset
= 0;
6834 int locs_sorted
= 1;
6835 unsigned char *next
= start
, *vnext
= vstart
;
6836 unsigned int *array
= NULL
;
6837 const char *suffix
= strrchr (section
->name
, '.');
6838 bool is_dwo
= false;
6839 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6840 dwarf_vma expected_start
= 0;
6842 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6845 bytes
= section
->size
;
6849 printf (_("\nThe %s section is empty.\n"), section
->name
);
6855 unsigned char *hdrptr
= section_begin
;
6856 dwarf_vma ll_length
;
6857 unsigned short ll_version
;
6858 unsigned char *end
= section_begin
+ section
->size
;
6859 unsigned char address_size
, segment_selector_size
;
6860 uint32_t offset_entry_count
;
6862 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6863 if (ll_length
== 0xffffffff)
6864 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6866 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6867 if (ll_version
!= 5)
6869 warn (_("The %s section contains corrupt or "
6870 "unsupported version number: %d.\n"),
6871 section
->name
, ll_version
);
6875 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6877 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6878 if (segment_selector_size
!= 0)
6880 warn (_("The %s section contains "
6881 "unsupported segment selector size: %d.\n"),
6882 section
->name
, segment_selector_size
);
6886 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6887 if (offset_entry_count
!= 0)
6889 warn (_("The %s section contains "
6890 "unsupported offset entry count: %d.\n"),
6891 section
->name
, offset_entry_count
);
6895 expected_start
= hdrptr
- section_begin
;
6898 if (load_debug_info (file
) == 0)
6900 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6905 /* Check the order of location list in .debug_info section. If
6906 offsets of location lists are in the ascending order, we can
6907 use `debug_information' directly. */
6908 for (i
= 0; i
< num_debug_info_entries
; i
++)
6912 num
= debug_information
[i
].num_loc_offsets
;
6913 if (num
> num_loc_list
)
6916 /* Check if we can use `debug_information' directly. */
6917 if (locs_sorted
&& num
!= 0)
6919 if (!seen_first_offset
)
6921 /* This is the first location list. */
6922 last_offset
= debug_information
[i
].loc_offsets
[0];
6923 last_view
= debug_information
[i
].loc_views
[0];
6925 seen_first_offset
= 1;
6931 for (; j
< num
; j
++)
6934 debug_information
[i
].loc_offsets
[j
]
6935 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6936 && last_view
> debug_information
[i
].loc_views
[j
]))
6941 last_offset
= debug_information
[i
].loc_offsets
[j
];
6942 last_view
= debug_information
[i
].loc_views
[j
];
6947 if (!seen_first_offset
)
6948 error (_("No location lists in .debug_info section!\n"));
6950 if (debug_information
[first
].num_loc_offsets
> 0
6951 && debug_information
[first
].loc_offsets
[0] != expected_start
6952 && debug_information
[first
].loc_views
[0] != expected_start
)
6953 warn (_("Location lists in %s section start at 0x%s\n"),
6955 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6958 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6960 introduce (section
, false);
6962 if (reloc_at (section
, 0))
6963 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6965 printf (_(" Offset Begin End Expression\n"));
6967 seen_first_offset
= 0;
6968 for (i
= first
; i
< num_debug_info_entries
; i
++)
6970 dwarf_vma offset
, voffset
;
6971 dwarf_vma base_address
;
6977 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6979 loc_offsets
= debug_information
[i
].loc_offsets
;
6980 loc_views
= debug_information
[i
].loc_views
;
6981 qsort (array
, debug_information
[i
].num_loc_offsets
,
6982 sizeof (*array
), loc_offsets_compar
);
6985 int adjacent_view_loclists
= 1;
6986 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6988 j
= locs_sorted
? k
: array
[k
];
6990 && (debug_information
[i
].loc_offsets
[locs_sorted
6991 ? k
- 1 : array
[k
- 1]]
6992 == debug_information
[i
].loc_offsets
[j
])
6993 && (debug_information
[i
].loc_views
[locs_sorted
6994 ? k
- 1 : array
[k
- 1]]
6995 == debug_information
[i
].loc_views
[j
]))
6997 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6998 offset
= debug_information
[i
].loc_offsets
[j
];
6999 next
= section_begin
+ offset
;
7000 voffset
= debug_information
[i
].loc_views
[j
];
7002 vnext
= section_begin
+ voffset
;
7005 base_address
= debug_information
[i
].base_address
;
7007 if (vnext
&& vnext
< next
)
7010 display_view_pair_list (section
, &vstart
, i
, next
);
7015 if (!seen_first_offset
|| !adjacent_view_loclists
)
7016 seen_first_offset
= 1;
7020 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
7021 (unsigned long) (start
- section_begin
),
7022 (unsigned long) offset
);
7023 else if (start
> next
)
7024 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
7025 (unsigned long) (start
- section_begin
),
7026 (unsigned long) offset
);
7031 if (offset
>= bytes
)
7033 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
7034 (unsigned long) offset
);
7038 if (vnext
&& voffset
>= bytes
)
7040 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
7041 (unsigned long) voffset
);
7048 display_loc_list_dwo (section
, &start
, i
, offset
,
7049 &vstart
, has_frame_base
);
7051 display_loc_list (section
, &start
, i
, offset
, base_address
,
7052 &vstart
, has_frame_base
);
7057 warn (_("DWO is not yet supported.\n"));
7059 display_loclists_list (section
, &start
, i
, offset
, base_address
,
7060 &vstart
, has_frame_base
);
7063 /* FIXME: this arrangement is quite simplistic. Nothing
7064 requires locview lists to be adjacent to corresponding
7065 loclists, and a single loclist could be augmented by
7066 different locview lists, and vice-versa, unlikely as it
7067 is that it would make sense to do so. Hopefully we'll
7068 have view pair support built into loclists before we ever
7069 need to address all these possibilities. */
7070 if (adjacent_view_loclists
&& vnext
7071 && vnext
!= start
&& vstart
!= next
)
7073 adjacent_view_loclists
= 0;
7074 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7077 if (vnext
&& vnext
== start
)
7078 display_view_pair_list (section
, &start
, i
, vstart
);
7082 if (start
< section
->start
+ section
->size
)
7083 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7084 "There are %ld unused bytes at the end of section %s\n",
7085 (long) (section
->start
+ section
->size
- start
)),
7086 (long) (section
->start
+ section
->size
- start
), section
->name
);
7093 display_debug_str (struct dwarf_section
*section
,
7094 void *file ATTRIBUTE_UNUSED
)
7096 unsigned char *start
= section
->start
;
7097 unsigned long bytes
= section
->size
;
7098 dwarf_vma addr
= section
->address
;
7102 printf (_("\nThe %s section is empty.\n"), section
->name
);
7106 introduce (section
, false);
7114 lbytes
= (bytes
> 16 ? 16 : bytes
);
7116 printf (" 0x%8.8lx ", (unsigned long) addr
);
7118 for (j
= 0; j
< 16; j
++)
7121 printf ("%2.2x", start
[j
]);
7129 for (j
= 0; j
< lbytes
; j
++)
7132 if (k
>= ' ' && k
< 0x80)
7151 display_debug_info (struct dwarf_section
*section
, void *file
)
7153 return process_debug_info (section
, file
, section
->abbrev_sec
, false, false);
7157 display_debug_types (struct dwarf_section
*section
, void *file
)
7159 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7163 display_trace_info (struct dwarf_section
*section
, void *file
)
7165 return process_debug_info (section
, file
, section
->abbrev_sec
, false, true);
7169 display_debug_aranges (struct dwarf_section
*section
,
7170 void *file ATTRIBUTE_UNUSED
)
7172 unsigned char *start
= section
->start
;
7173 unsigned char *end
= start
+ section
->size
;
7175 introduce (section
, false);
7177 /* It does not matter if this load fails,
7178 we test for that later on. */
7179 load_debug_info (file
);
7183 unsigned char *hdrptr
;
7184 DWARF2_Internal_ARange arange
;
7185 unsigned char *addr_ranges
;
7188 unsigned long sec_off
;
7189 unsigned char address_size
;
7191 unsigned int offset_size
;
7192 unsigned char *end_ranges
;
7195 sec_off
= hdrptr
- section
->start
;
7197 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7198 if (arange
.ar_length
== 0xffffffff)
7200 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7206 if (arange
.ar_length
> (size_t) (end
- hdrptr
))
7208 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
7211 dwarf_vmatoa ("x", arange
.ar_length
));
7214 end_ranges
= hdrptr
+ arange
.ar_length
;
7216 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end_ranges
);
7217 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
,
7220 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7221 && num_debug_info_entries
> 0
7222 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7223 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
7224 (unsigned long) arange
.ar_info_offset
, section
->name
);
7226 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end_ranges
);
7227 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end_ranges
);
7229 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7231 /* PR 19872: A version number of 0 probably means that there is
7232 padding at the end of the .debug_aranges section. Gold puts
7233 it there when performing an incremental link, for example.
7234 So do not generate a warning in this case. */
7235 if (arange
.ar_version
)
7236 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7240 printf (_(" Length: %ld\n"),
7241 (long) arange
.ar_length
);
7242 printf (_(" Version: %d\n"), arange
.ar_version
);
7243 printf (_(" Offset into .debug_info: 0x%lx\n"),
7244 (unsigned long) arange
.ar_info_offset
);
7245 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7246 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7248 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7250 /* PR 17512: file: 001-108546-0.001:0.1. */
7251 if (address_size
== 0 || address_size
> 8)
7253 error (_("Invalid address size in %s section!\n"),
7258 /* The DWARF spec does not require that the address size be a power
7259 of two, but we do. This will have to change if we ever encounter
7260 an uneven architecture. */
7261 if ((address_size
& (address_size
- 1)) != 0)
7263 warn (_("Pointer size + Segment size is not a power of two.\n"));
7267 if (address_size
> 4)
7268 printf (_("\n Address Length\n"));
7270 printf (_("\n Address Length\n"));
7272 addr_ranges
= hdrptr
;
7274 /* Must pad to an alignment boundary that is twice the address size. */
7275 excess
= (hdrptr
- start
) % (2 * address_size
);
7277 addr_ranges
+= (2 * address_size
) - excess
;
7281 while (2u * address_size
<= (size_t) (start
- addr_ranges
))
7283 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, start
);
7284 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, start
);
7287 print_dwarf_vma (address
, address_size
);
7288 print_dwarf_vma (length
, address_size
);
7298 /* Comparison function for qsort. */
7300 comp_addr_base (const void * v0
, const void * v1
)
7302 debug_info
*info0
= *(debug_info
**) v0
;
7303 debug_info
*info1
= *(debug_info
**) v1
;
7304 return info0
->addr_base
- info1
->addr_base
;
7307 /* Display the debug_addr section. */
7309 display_debug_addr (struct dwarf_section
*section
,
7312 debug_info
**debug_addr_info
;
7313 unsigned char *entry
;
7317 unsigned char * header
;
7319 if (section
->size
== 0)
7321 printf (_("\nThe %s section is empty.\n"), section
->name
);
7325 if (load_debug_info (file
) == 0)
7327 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7332 introduce (section
, false);
7334 /* PR 17531: file: cf38d01b.
7335 We use xcalloc because a corrupt file may not have initialised all of the
7336 fields in the debug_info structure, which means that the sort below might
7337 try to move uninitialised data. */
7338 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7339 sizeof (debug_info
*));
7342 for (i
= 0; i
< num_debug_info_entries
; i
++)
7343 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7345 /* PR 17531: file: cf38d01b. */
7346 if (debug_information
[i
].addr_base
>= section
->size
)
7347 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
7348 (unsigned long) debug_information
[i
].addr_base
, i
);
7350 debug_addr_info
[count
++] = debug_information
+ i
;
7353 /* Add a sentinel to make iteration convenient. */
7354 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7355 debug_addr_info
[count
]->addr_base
= section
->size
;
7356 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7358 header
= section
->start
;
7359 for (i
= 0; i
< count
; i
++)
7362 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7364 printf (_(" For compilation unit at offset 0x%s:\n"),
7365 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
7367 printf (_("\tIndex\tAddress\n"));
7368 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7369 if (debug_addr_info
[i
]->dwarf_version
>= 5)
7371 size_t header_size
= entry
- header
;
7372 unsigned char * curr_header
= header
;
7375 int segment_selector_size
;
7377 if (header_size
!= 8 && header_size
!= 16)
7379 warn (_("Corrupt %s section: expecting header size of 8 or 16, but found %ld instead\n"),
7380 section
->name
, (long) header_size
);
7384 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 4, entry
);
7385 if (length
== 0xffffffff)
7386 SAFE_BYTE_GET_AND_INC (length
, curr_header
, 8, entry
);
7387 end
= curr_header
+ length
;
7389 SAFE_BYTE_GET_AND_INC (version
, curr_header
, 2, entry
);
7391 warn (_("Corrupt %s section: expecting version number 5 in header but found %d instead\n"),
7392 section
->name
, version
);
7394 SAFE_BYTE_GET_AND_INC (address_size
, curr_header
, 1, entry
);
7395 SAFE_BYTE_GET_AND_INC (segment_selector_size
, curr_header
, 1, entry
);
7396 address_size
+= segment_selector_size
;
7399 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7404 dwarf_vma base
= byte_get (entry
, address_size
);
7405 printf (_("\t%d:\t"), idx
);
7406 print_dwarf_vma (base
, address_size
);
7408 entry
+= address_size
;
7414 free (debug_addr_info
);
7418 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7421 display_debug_str_offsets (struct dwarf_section
*section
,
7422 void *file ATTRIBUTE_UNUSED
)
7426 if (section
->size
== 0)
7428 printf (_("\nThe %s section is empty.\n"), section
->name
);
7432 unsigned char *start
= section
->start
;
7433 unsigned char *end
= start
+ section
->size
;
7434 unsigned char *curr
= start
;
7436 const char *suffix
= strrchr (section
->name
, '.');
7437 bool dwo
= suffix
&& strcmp (suffix
, ".dwo") == 0;
7440 load_debug_section_with_follow (str_dwo
, file
);
7442 load_debug_section_with_follow (str
, file
);
7444 introduce (section
, false);
7449 dwarf_vma entry_length
;
7451 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7452 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7453 if (length
== 0xffffffff)
7455 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
7461 unsigned char *entries_end
;
7464 /* This is probably an old style .debug_str_offset section which
7465 just contains offsets and no header (and the first offset is 0). */
7466 length
= section
->size
;
7467 curr
= section
->start
;
7470 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7471 printf (_(" Index Offset [String]\n"));
7475 if (length
<= (dwarf_vma
) (end
- curr
))
7476 entries_end
= curr
+ length
;
7479 warn (_("Section %s is too small %#lx\n"),
7480 section
->name
, (unsigned long) section
->size
);
7485 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, entries_end
);
7487 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7490 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, entries_end
);
7492 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
7494 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7495 printf (_(" Version: %#lx\n"), (unsigned long) version
);
7496 printf (_(" Index Offset [String]\n"));
7499 for (idx
= 0; curr
< entries_end
; idx
++)
7502 const unsigned char * string
;
7504 if ((dwarf_vma
) (entries_end
- curr
) < entry_length
)
7505 /* Not enough space to read one entry_length, give up. */
7508 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, entries_end
);
7510 string
= (const unsigned char *)
7511 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
7513 string
= fetch_indirect_string (offset
);
7515 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
7523 /* Each debug_information[x].range_lists[y] gets this representation for
7524 sorting purposes. */
7528 /* The debug_information[x].range_lists[y] value. */
7529 dwarf_vma ranges_offset
;
7531 /* Original debug_information to find parameters of the data. */
7532 debug_info
*debug_info_p
;
7535 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7538 range_entry_compar (const void *ap
, const void *bp
)
7540 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7541 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7542 const dwarf_vma a
= a_re
->ranges_offset
;
7543 const dwarf_vma b
= b_re
->ranges_offset
;
7545 return (a
> b
) - (b
> a
);
7549 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
7550 unsigned int pointer_size
, unsigned long offset
,
7551 unsigned long base_address
)
7553 while (start
< finish
)
7558 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7559 if (start
>= finish
)
7561 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7563 printf (" %8.8lx ", offset
);
7565 if (begin
== 0 && end
== 0)
7567 printf (_("<End of list>\n"));
7571 /* Check base address specifiers. */
7572 if (is_max_address (begin
, pointer_size
)
7573 && !is_max_address (end
, pointer_size
))
7576 print_dwarf_vma (begin
, pointer_size
);
7577 print_dwarf_vma (end
, pointer_size
);
7578 printf ("(base address)\n");
7582 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7583 print_dwarf_vma (end
+ base_address
, pointer_size
);
7586 fputs (_("(start == end)"), stdout
);
7587 else if (begin
> end
)
7588 fputs (_("(start > end)"), stdout
);
7595 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7596 unsigned int pointer_size
, unsigned long offset
,
7597 unsigned long base_address
)
7599 unsigned char *next
= start
;
7603 unsigned long off
= offset
+ (start
- next
);
7604 enum dwarf_range_list_entry rlet
;
7605 /* Initialize it due to a false compiler warning. */
7606 dwarf_vma begin
= -1, length
, end
= -1;
7608 if (start
>= finish
)
7610 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7615 printf (" %8.8lx ", off
);
7617 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7621 case DW_RLE_end_of_list
:
7622 printf (_("<End of list>\n"));
7624 case DW_RLE_base_address
:
7625 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7626 print_dwarf_vma (base_address
, pointer_size
);
7627 printf (_("(base address)\n"));
7629 case DW_RLE_start_length
:
7630 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7631 READ_ULEB (length
, start
, finish
);
7632 end
= begin
+ length
;
7634 case DW_RLE_offset_pair
:
7635 READ_ULEB (begin
, start
, finish
);
7636 READ_ULEB (end
, start
, finish
);
7638 case DW_RLE_start_end
:
7639 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7640 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7643 error (_("Invalid range list entry type %d\n"), rlet
);
7644 rlet
= DW_RLE_end_of_list
;
7647 if (rlet
== DW_RLE_end_of_list
)
7649 if (rlet
== DW_RLE_base_address
)
7652 /* Only a DW_RLE_offset_pair needs the base address added. */
7653 if (rlet
== DW_RLE_offset_pair
)
7655 begin
+= base_address
;
7656 end
+= base_address
;
7659 print_dwarf_vma (begin
, pointer_size
);
7660 print_dwarf_vma (end
, pointer_size
);
7663 fputs (_("(start == end)"), stdout
);
7664 else if (begin
> end
)
7665 fputs (_("(start > end)"), stdout
);
7672 display_debug_ranges (struct dwarf_section
*section
,
7673 void *file ATTRIBUTE_UNUSED
)
7675 unsigned char *start
= section
->start
;
7676 unsigned char *last_start
= start
;
7677 unsigned long bytes
= section
->size
;
7678 unsigned char *section_begin
= start
;
7679 unsigned char *finish
= start
+ bytes
;
7680 unsigned int num_range_list
, i
;
7681 struct range_entry
*range_entries
, *range_entry_fill
;
7682 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7683 /* Initialize it due to a false compiler warning. */
7684 unsigned char address_size
= 0;
7685 dwarf_vma last_offset
= 0;
7689 printf (_("\nThe %s section is empty.\n"), section
->name
);
7695 dwarf_vma initial_length
;
7696 unsigned char segment_selector_size
;
7697 unsigned int offset_size
, offset_entry_count
;
7698 unsigned short version
;
7700 /* Get and check the length of the block. */
7701 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7703 if (initial_length
== 0xffffffff)
7705 /* This section is 64-bit DWARF 3. */
7706 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7712 if (initial_length
> (size_t) (finish
- start
))
7714 /* If the length field has a relocation against it, then we should
7715 not complain if it is inaccurate (and probably negative).
7716 It is copied from .debug_line handling code. */
7717 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7719 initial_length
= finish
- start
;
7723 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7724 (long) initial_length
);
7728 finish
= start
+ initial_length
;
7730 /* Get and check the version number. */
7731 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7735 warn (_("Only DWARF version 5 debug_rnglists info "
7736 "is currently supported.\n"));
7740 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7742 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7743 if (segment_selector_size
!= 0)
7745 warn (_("The %s section contains "
7746 "unsupported segment selector size: %d.\n"),
7747 section
->name
, segment_selector_size
);
7751 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7752 if (offset_entry_count
!= 0)
7754 warn (_("The %s section contains "
7755 "unsupported offset entry count: %u.\n"),
7756 section
->name
, offset_entry_count
);
7761 if (load_debug_info (file
) == 0)
7763 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7769 for (i
= 0; i
< num_debug_info_entries
; i
++)
7771 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7772 /* Skip .debug_rnglists reference. */
7774 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7775 /* Skip .debug_range reference. */
7777 num_range_list
+= debug_information
[i
].num_range_lists
;
7780 if (num_range_list
== 0)
7782 /* This can happen when the file was compiled with -gsplit-debug
7783 which removes references to range lists from the primary .o file. */
7784 printf (_("No range lists in .debug_info section.\n"));
7788 range_entries
= (struct range_entry
*)
7789 xmalloc (sizeof (*range_entries
) * num_range_list
);
7790 range_entry_fill
= range_entries
;
7792 for (i
= 0; i
< num_debug_info_entries
; i
++)
7794 debug_info
*debug_info_p
= &debug_information
[i
];
7797 if (debug_information
[i
].dwarf_version
< 5 && is_rnglists
)
7798 /* Skip .debug_rnglists reference. */
7800 if (debug_information
[i
].dwarf_version
>= 5 && !is_rnglists
)
7801 /* Skip .debug_range reference. */
7804 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7806 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7807 range_entry_fill
->debug_info_p
= debug_info_p
;
7812 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7813 range_entry_compar
);
7815 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7816 warn (_("Range lists in %s section start at 0x%lx\n"),
7817 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7819 introduce (section
, false);
7821 printf (_(" Offset Begin End\n"));
7823 for (i
= 0; i
< num_range_list
; i
++)
7825 struct range_entry
*range_entry
= &range_entries
[i
];
7826 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7827 unsigned int pointer_size
;
7829 unsigned char *next
;
7830 dwarf_vma base_address
;
7832 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7833 offset
= range_entry
->ranges_offset
;
7834 base_address
= debug_info_p
->base_address
;
7836 /* PR 17512: file: 001-101485-0.001:0.1. */
7837 if (pointer_size
< 2 || pointer_size
> 8)
7839 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7840 pointer_size
, (unsigned long) offset
);
7844 if (offset
> (size_t) (finish
- section_begin
))
7846 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7847 (unsigned long) offset
, i
);
7850 next
= section_begin
+ offset
;
7852 /* If multiple DWARF entities reference the same range then we will
7853 have multiple entries in the `range_entries' list for the same
7854 offset. Thanks to the sort above these will all be consecutive in
7855 the `range_entries' list, so we can easily ignore duplicates
7857 if (i
> 0 && last_offset
== offset
)
7859 last_offset
= offset
;
7861 if (dwarf_check
!= 0 && i
> 0)
7864 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7865 (unsigned long) (start
- section_begin
),
7866 (unsigned long) (next
- section_begin
), section
->name
);
7867 else if (start
> next
)
7869 if (next
== last_start
)
7871 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7872 (unsigned long) (start
- section_begin
),
7873 (unsigned long) (next
- section_begin
), section
->name
);
7880 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7881 (start
, finish
, pointer_size
, offset
, base_address
);
7885 free (range_entries
);
7890 typedef struct Frame_Chunk
7892 struct Frame_Chunk
*next
;
7893 unsigned char *chunk_start
;
7895 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7896 short int *col_type
;
7899 unsigned int code_factor
;
7903 unsigned int cfa_reg
;
7904 dwarf_vma cfa_offset
;
7906 unsigned char fde_encoding
;
7907 unsigned char cfa_exp
;
7908 unsigned char ptr_size
;
7909 unsigned char segment_size
;
7913 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7914 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7915 static const char *const *dwarf_regnames
;
7916 static unsigned int dwarf_regnames_count
;
7919 /* A marker for a col_type that means this column was never referenced
7920 in the frame info. */
7921 #define DW_CFA_unreferenced (-1)
7923 /* Return 0 if no more space is needed, 1 if more space is needed,
7924 -1 for invalid reg. */
7927 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7929 unsigned int prev
= fc
->ncols
;
7931 if (reg
< (unsigned int) fc
->ncols
)
7934 if (dwarf_regnames_count
> 0
7935 && reg
> dwarf_regnames_count
)
7938 fc
->ncols
= reg
+ 1;
7939 /* PR 17512: file: 10450-2643-0.004.
7940 If reg == -1 then this can happen... */
7944 /* PR 17512: file: 2844a11d. */
7945 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7947 error (_("Unfeasibly large register number: %u\n"), reg
);
7949 /* FIXME: 1024 is an arbitrary limit. Increase it if
7950 we ever encounter a valid binary that exceeds it. */
7954 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7955 sizeof (short int));
7956 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7957 /* PR 17512: file:002-10025-0.005. */
7958 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7960 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7966 while (prev
< fc
->ncols
)
7968 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7969 fc
->col_offset
[prev
] = 0;
7975 static const char *const dwarf_regnames_i386
[] =
7977 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7978 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7979 "eip", "eflags", NULL
, /* 8 - 10 */
7980 "st0", "st1", "st2", "st3", /* 11 - 14 */
7981 "st4", "st5", "st6", "st7", /* 15 - 18 */
7982 NULL
, NULL
, /* 19 - 20 */
7983 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7984 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7985 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7986 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7987 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7988 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7989 "tr", "ldtr", /* 48 - 49 */
7990 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7991 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7992 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7993 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7994 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7995 NULL
, NULL
, NULL
, /* 90 - 92 */
7996 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7999 static const char *const dwarf_regnames_iamcu
[] =
8001 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
8002 "esp", "ebp", "esi", "edi", /* 4 - 7 */
8003 "eip", "eflags", NULL
, /* 8 - 10 */
8004 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
8005 NULL
, NULL
, /* 19 - 20 */
8006 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
8007 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
8008 NULL
, NULL
, NULL
, /* 37 - 39 */
8009 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
8010 "tr", "ldtr", /* 48 - 49 */
8011 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
8012 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
8013 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
8014 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
8015 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
8016 NULL
, NULL
, NULL
, /* 90 - 92 */
8017 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
8021 init_dwarf_regnames_i386 (void)
8023 dwarf_regnames
= dwarf_regnames_i386
;
8024 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
8025 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8029 init_dwarf_regnames_iamcu (void)
8031 dwarf_regnames
= dwarf_regnames_iamcu
;
8032 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
8033 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8036 static const char *const dwarf_regnames_x86_64
[] =
8038 "rax", "rdx", "rcx", "rbx",
8039 "rsi", "rdi", "rbp", "rsp",
8040 "r8", "r9", "r10", "r11",
8041 "r12", "r13", "r14", "r15",
8043 "xmm0", "xmm1", "xmm2", "xmm3",
8044 "xmm4", "xmm5", "xmm6", "xmm7",
8045 "xmm8", "xmm9", "xmm10", "xmm11",
8046 "xmm12", "xmm13", "xmm14", "xmm15",
8047 "st0", "st1", "st2", "st3",
8048 "st4", "st5", "st6", "st7",
8049 "mm0", "mm1", "mm2", "mm3",
8050 "mm4", "mm5", "mm6", "mm7",
8052 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
8053 "fs.base", "gs.base", NULL
, NULL
,
8055 "mxcsr", "fcw", "fsw",
8056 "xmm16", "xmm17", "xmm18", "xmm19",
8057 "xmm20", "xmm21", "xmm22", "xmm23",
8058 "xmm24", "xmm25", "xmm26", "xmm27",
8059 "xmm28", "xmm29", "xmm30", "xmm31",
8060 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
8061 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
8062 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
8063 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
8064 NULL
, NULL
, NULL
, /* 115 - 117 */
8065 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
8069 init_dwarf_regnames_x86_64 (void)
8071 dwarf_regnames
= dwarf_regnames_x86_64
;
8072 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
8073 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8076 static const char *const dwarf_regnames_aarch64
[] =
8078 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
8079 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
8080 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
8081 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
8082 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8083 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
8084 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
8085 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
8086 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
8087 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
8088 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
8089 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
8090 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
8091 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
8092 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
8093 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
8097 init_dwarf_regnames_aarch64 (void)
8099 dwarf_regnames
= dwarf_regnames_aarch64
;
8100 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
8101 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8104 static const char *const dwarf_regnames_s390
[] =
8106 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
8107 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8108 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
8109 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
8110 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
8111 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
8112 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
8113 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
8114 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
8117 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
8118 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
8122 init_dwarf_regnames_s390 (void)
8124 dwarf_regnames
= dwarf_regnames_s390
;
8125 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
8126 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8129 static const char *const dwarf_regnames_riscv
[] =
8131 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8132 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8133 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8134 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8135 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8136 "fs0", "fs1", /* 40 - 41 */
8137 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8138 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8139 "fs10", "fs11", /* 58 - 59 */
8140 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8143 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8144 the large number of CSRs. */
8147 regname_internal_riscv (unsigned int regno
)
8149 const char *name
= NULL
;
8151 /* Lookup in the table first, this covers GPR and FPR. */
8152 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8153 name
= dwarf_regnames_riscv
[regno
];
8154 else if (regno
>= 4096 && regno
<= 8191)
8156 /* This might be a CSR, these live in a sparse number space from 4096
8157 to 8191 These numbers are defined in the RISC-V ELF ABI
8161 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8162 case VALUE + 4096: name = #NAME; break;
8163 #include "opcode/riscv-opc.h"
8168 static char csr_name
[10];
8169 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8180 init_dwarf_regnames_riscv (void)
8182 dwarf_regnames
= NULL
;
8183 dwarf_regnames_count
= 8192;
8184 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8188 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8190 dwarf_regnames_lookup_func
= NULL
;
8195 init_dwarf_regnames_i386 ();
8199 init_dwarf_regnames_iamcu ();
8205 init_dwarf_regnames_x86_64 ();
8209 init_dwarf_regnames_aarch64 ();
8213 init_dwarf_regnames_s390 ();
8217 init_dwarf_regnames_riscv ();
8225 /* Initialize the DWARF register name lookup state based on the
8226 architecture and specific machine type of a BFD. */
8229 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8232 dwarf_regnames_lookup_func
= NULL
;
8239 case bfd_mach_x86_64
:
8240 case bfd_mach_x86_64_intel_syntax
:
8241 case bfd_mach_x64_32
:
8242 case bfd_mach_x64_32_intel_syntax
:
8243 init_dwarf_regnames_x86_64 ();
8247 init_dwarf_regnames_i386 ();
8252 case bfd_arch_iamcu
:
8253 init_dwarf_regnames_iamcu ();
8256 case bfd_arch_aarch64
:
8257 init_dwarf_regnames_aarch64();
8261 init_dwarf_regnames_s390 ();
8264 case bfd_arch_riscv
:
8265 init_dwarf_regnames_riscv ();
8274 regname_internal_by_table_only (unsigned int regno
)
8276 if (dwarf_regnames
!= NULL
8277 && regno
< dwarf_regnames_count
8278 && dwarf_regnames
[regno
] != NULL
)
8279 return dwarf_regnames
[regno
];
8285 regname (unsigned int regno
, int name_only_p
)
8287 static char reg
[64];
8289 const char *name
= NULL
;
8291 if (dwarf_regnames_lookup_func
!= NULL
)
8292 name
= dwarf_regnames_lookup_func (regno
);
8298 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8301 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8306 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8311 if (*max_regs
!= fc
->ncols
)
8312 *max_regs
= fc
->ncols
;
8314 if (*need_col_headers
)
8316 *need_col_headers
= 0;
8318 printf ("%-*s CFA ", eh_addr_size
* 2, " LOC");
8320 for (r
= 0; r
< *max_regs
; r
++)
8321 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8326 printf ("%-5s ", regname (r
, 1));
8332 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
8334 strcpy (tmp
, "exp");
8336 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8337 printf ("%-8s ", tmp
);
8339 for (r
= 0; r
< fc
->ncols
; r
++)
8341 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8343 switch (fc
->col_type
[r
])
8345 case DW_CFA_undefined
:
8348 case DW_CFA_same_value
:
8352 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8354 case DW_CFA_val_offset
:
8355 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8357 case DW_CFA_register
:
8358 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8360 case DW_CFA_expression
:
8361 strcpy (tmp
, "exp");
8363 case DW_CFA_val_expression
:
8364 strcpy (tmp
, "vexp");
8367 strcpy (tmp
, "n/a");
8370 printf ("%-5s ", tmp
);
8376 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8378 static unsigned char *
8379 read_cie (unsigned char *start
, unsigned char *end
,
8380 Frame_Chunk
**p_cie
, int *p_version
,
8381 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
8385 unsigned char *augmentation_data
= NULL
;
8386 bfd_size_type augmentation_data_len
= 0;
8389 /* PR 17512: file: 001-228113-0.004. */
8393 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8394 memset (fc
, 0, sizeof (Frame_Chunk
));
8396 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8397 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8401 fc
->augmentation
= (char *) start
;
8402 /* PR 17512: file: 001-228113-0.004.
8403 Skip past augmentation name, but avoid running off the end of the data. */
8405 if (* start
++ == '\0')
8409 warn (_("No terminator for augmentation name\n"));
8413 if (strcmp (fc
->augmentation
, "eh") == 0)
8415 if (eh_addr_size
> (size_t) (end
- start
))
8417 start
+= eh_addr_size
;
8422 if (2 > (size_t) (end
- start
))
8424 GET (fc
->ptr_size
, 1);
8425 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8427 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8431 GET (fc
->segment_size
, 1);
8432 /* PR 17512: file: e99d2804. */
8433 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8435 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8439 eh_addr_size
= fc
->ptr_size
;
8443 fc
->ptr_size
= eh_addr_size
;
8444 fc
->segment_size
= 0;
8447 READ_ULEB (fc
->code_factor
, start
, end
);
8448 READ_SLEB (fc
->data_factor
, start
, end
);
8459 READ_ULEB (fc
->ra
, start
, end
);
8462 if (fc
->augmentation
[0] == 'z')
8466 READ_ULEB (augmentation_data_len
, start
, end
);
8467 augmentation_data
= start
;
8468 /* PR 17512: file: 11042-2589-0.004. */
8469 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8471 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
8472 dwarf_vmatoa ("x", augmentation_data_len
),
8473 (unsigned long) (end
- start
));
8476 start
+= augmentation_data_len
;
8479 if (augmentation_data_len
)
8483 unsigned char *qend
;
8485 p
= (unsigned char *) fc
->augmentation
+ 1;
8486 q
= augmentation_data
;
8487 qend
= q
+ augmentation_data_len
;
8489 while (p
< end
&& q
< qend
)
8494 q
+= 1 + size_of_encoded_value (*q
);
8496 fc
->fde_encoding
= *q
++;
8505 /* Note - it is OK if this loop terminates with q < qend.
8506 Padding may have been inserted to align the end of the CIE. */
8511 *p_version
= version
;
8514 *p_aug_len
= augmentation_data_len
;
8515 *p_aug
= augmentation_data
;
8520 free (fc
->col_offset
);
8521 free (fc
->col_type
);
8526 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8527 If do_wide is not enabled, then formats the output to fit into 80 columns.
8528 PRINTED contains the number of characters already written to the current
8532 display_data (bfd_size_type printed
,
8533 const unsigned char * data
,
8534 const bfd_size_type len
)
8536 if (do_wide
|| len
< ((80 - printed
) / 3))
8537 for (printed
= 0; printed
< len
; ++printed
)
8538 printf (" %02x", data
[printed
]);
8541 for (printed
= 0; printed
< len
; ++printed
)
8543 if (printed
% (80 / 3) == 0)
8545 printf (" %02x", data
[printed
]);
8550 /* Prints out the contents on the augmentation data array.
8551 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8554 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
8558 i
= printf (_(" Augmentation data: "));
8559 display_data (i
, data
, len
);
8563 display_debug_frames (struct dwarf_section
*section
,
8564 void *file ATTRIBUTE_UNUSED
)
8566 unsigned char *start
= section
->start
;
8567 unsigned char *end
= start
+ section
->size
;
8568 unsigned char *section_start
= start
;
8569 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8570 Frame_Chunk
*remembered_state
= NULL
;
8572 bool is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8573 unsigned int max_regs
= 0;
8574 const char *bad_reg
= _("bad register: ");
8575 unsigned int saved_eh_addr_size
= eh_addr_size
;
8577 introduce (section
, false);
8581 unsigned char *saved_start
;
8582 unsigned char *block_end
;
8587 int need_col_headers
= 1;
8588 unsigned char *augmentation_data
= NULL
;
8589 bfd_size_type augmentation_data_len
= 0;
8590 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8591 unsigned int offset_size
;
8593 static Frame_Chunk fde_fc
;
8595 saved_start
= start
;
8597 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8601 printf ("\n%08lx ZERO terminator\n\n",
8602 (unsigned long)(saved_start
- section_start
));
8603 /* Skip any zero terminators that directly follow.
8604 A corrupt section size could have loaded a whole
8605 slew of zero filled memory bytes. eg
8606 PR 17512: file: 070-19381-0.004. */
8607 while (start
< end
&& * start
== 0)
8612 if (length
== 0xffffffff)
8614 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8620 if (length
> (size_t) (end
- start
))
8622 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8623 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8624 (unsigned long) (saved_start
- section_start
));
8628 block_end
= start
+ length
;
8630 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, block_end
);
8632 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8633 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8638 start
= read_cie (start
, block_end
, &cie
, &version
,
8639 &augmentation_data_len
, &augmentation_data
);
8640 /* PR 17512: file: 027-135133-0.005. */
8647 fc
->chunk_start
= saved_start
;
8648 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8651 if (frame_need_space (fc
, mreg
) < 0)
8653 if (fc
->fde_encoding
)
8654 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8656 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8657 print_dwarf_vma (length
, fc
->ptr_size
);
8658 print_dwarf_vma (cie_id
, offset_size
);
8660 if (do_debug_frames_interp
)
8662 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8663 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8668 printf (" Version: %d\n", version
);
8669 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8672 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8673 printf (" Segment Size: %u\n", fc
->segment_size
);
8675 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8676 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8677 printf (" Return address column: %d\n", fc
->ra
);
8679 if (augmentation_data_len
)
8680 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8687 unsigned char *look_for
;
8688 unsigned long segment_selector
;
8694 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8695 cie_off
= (cie_off
^ sign
) - sign
;
8696 cie_off
= start
- 4 - section_start
- cie_off
;
8699 look_for
= section_start
+ cie_off
;
8700 if (cie_off
<= (dwarf_vma
) (saved_start
- section_start
))
8702 for (cie
= chunks
; cie
; cie
= cie
->next
)
8703 if (cie
->chunk_start
== look_for
)
8706 else if (cie_off
>= section
->size
)
8710 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8711 if (cie
->chunk_start
== look_for
)
8715 unsigned int off_size
;
8716 unsigned char *cie_scan
;
8718 cie_scan
= look_for
;
8720 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8721 if (length
== 0xffffffff)
8723 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8726 if (length
!= 0 && length
<= (size_t) (end
- cie_scan
))
8729 unsigned char *cie_end
= cie_scan
+ length
;
8731 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
,
8735 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8736 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8741 read_cie (cie_scan
, cie_end
, &cie
, &version
,
8742 &augmentation_data_len
, &augmentation_data
);
8743 /* PR 17512: file: 3450-2098-0.004. */
8746 warn (_("Failed to read CIE information\n"));
8749 cie
->next
= forward_refs
;
8751 cie
->chunk_start
= look_for
;
8752 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8755 if (frame_need_space (cie
, mreg
) < 0)
8757 warn (_("Invalid max register\n"));
8760 if (cie
->fde_encoding
)
8762 = size_of_encoded_value (cie
->fde_encoding
);
8769 memset (fc
, 0, sizeof (Frame_Chunk
));
8773 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8774 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8775 (unsigned long) (saved_start
- section_start
));
8777 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8778 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8779 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8781 warn (_("Invalid max register\n"));
8785 fc
->augmentation
= "";
8786 fc
->fde_encoding
= 0;
8787 fc
->ptr_size
= eh_addr_size
;
8788 fc
->segment_size
= 0;
8792 fc
->ncols
= cie
->ncols
;
8793 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8794 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8795 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8796 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8797 fc
->augmentation
= cie
->augmentation
;
8798 fc
->ptr_size
= cie
->ptr_size
;
8799 eh_addr_size
= cie
->ptr_size
;
8800 fc
->segment_size
= cie
->segment_size
;
8801 fc
->code_factor
= cie
->code_factor
;
8802 fc
->data_factor
= cie
->data_factor
;
8803 fc
->cfa_reg
= cie
->cfa_reg
;
8804 fc
->cfa_offset
= cie
->cfa_offset
;
8806 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8808 warn (_("Invalid max register\n"));
8811 fc
->fde_encoding
= cie
->fde_encoding
;
8814 if (fc
->fde_encoding
)
8815 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8817 segment_selector
= 0;
8818 if (fc
->segment_size
)
8820 if (fc
->segment_size
> sizeof (segment_selector
))
8822 /* PR 17512: file: 9e196b3e. */
8823 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8824 fc
->segment_size
= 4;
8826 SAFE_BYTE_GET_AND_INC (segment_selector
, start
,
8827 fc
->segment_size
, block_end
);
8830 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
8833 /* FIXME: It appears that sometimes the final pc_range value is
8834 encoded in less than encoded_ptr_size bytes. See the x86_64
8835 run of the "objcopy on compressed debug sections" test for an
8837 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
,
8840 if (cie
->augmentation
[0] == 'z')
8842 READ_ULEB (augmentation_data_len
, start
, block_end
);
8843 augmentation_data
= start
;
8844 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8845 if (augmentation_data_len
> (bfd_size_type
) (block_end
- start
))
8847 warn (_("Augmentation data too long: 0x%s, "
8848 "expected at most %#lx\n"),
8849 dwarf_vmatoa ("x", augmentation_data_len
),
8850 (unsigned long) (block_end
- start
));
8852 augmentation_data
= NULL
;
8853 augmentation_data_len
= 0;
8855 start
+= augmentation_data_len
;
8858 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8859 (unsigned long)(saved_start
- section_start
),
8860 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8861 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8862 (unsigned long)(cie
->chunk_start
- section_start
));
8864 if (fc
->segment_size
)
8865 printf ("%04lx:", segment_selector
);
8868 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8869 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8871 if (! do_debug_frames_interp
&& augmentation_data_len
)
8873 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8878 /* At this point, fc is the current chunk, cie (if any) is set, and
8879 we're about to interpret instructions for the chunk. */
8880 /* ??? At present we need to do this always, since this sizes the
8881 fc->col_type and fc->col_offset arrays, which we write into always.
8882 We should probably split the interpreted and non-interpreted bits
8883 into two different routines, since there's so much that doesn't
8884 really overlap between them. */
8885 if (1 || do_debug_frames_interp
)
8887 /* Start by making a pass over the chunk, allocating storage
8888 and taking note of what registers are used. */
8889 unsigned char *tmp
= start
;
8891 while (start
< block_end
)
8893 unsigned int reg
, op
, opa
;
8901 /* Warning: if you add any more cases to this switch, be
8902 sure to add them to the corresponding switch below. */
8905 case DW_CFA_advance_loc
:
8908 SKIP_ULEB (start
, block_end
);
8909 if (frame_need_space (fc
, opa
) >= 0)
8910 fc
->col_type
[opa
] = DW_CFA_undefined
;
8912 case DW_CFA_restore
:
8913 if (frame_need_space (fc
, opa
) >= 0)
8914 fc
->col_type
[opa
] = DW_CFA_undefined
;
8916 case DW_CFA_set_loc
:
8917 if ((size_t) (block_end
- start
) < encoded_ptr_size
)
8920 start
+= encoded_ptr_size
;
8922 case DW_CFA_advance_loc1
:
8923 if ((size_t) (block_end
- start
) < 1)
8928 case DW_CFA_advance_loc2
:
8929 if ((size_t) (block_end
- start
) < 2)
8934 case DW_CFA_advance_loc4
:
8935 if ((size_t) (block_end
- start
) < 4)
8940 case DW_CFA_offset_extended
:
8941 case DW_CFA_val_offset
:
8942 READ_ULEB (reg
, start
, block_end
);
8943 SKIP_ULEB (start
, block_end
);
8944 if (frame_need_space (fc
, reg
) >= 0)
8945 fc
->col_type
[reg
] = DW_CFA_undefined
;
8947 case DW_CFA_restore_extended
:
8948 READ_ULEB (reg
, start
, block_end
);
8949 if (frame_need_space (fc
, reg
) >= 0)
8950 fc
->col_type
[reg
] = DW_CFA_undefined
;
8952 case DW_CFA_undefined
:
8953 READ_ULEB (reg
, start
, block_end
);
8954 if (frame_need_space (fc
, reg
) >= 0)
8955 fc
->col_type
[reg
] = DW_CFA_undefined
;
8957 case DW_CFA_same_value
:
8958 READ_ULEB (reg
, start
, block_end
);
8959 if (frame_need_space (fc
, reg
) >= 0)
8960 fc
->col_type
[reg
] = DW_CFA_undefined
;
8962 case DW_CFA_register
:
8963 READ_ULEB (reg
, start
, block_end
);
8964 SKIP_ULEB (start
, block_end
);
8965 if (frame_need_space (fc
, reg
) >= 0)
8966 fc
->col_type
[reg
] = DW_CFA_undefined
;
8968 case DW_CFA_def_cfa
:
8969 SKIP_ULEB (start
, block_end
);
8970 SKIP_ULEB (start
, block_end
);
8972 case DW_CFA_def_cfa_register
:
8973 SKIP_ULEB (start
, block_end
);
8975 case DW_CFA_def_cfa_offset
:
8976 SKIP_ULEB (start
, block_end
);
8978 case DW_CFA_def_cfa_expression
:
8979 READ_ULEB (temp
, start
, block_end
);
8980 if ((size_t) (block_end
- start
) < temp
)
8985 case DW_CFA_expression
:
8986 case DW_CFA_val_expression
:
8987 READ_ULEB (reg
, start
, block_end
);
8988 READ_ULEB (temp
, start
, block_end
);
8989 if ((size_t) (block_end
- start
) < temp
)
8993 if (frame_need_space (fc
, reg
) >= 0)
8994 fc
->col_type
[reg
] = DW_CFA_undefined
;
8996 case DW_CFA_offset_extended_sf
:
8997 case DW_CFA_val_offset_sf
:
8998 READ_ULEB (reg
, start
, block_end
);
8999 SKIP_SLEB (start
, block_end
);
9000 if (frame_need_space (fc
, reg
) >= 0)
9001 fc
->col_type
[reg
] = DW_CFA_undefined
;
9003 case DW_CFA_def_cfa_sf
:
9004 SKIP_ULEB (start
, block_end
);
9005 SKIP_SLEB (start
, block_end
);
9007 case DW_CFA_def_cfa_offset_sf
:
9008 SKIP_SLEB (start
, block_end
);
9010 case DW_CFA_MIPS_advance_loc8
:
9011 if ((size_t) (block_end
- start
) < 8)
9016 case DW_CFA_GNU_args_size
:
9017 SKIP_ULEB (start
, block_end
);
9019 case DW_CFA_GNU_negative_offset_extended
:
9020 READ_ULEB (reg
, start
, block_end
);
9021 SKIP_ULEB (start
, block_end
);
9022 if (frame_need_space (fc
, reg
) >= 0)
9023 fc
->col_type
[reg
] = DW_CFA_undefined
;
9034 /* Now we know what registers are used, make a second pass over
9035 the chunk, this time actually printing out the info. */
9037 while (start
< block_end
)
9040 unsigned long ul
, roffs
;
9041 /* Note: It is tempting to use an unsigned long for 'reg' but there
9042 are various functions, notably frame_space_needed() that assume that
9043 reg is an unsigned int. */
9048 const char *reg_prefix
= "";
9055 /* Make a note if something other than DW_CFA_nop happens. */
9056 if (op
!= DW_CFA_nop
)
9059 /* Warning: if you add any more cases to this switch, be
9060 sure to add them to the corresponding switch above. */
9063 case DW_CFA_advance_loc
:
9064 if (do_debug_frames_interp
)
9065 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9067 printf (" DW_CFA_advance_loc: %d to %s\n",
9068 opa
* fc
->code_factor
,
9069 dwarf_vmatoa_1 (NULL
,
9070 fc
->pc_begin
+ opa
* fc
->code_factor
,
9072 fc
->pc_begin
+= opa
* fc
->code_factor
;
9076 READ_ULEB (roffs
, start
, block_end
);
9077 if (opa
>= (unsigned int) fc
->ncols
)
9078 reg_prefix
= bad_reg
;
9079 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9080 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
9081 reg_prefix
, regname (opa
, 0),
9082 roffs
* fc
->data_factor
);
9083 if (*reg_prefix
== '\0')
9085 fc
->col_type
[opa
] = DW_CFA_offset
;
9086 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9090 case DW_CFA_restore
:
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_restore: %s%s\n",
9095 reg_prefix
, regname (opa
, 0));
9096 if (*reg_prefix
!= '\0')
9099 if (opa
>= (unsigned int) cie
->ncols
9100 || (do_debug_frames_interp
9101 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
9103 fc
->col_type
[opa
] = DW_CFA_undefined
;
9104 fc
->col_offset
[opa
] = 0;
9108 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9109 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9113 case DW_CFA_set_loc
:
9114 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
,
9116 if (do_debug_frames_interp
)
9117 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9119 printf (" DW_CFA_set_loc: %s\n",
9120 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
9124 case DW_CFA_advance_loc1
:
9125 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, block_end
);
9126 if (do_debug_frames_interp
)
9127 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9129 printf (" DW_CFA_advance_loc1: %ld to %s\n",
9130 (unsigned long) (ofs
* fc
->code_factor
),
9131 dwarf_vmatoa_1 (NULL
,
9132 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9134 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9137 case DW_CFA_advance_loc2
:
9138 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
9139 if (do_debug_frames_interp
)
9140 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9142 printf (" DW_CFA_advance_loc2: %ld to %s\n",
9143 (unsigned long) (ofs
* fc
->code_factor
),
9144 dwarf_vmatoa_1 (NULL
,
9145 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9147 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9150 case DW_CFA_advance_loc4
:
9151 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9152 if (do_debug_frames_interp
)
9153 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9155 printf (" DW_CFA_advance_loc4: %ld to %s\n",
9156 (unsigned long) (ofs
* fc
->code_factor
),
9157 dwarf_vmatoa_1 (NULL
,
9158 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9160 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9163 case DW_CFA_offset_extended
:
9164 READ_ULEB (reg
, start
, block_end
);
9165 READ_ULEB (roffs
, start
, block_end
);
9166 if (reg
>= (unsigned int) fc
->ncols
)
9167 reg_prefix
= bad_reg
;
9168 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9169 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9170 reg_prefix
, regname (reg
, 0),
9171 roffs
* fc
->data_factor
);
9172 if (*reg_prefix
== '\0')
9174 fc
->col_type
[reg
] = DW_CFA_offset
;
9175 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9179 case DW_CFA_val_offset
:
9180 READ_ULEB (reg
, start
, block_end
);
9181 READ_ULEB (roffs
, start
, block_end
);
9182 if (reg
>= (unsigned int) fc
->ncols
)
9183 reg_prefix
= bad_reg
;
9184 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9185 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9186 reg_prefix
, regname (reg
, 0),
9187 roffs
* fc
->data_factor
);
9188 if (*reg_prefix
== '\0')
9190 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9191 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9195 case DW_CFA_restore_extended
:
9196 READ_ULEB (reg
, start
, block_end
);
9197 if (reg
>= (unsigned int) fc
->ncols
)
9198 reg_prefix
= bad_reg
;
9199 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9200 printf (" DW_CFA_restore_extended: %s%s\n",
9201 reg_prefix
, regname (reg
, 0));
9202 if (*reg_prefix
!= '\0')
9205 if (reg
>= (unsigned int) cie
->ncols
)
9207 fc
->col_type
[reg
] = DW_CFA_undefined
;
9208 fc
->col_offset
[reg
] = 0;
9212 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9213 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9217 case DW_CFA_undefined
:
9218 READ_ULEB (reg
, start
, block_end
);
9219 if (reg
>= (unsigned int) fc
->ncols
)
9220 reg_prefix
= bad_reg
;
9221 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9222 printf (" DW_CFA_undefined: %s%s\n",
9223 reg_prefix
, regname (reg
, 0));
9224 if (*reg_prefix
== '\0')
9226 fc
->col_type
[reg
] = DW_CFA_undefined
;
9227 fc
->col_offset
[reg
] = 0;
9231 case DW_CFA_same_value
:
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_same_value: %s%s\n",
9237 reg_prefix
, regname (reg
, 0));
9238 if (*reg_prefix
== '\0')
9240 fc
->col_type
[reg
] = DW_CFA_same_value
;
9241 fc
->col_offset
[reg
] = 0;
9245 case DW_CFA_register
:
9246 READ_ULEB (reg
, start
, block_end
);
9247 READ_ULEB (roffs
, start
, block_end
);
9248 if (reg
>= (unsigned int) fc
->ncols
)
9249 reg_prefix
= bad_reg
;
9250 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9252 printf (" DW_CFA_register: %s%s in ",
9253 reg_prefix
, regname (reg
, 0));
9254 puts (regname (roffs
, 0));
9256 if (*reg_prefix
== '\0')
9258 fc
->col_type
[reg
] = DW_CFA_register
;
9259 fc
->col_offset
[reg
] = roffs
;
9263 case DW_CFA_remember_state
:
9264 if (! do_debug_frames_interp
)
9265 printf (" DW_CFA_remember_state\n");
9266 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9267 rs
->cfa_offset
= fc
->cfa_offset
;
9268 rs
->cfa_reg
= fc
->cfa_reg
;
9270 rs
->cfa_exp
= fc
->cfa_exp
;
9271 rs
->ncols
= fc
->ncols
;
9272 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9273 sizeof (* rs
->col_type
));
9274 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9275 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9276 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9277 rs
->next
= remembered_state
;
9278 remembered_state
= rs
;
9281 case DW_CFA_restore_state
:
9282 if (! do_debug_frames_interp
)
9283 printf (" DW_CFA_restore_state\n");
9284 rs
= remembered_state
;
9287 remembered_state
= rs
->next
;
9288 fc
->cfa_offset
= rs
->cfa_offset
;
9289 fc
->cfa_reg
= rs
->cfa_reg
;
9291 fc
->cfa_exp
= rs
->cfa_exp
;
9292 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9294 warn (_("Invalid column number in saved frame state\n"));
9298 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9299 memcpy (fc
->col_offset
, rs
->col_offset
,
9300 rs
->ncols
* sizeof (* rs
->col_offset
));
9301 free (rs
->col_type
);
9302 free (rs
->col_offset
);
9305 else if (do_debug_frames_interp
)
9306 printf ("Mismatched DW_CFA_restore_state\n");
9309 case DW_CFA_def_cfa
:
9310 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9311 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9313 if (! do_debug_frames_interp
)
9314 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9315 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9318 case DW_CFA_def_cfa_register
:
9319 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9321 if (! do_debug_frames_interp
)
9322 printf (" DW_CFA_def_cfa_register: %s\n",
9323 regname (fc
->cfa_reg
, 0));
9326 case DW_CFA_def_cfa_offset
:
9327 READ_ULEB (fc
->cfa_offset
, start
, block_end
);
9328 if (! do_debug_frames_interp
)
9329 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9333 if (! do_debug_frames_interp
)
9334 printf (" DW_CFA_nop\n");
9337 case DW_CFA_def_cfa_expression
:
9338 READ_ULEB (ul
, start
, block_end
);
9339 if (ul
> (size_t) (block_end
- start
))
9341 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9344 if (! do_debug_frames_interp
)
9346 printf (" DW_CFA_def_cfa_expression (");
9347 decode_location_expression (start
, eh_addr_size
, 0, -1,
9355 case DW_CFA_expression
:
9356 READ_ULEB (reg
, start
, block_end
);
9357 READ_ULEB (ul
, start
, block_end
);
9358 if (reg
>= (unsigned int) fc
->ncols
)
9359 reg_prefix
= bad_reg
;
9360 /* PR 17512: file: 069-133014-0.006. */
9361 /* PR 17512: file: 98c02eb4. */
9362 if (ul
> (size_t) (block_end
- start
))
9364 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9367 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9369 printf (" DW_CFA_expression: %s%s (",
9370 reg_prefix
, regname (reg
, 0));
9371 decode_location_expression (start
, eh_addr_size
, 0, -1,
9375 if (*reg_prefix
== '\0')
9376 fc
->col_type
[reg
] = DW_CFA_expression
;
9380 case DW_CFA_val_expression
:
9381 READ_ULEB (reg
, start
, block_end
);
9382 READ_ULEB (ul
, start
, block_end
);
9383 if (reg
>= (unsigned int) fc
->ncols
)
9384 reg_prefix
= bad_reg
;
9385 if (ul
> (size_t) (block_end
- start
))
9387 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9390 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9392 printf (" DW_CFA_val_expression: %s%s (",
9393 reg_prefix
, regname (reg
, 0));
9394 decode_location_expression (start
, eh_addr_size
, 0, -1,
9398 if (*reg_prefix
== '\0')
9399 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9403 case DW_CFA_offset_extended_sf
:
9404 READ_ULEB (reg
, start
, block_end
);
9405 READ_SLEB (l
, start
, block_end
);
9406 if (frame_need_space (fc
, reg
) < 0)
9407 reg_prefix
= bad_reg
;
9408 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9409 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
9410 reg_prefix
, regname (reg
, 0),
9411 (long)(l
* fc
->data_factor
));
9412 if (*reg_prefix
== '\0')
9414 fc
->col_type
[reg
] = DW_CFA_offset
;
9415 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9419 case DW_CFA_val_offset_sf
:
9420 READ_ULEB (reg
, start
, block_end
);
9421 READ_SLEB (l
, start
, block_end
);
9422 if (frame_need_space (fc
, reg
) < 0)
9423 reg_prefix
= bad_reg
;
9424 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9425 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
9426 reg_prefix
, regname (reg
, 0),
9427 (long)(l
* fc
->data_factor
));
9428 if (*reg_prefix
== '\0')
9430 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9431 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9435 case DW_CFA_def_cfa_sf
:
9436 READ_ULEB (fc
->cfa_reg
, start
, block_end
);
9437 READ_SLEB (l
, start
, block_end
);
9438 l
*= fc
->data_factor
;
9441 if (! do_debug_frames_interp
)
9442 printf (" DW_CFA_def_cfa_sf: %s ofs %ld\n",
9443 regname (fc
->cfa_reg
, 0), (long) l
);
9446 case DW_CFA_def_cfa_offset_sf
:
9447 READ_SLEB (l
, start
, block_end
);
9448 l
*= fc
->data_factor
;
9450 if (! do_debug_frames_interp
)
9451 printf (" DW_CFA_def_cfa_offset_sf: %ld\n", (long) l
);
9454 case DW_CFA_MIPS_advance_loc8
:
9455 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9456 if (do_debug_frames_interp
)
9457 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9459 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
9460 (unsigned long) (ofs
* fc
->code_factor
),
9461 dwarf_vmatoa_1 (NULL
,
9462 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9464 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9467 case DW_CFA_GNU_window_save
:
9468 if (! do_debug_frames_interp
)
9469 printf (" DW_CFA_GNU_window_save\n");
9472 case DW_CFA_GNU_args_size
:
9473 READ_ULEB (ul
, start
, block_end
);
9474 if (! do_debug_frames_interp
)
9475 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9478 case DW_CFA_GNU_negative_offset_extended
:
9479 READ_ULEB (reg
, start
, block_end
);
9480 READ_SLEB (l
, start
, block_end
);
9482 if (frame_need_space (fc
, reg
) < 0)
9483 reg_prefix
= bad_reg
;
9484 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9485 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
9486 reg_prefix
, regname (reg
, 0),
9487 (long)(l
* fc
->data_factor
));
9488 if (*reg_prefix
== '\0')
9490 fc
->col_type
[reg
] = DW_CFA_offset
;
9491 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9496 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9497 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9499 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9504 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9505 if (do_debug_frames_interp
&& ! all_nops
)
9506 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9508 if (fde_fc
.col_type
!= NULL
)
9510 free (fde_fc
.col_type
);
9511 fde_fc
.col_type
= NULL
;
9513 if (fde_fc
.col_offset
!= NULL
)
9515 free (fde_fc
.col_offset
);
9516 fde_fc
.col_offset
= NULL
;
9520 eh_addr_size
= saved_eh_addr_size
;
9525 while (remembered_state
!= NULL
)
9527 rs
= remembered_state
;
9528 remembered_state
= rs
->next
;
9529 free (rs
->col_type
);
9530 free (rs
->col_offset
);
9531 rs
->next
= NULL
; /* Paranoia. */
9535 while (chunks
!= NULL
)
9539 free (rs
->col_type
);
9540 free (rs
->col_offset
);
9541 rs
->next
= NULL
; /* Paranoia. */
9545 while (forward_refs
!= NULL
)
9548 forward_refs
= rs
->next
;
9549 free (rs
->col_type
);
9550 free (rs
->col_offset
);
9551 rs
->next
= NULL
; /* Paranoia. */
9561 display_debug_names (struct dwarf_section
*section
, void *file
)
9563 unsigned char *hdrptr
= section
->start
;
9564 dwarf_vma unit_length
;
9565 unsigned char *unit_start
;
9566 const unsigned char *const section_end
= section
->start
+ section
->size
;
9567 unsigned char *unit_end
;
9569 introduce (section
, false);
9571 load_debug_section_with_follow (str
, file
);
9573 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9575 unsigned int offset_size
;
9576 uint16_t dwarf_version
, padding
;
9577 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9578 uint64_t bucket_count
, name_count
, abbrev_table_size
;
9579 uint32_t augmentation_string_size
;
9581 bool augmentation_printable
;
9582 const char *augmentation_string
;
9585 unit_start
= hdrptr
;
9587 /* Get and check the length of the block. */
9588 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9590 if (unit_length
== 0xffffffff)
9592 /* This section is 64-bit DWARF. */
9593 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9599 if (unit_length
> (size_t) (section_end
- hdrptr
)
9600 || unit_length
< 2 + 2 + 4 * 7)
9603 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9605 (unsigned long) (unit_start
- section
->start
),
9606 dwarf_vmatoa ("x", unit_length
));
9609 unit_end
= hdrptr
+ unit_length
;
9611 /* Get and check the version number. */
9612 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9613 printf (_("Version %ld\n"), (long) dwarf_version
);
9615 /* Prior versions did not exist, and future versions may not be
9616 backwards compatible. */
9617 if (dwarf_version
!= 5)
9619 warn (_("Only DWARF version 5 .debug_names "
9620 "is currently supported.\n"));
9624 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9626 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9629 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9630 if (comp_unit_count
== 0)
9631 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9633 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9634 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9635 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9636 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9637 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9639 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9640 if (augmentation_string_size
% 4 != 0)
9642 warn (_("Augmentation string length %u must be rounded up "
9643 "to a multiple of 4 in .debug_names.\n"),
9644 augmentation_string_size
);
9645 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9647 if (augmentation_string_size
> (size_t) (unit_end
- hdrptr
))
9650 printf (_("Augmentation string:"));
9652 augmentation_printable
= true;
9653 augmentation_string
= (const char *) hdrptr
;
9655 for (i
= 0; i
< augmentation_string_size
; i
++)
9659 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9660 printf (" %02x", uc
);
9662 if (uc
!= 0 && !ISPRINT (uc
))
9663 augmentation_printable
= false;
9666 if (augmentation_printable
)
9670 i
< augmentation_string_size
&& augmentation_string
[i
];
9672 putchar (augmentation_string
[i
]);
9677 printf (_("CU table:\n"));
9678 if (_mul_overflow (comp_unit_count
, offset_size
, &total
)
9679 || total
> (size_t) (unit_end
- hdrptr
))
9681 for (i
= 0; i
< comp_unit_count
; i
++)
9685 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9686 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9690 printf (_("TU table:\n"));
9691 if (_mul_overflow (local_type_unit_count
, offset_size
, &total
)
9692 || total
> (size_t) (unit_end
- hdrptr
))
9694 for (i
= 0; i
< local_type_unit_count
; i
++)
9698 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9699 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9703 printf (_("Foreign TU table:\n"));
9704 if (_mul_overflow (foreign_type_unit_count
, 8, &total
)
9705 || total
> (size_t) (unit_end
- hdrptr
))
9707 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9711 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9712 printf (_("[%3u] "), i
);
9713 print_dwarf_vma (signature
, 8);
9718 uint64_t xtra
= (bucket_count
* sizeof (uint32_t)
9719 + name_count
* (sizeof (uint32_t) + 2 * offset_size
)
9720 + abbrev_table_size
);
9721 if (xtra
> (size_t) (unit_end
- hdrptr
))
9723 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9724 "for unit 0x%lx in the debug_names\n"),
9726 (long) (unit_end
- unit_start
),
9727 (long) (unit_start
- section
->start
));
9730 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9731 hdrptr
+= bucket_count
* sizeof (uint32_t);
9732 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9733 hdrptr
+= name_count
* sizeof (uint32_t);
9734 unsigned char *const name_table_string_offsets
= hdrptr
;
9735 hdrptr
+= name_count
* offset_size
;
9736 unsigned char *const name_table_entry_offsets
= hdrptr
;
9737 hdrptr
+= name_count
* offset_size
;
9738 unsigned char *const abbrev_table
= hdrptr
;
9739 hdrptr
+= abbrev_table_size
;
9740 const unsigned char *const abbrev_table_end
= hdrptr
;
9741 unsigned char *const entry_pool
= hdrptr
;
9743 size_t buckets_filled
= 0;
9745 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9747 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9752 printf (ngettext ("Used %zu of %lu bucket.\n",
9753 "Used %zu of %lu buckets.\n",
9755 buckets_filled
, (unsigned long) bucket_count
);
9757 uint32_t hash_prev
= 0;
9758 size_t hash_clash_count
= 0;
9759 size_t longest_clash
= 0;
9760 size_t this_length
= 0;
9762 for (hashi
= 0; hashi
< name_count
; hashi
++)
9764 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9768 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9772 longest_clash
= MAX (longest_clash
, this_length
);
9777 hash_prev
= hash_this
;
9779 printf (_("Out of %lu items there are %zu bucket clashes"
9780 " (longest of %zu entries).\n"),
9781 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9782 assert (name_count
== buckets_filled
+ hash_clash_count
);
9784 struct abbrev_lookup_entry
9786 dwarf_vma abbrev_tag
;
9787 unsigned char *abbrev_lookup_ptr
;
9789 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9790 size_t abbrev_lookup_used
= 0;
9791 size_t abbrev_lookup_allocated
= 0;
9793 unsigned char *abbrevptr
= abbrev_table
;
9796 dwarf_vma abbrev_tag
;
9798 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9799 if (abbrev_tag
== 0)
9801 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9803 abbrev_lookup_allocated
= MAX (0x100,
9804 abbrev_lookup_allocated
* 2);
9805 abbrev_lookup
= xrealloc (abbrev_lookup
,
9806 (abbrev_lookup_allocated
9807 * sizeof (*abbrev_lookup
)));
9809 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9810 struct abbrev_lookup_entry
*entry
;
9811 for (entry
= abbrev_lookup
;
9812 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9814 if (entry
->abbrev_tag
== abbrev_tag
)
9816 warn (_("Duplicate abbreviation tag %lu "
9817 "in unit 0x%lx in the debug_names\n"),
9818 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9821 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9822 entry
->abbrev_tag
= abbrev_tag
;
9823 entry
->abbrev_lookup_ptr
= abbrevptr
;
9825 /* Skip DWARF tag. */
9826 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9829 dwarf_vma xindex
, form
;
9831 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9832 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9833 if (xindex
== 0 && form
== 0)
9838 printf (_("\nSymbol table:\n"));
9840 for (namei
= 0; namei
< name_count
; ++namei
)
9842 uint64_t string_offset
, entry_offset
;
9845 p
= name_table_string_offsets
+ namei
* offset_size
;
9846 SAFE_BYTE_GET (string_offset
, p
, offset_size
, unit_end
);
9847 p
= name_table_entry_offsets
+ namei
* offset_size
;
9848 SAFE_BYTE_GET (entry_offset
, p
, offset_size
, unit_end
);
9850 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9851 fetch_indirect_string (string_offset
));
9853 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9855 /* We need to scan first whether there is a single or multiple
9856 entries. TAGNO is -2 for the first entry, it is -1 for the
9857 initial tag read of the second entry, then it becomes 0 for the
9858 first entry for real printing etc. */
9860 /* Initialize it due to a false compiler warning. */
9861 dwarf_vma second_abbrev_tag
= -1;
9864 dwarf_vma abbrev_tag
;
9865 dwarf_vma dwarf_tag
;
9866 const struct abbrev_lookup_entry
*entry
;
9868 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9871 second_abbrev_tag
= abbrev_tag
;
9873 entryptr
= entry_pool
+ entry_offset
;
9876 if (abbrev_tag
== 0)
9880 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9881 (unsigned long) abbrev_tag
);
9883 for (entry
= abbrev_lookup
;
9884 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9886 if (entry
->abbrev_tag
== abbrev_tag
)
9888 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9890 warn (_("Undefined abbreviation tag %lu "
9891 "in unit 0x%lx in the debug_names\n"),
9893 (long) (unit_start
- section
->start
));
9896 abbrevptr
= entry
->abbrev_lookup_ptr
;
9897 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9899 printf (" %s", get_TAG_name (dwarf_tag
));
9902 dwarf_vma xindex
, form
;
9904 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9905 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9906 if (xindex
== 0 && form
== 0)
9910 printf (" %s", get_IDX_name (xindex
));
9911 entryptr
= read_and_display_attr_value (0, form
, 0,
9912 unit_start
, entryptr
, unit_end
,
9914 dwarf_version
, NULL
,
9921 printf (_(" <no entries>"));
9925 free (abbrev_lookup
);
9932 display_debug_links (struct dwarf_section
* section
,
9933 void * file ATTRIBUTE_UNUSED
)
9935 const unsigned char * filename
;
9936 unsigned int filelen
;
9938 introduce (section
, false);
9940 /* The .gnu_debuglink section is formatted as:
9941 (c-string) Filename.
9942 (padding) If needed to reach a 4 byte boundary.
9943 (uint32_t) CRC32 value.
9945 The .gun_debugaltlink section is formatted as:
9946 (c-string) Filename.
9947 (binary) Build-ID. */
9949 filename
= section
->start
;
9950 filelen
= strnlen ((const char *) filename
, section
->size
);
9951 if (filelen
== section
->size
)
9953 warn (_("The debuglink filename is corrupt/missing\n"));
9957 printf (_(" Separate debug info file: %s\n"), filename
);
9959 if (startswith (section
->name
, ".gnu_debuglink"))
9962 unsigned int crc_offset
;
9964 crc_offset
= filelen
+ 1;
9965 crc_offset
= (crc_offset
+ 3) & ~3;
9966 if (crc_offset
+ 4 > section
->size
)
9968 warn (_("CRC offset missing/truncated\n"));
9972 crc32
= byte_get (filename
+ crc_offset
, 4);
9974 printf (_(" CRC value: %#x\n"), crc32
);
9976 if (crc_offset
+ 4 < section
->size
)
9978 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9979 (long)(section
->size
- (crc_offset
+ 4)));
9983 else /* startswith (section->name, ".gnu_debugaltlink") */
9985 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9986 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9987 bfd_size_type printed
;
9989 /* FIXME: Should we support smaller build-id notes ? */
9990 if (build_id_len
< 0x14)
9992 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9996 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9997 display_data (printed
, build_id
, build_id_len
);
10006 display_gdb_index (struct dwarf_section
*section
,
10007 void *file ATTRIBUTE_UNUSED
)
10009 unsigned char *start
= section
->start
;
10011 uint32_t cu_list_offset
, tu_list_offset
;
10012 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
10013 unsigned int cu_list_elements
, tu_list_elements
;
10014 unsigned int address_table_size
, symbol_table_slots
;
10015 unsigned char *cu_list
, *tu_list
;
10016 unsigned char *address_table
, *symbol_table
, *constant_pool
;
10019 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
10021 introduce (section
, false);
10023 if (section
->size
< 6 * sizeof (uint32_t))
10025 warn (_("Truncated header in the %s section.\n"), section
->name
);
10029 version
= byte_get_little_endian (start
, 4);
10030 printf (_("Version %ld\n"), (long) version
);
10032 /* Prior versions are obsolete, and future versions may not be
10033 backwards compatible. */
10034 if (version
< 3 || version
> 8)
10036 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
10040 warn (_("The address table data in version 3 may be wrong.\n"));
10042 warn (_("Version 4 does not support case insensitive lookups.\n"));
10044 warn (_("Version 5 does not include inlined functions.\n"));
10046 warn (_("Version 6 does not include symbol attributes.\n"));
10047 /* Version 7 indices generated by Gold have bad type unit references,
10048 PR binutils/15021. But we don't know if the index was generated by
10049 Gold or not, so to avoid worrying users with gdb-generated indices
10050 we say nothing for version 7 here. */
10052 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
10053 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
10054 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
10055 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
10056 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
10058 if (cu_list_offset
> section
->size
10059 || tu_list_offset
> section
->size
10060 || address_table_offset
> section
->size
10061 || symbol_table_offset
> section
->size
10062 || constant_pool_offset
> section
->size
)
10064 warn (_("Corrupt header in the %s section.\n"), section
->name
);
10068 /* PR 17531: file: 418d0a8a. */
10069 if (tu_list_offset
< cu_list_offset
)
10071 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
10072 tu_list_offset
, cu_list_offset
);
10076 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
10078 if (address_table_offset
< tu_list_offset
)
10080 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
10081 address_table_offset
, tu_list_offset
);
10085 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
10087 /* PR 17531: file: 18a47d3d. */
10088 if (symbol_table_offset
< address_table_offset
)
10090 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
10091 symbol_table_offset
, address_table_offset
);
10095 address_table_size
= symbol_table_offset
- address_table_offset
;
10097 if (constant_pool_offset
< symbol_table_offset
)
10099 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
10100 constant_pool_offset
, symbol_table_offset
);
10104 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
10106 cu_list
= start
+ cu_list_offset
;
10107 tu_list
= start
+ tu_list_offset
;
10108 address_table
= start
+ address_table_offset
;
10109 symbol_table
= start
+ symbol_table_offset
;
10110 constant_pool
= start
+ constant_pool_offset
;
10112 if (address_table_offset
+ address_table_size
> section
->size
)
10114 warn (_("Address table extends beyond end of section.\n"));
10118 printf (_("\nCU table:\n"));
10119 for (i
= 0; i
< cu_list_elements
; i
+= 2)
10121 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
10122 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
10124 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
10125 (unsigned long) cu_offset
,
10126 (unsigned long) (cu_offset
+ cu_length
- 1));
10129 printf (_("\nTU table:\n"));
10130 for (i
= 0; i
< tu_list_elements
; i
+= 3)
10132 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
10133 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
10134 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
10136 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
10137 (unsigned long) tu_offset
,
10138 (unsigned long) type_offset
);
10139 print_dwarf_vma (signature
, 8);
10143 printf (_("\nAddress table:\n"));
10144 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
10147 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
10148 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
10149 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
10151 print_dwarf_vma (low
, 8);
10152 print_dwarf_vma (high
, 8);
10153 printf (_("%lu\n"), (unsigned long) cu_index
);
10156 printf (_("\nSymbol table:\n"));
10157 for (i
= 0; i
< symbol_table_slots
; ++i
)
10159 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10160 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10161 uint32_t num_cus
, cu
;
10163 if (name_offset
!= 0
10164 || cu_vector_offset
!= 0)
10168 /* PR 17531: file: 5b7b07ad. */
10169 if (name_offset
>= section
->size
- constant_pool_offset
)
10171 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10172 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10176 printf ("[%3u] %.*s:", i
,
10177 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10178 constant_pool
+ name_offset
);
10180 if (section
->size
- constant_pool_offset
< 4
10181 || cu_vector_offset
> section
->size
- constant_pool_offset
- 4)
10183 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10184 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10185 cu_vector_offset
, i
);
10189 num_cus
= byte_get_little_endian (constant_pool
+ cu_vector_offset
, 4);
10191 if ((uint64_t) num_cus
* 4 > section
->size
- (constant_pool_offset
10192 + cu_vector_offset
+ 4))
10194 printf ("<invalid number of CUs: %d>\n", num_cus
);
10195 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10203 for (j
= 0; j
< num_cus
; ++j
)
10206 gdb_index_symbol_kind kind
;
10208 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10209 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10210 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10211 cu
= GDB_INDEX_CU_VALUE (cu
);
10212 /* Convert to TU number if it's for a type unit. */
10213 if (cu
>= cu_list_elements
/ 2)
10214 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10215 (unsigned long) (cu
- cu_list_elements
/ 2));
10217 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10219 printf (" [%s, %s]",
10220 is_static
? _("static") : _("global"),
10221 get_gdb_index_symbol_kind_name (kind
));
10233 /* Pre-allocate enough space for the CU/TU sets needed. */
10236 prealloc_cu_tu_list (unsigned int nshndx
)
10238 if (shndx_pool
== NULL
)
10240 shndx_pool_size
= nshndx
;
10241 shndx_pool_used
= 0;
10242 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10243 sizeof (unsigned int));
10247 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10248 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10249 sizeof (unsigned int));
10254 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10256 if (shndx_pool_used
>= shndx_pool_size
)
10258 error (_("Internal error: out of space in the shndx pool.\n"));
10261 shndx_pool
[shndx_pool_used
++] = shndx
;
10265 end_cu_tu_entry (void)
10267 if (shndx_pool_used
>= shndx_pool_size
)
10269 error (_("Internal error: out of space in the shndx pool.\n"));
10272 shndx_pool
[shndx_pool_used
++] = 0;
10275 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10277 static const char *
10278 get_DW_SECT_short_name (unsigned int dw_sect
)
10280 static char buf
[16];
10286 case DW_SECT_TYPES
:
10288 case DW_SECT_ABBREV
:
10294 case DW_SECT_STR_OFFSETS
:
10296 case DW_SECT_MACINFO
:
10298 case DW_SECT_MACRO
:
10304 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10308 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10309 These sections are extensions for Fission.
10310 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10313 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10315 unsigned char *phdr
= section
->start
;
10316 unsigned char *limit
= phdr
+ section
->size
;
10317 unsigned char *phash
;
10318 unsigned char *pindex
;
10319 unsigned char *ppool
;
10320 unsigned int version
;
10321 unsigned int ncols
= 0;
10322 unsigned int nused
;
10323 unsigned int nslots
;
10326 dwarf_vma signature
;
10329 /* PR 17512: file: 002-168123-0.004. */
10332 warn (_("Section %s is empty\n"), section
->name
);
10335 /* PR 17512: file: 002-376-0.004. */
10336 if (section
->size
< 24)
10338 warn (_("Section %s is too small to contain a CU/TU header\n"),
10344 SAFE_BYTE_GET_AND_INC (version
, phash
, 4, limit
);
10346 SAFE_BYTE_GET_AND_INC (ncols
, phash
, 4, limit
);
10347 SAFE_BYTE_GET_AND_INC (nused
, phash
, 4, limit
);
10348 SAFE_BYTE_GET_AND_INC (nslots
, phash
, 4, limit
);
10350 pindex
= phash
+ (size_t) nslots
* 8;
10351 ppool
= pindex
+ (size_t) nslots
* 4;
10355 introduce (section
, false);
10357 printf (_(" Version: %u\n"), version
);
10359 printf (_(" Number of columns: %u\n"), ncols
);
10360 printf (_(" Number of used entries: %u\n"), nused
);
10361 printf (_(" Number of slots: %u\n\n"), nslots
);
10364 /* PR 17531: file: 45d69832. */
10365 if (_mul_overflow ((size_t) nslots
, 12, &total
)
10366 || total
> (size_t) (limit
- phash
))
10368 warn (ngettext ("Section %s is too small for %u slot\n",
10369 "Section %s is too small for %u slots\n",
10371 section
->name
, nslots
);
10378 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10379 for (i
= 0; i
< nslots
; i
++)
10381 unsigned char *shndx_list
;
10382 unsigned int shndx
;
10384 SAFE_BYTE_GET (signature
, phash
, 8, limit
);
10385 if (signature
!= 0)
10387 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10388 shndx_list
= ppool
+ j
* 4;
10389 /* PR 17531: file: 705e010d. */
10390 if (shndx_list
< ppool
)
10392 warn (_("Section index pool located before start of section\n"));
10397 printf (_(" [%3d] Signature: 0x%s Sections: "),
10398 i
, dwarf_vmatoa ("x", signature
));
10401 if (shndx_list
>= limit
)
10403 warn (_("Section %s too small for shndx pool\n"),
10407 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10411 printf (" %d", shndx
);
10413 add_shndx_to_cu_tu_entry (shndx
);
10419 end_cu_tu_entry ();
10425 else if (version
== 2)
10428 unsigned int dw_sect
;
10429 unsigned char *ph
= phash
;
10430 unsigned char *pi
= pindex
;
10431 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10432 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10434 struct cu_tu_set
*this_set
= NULL
;
10436 unsigned char *prow
;
10439 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10441 /* PR 17531: file: 0dd159bf.
10442 Check for integer overflow (can occur when size_t is 32-bit)
10443 with overlarge ncols or nused values. */
10445 || _mul_overflow ((size_t) ncols
, 4, &temp
)
10446 || _mul_overflow ((size_t) nused
+ 1, temp
, &total
)
10447 || total
> (size_t) (limit
- ppool
))
10449 warn (_("Section %s too small for offset and size tables\n"),
10456 printf (_(" Offset table\n"));
10457 printf (" slot %-16s ",
10458 is_tu_index
? _("signature") : _("dwo_id"));
10465 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10466 this_set
= tu_sets
;
10471 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10472 this_set
= cu_sets
;
10478 for (j
= 0; j
< ncols
; j
++)
10480 unsigned char *p
= ppool
+ j
* 4;
10481 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10482 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10487 for (i
= 0; i
< nslots
; i
++)
10489 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10491 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10494 /* PR 17531: file: a05f6ab3. */
10497 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10504 size_t num_copy
= sizeof (uint64_t);
10506 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10509 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10511 printf (_(" [%3d] 0x%s"),
10512 i
, dwarf_vmatoa ("x", signature
));
10513 for (j
= 0; j
< ncols
; j
++)
10515 unsigned char *p
= prow
+ j
* 4;
10516 SAFE_BYTE_GET (val
, p
, 4, limit
);
10518 printf (" %8d", val
);
10522 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10524 /* PR 17531: file: 10796eb3. */
10525 if (dw_sect
>= DW_SECT_MAX
)
10526 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10528 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10544 printf (_(" Size table\n"));
10545 printf (" slot %-16s ",
10546 is_tu_index
? _("signature") : _("dwo_id"));
10549 for (j
= 0; j
< ncols
; j
++)
10551 unsigned char *p
= ppool
+ j
* 4;
10552 SAFE_BYTE_GET (val
, p
, 4, limit
);
10554 printf (" %8s", get_DW_SECT_short_name (val
));
10560 for (i
= 0; i
< nslots
; i
++)
10562 SAFE_BYTE_GET (signature
, ph
, 8, limit
);
10564 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10567 prow
= psizes
+ (row
- 1) * ncols
* 4;
10570 printf (_(" [%3d] 0x%s"),
10571 i
, dwarf_vmatoa ("x", signature
));
10573 for (j
= 0; j
< ncols
; j
++)
10575 unsigned char *p
= prow
+ j
* 4;
10576 SAFE_BYTE_GET (val
, p
, 4, limit
);
10578 printf (" %8d", val
);
10582 SAFE_BYTE_GET (dw_sect
, p
, 4, limit
);
10583 if (dw_sect
>= DW_SECT_MAX
)
10584 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10586 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10598 else if (do_display
)
10599 printf (_(" Unsupported version (%d)\n"), version
);
10607 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10609 /* Load the CU and TU indexes if present. This will build a list of
10610 section sets that we can use to associate a .debug_info.dwo section
10611 with its associated .debug_abbrev.dwo section in a .dwp file. */
10614 load_cu_tu_indexes (void *file
)
10616 /* If we have already loaded (or tried to load) the CU and TU indexes
10617 then do not bother to repeat the task. */
10618 if (cu_tu_indexes_read
== -1)
10620 cu_tu_indexes_read
= true;
10622 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10623 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10624 cu_tu_indexes_read
= false;
10626 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10627 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10628 cu_tu_indexes_read
= false;
10631 return (bool) cu_tu_indexes_read
;
10634 /* Find the set of sections that includes section SHNDX. */
10637 find_cu_tu_set (void *file
, unsigned int shndx
)
10641 if (! load_cu_tu_indexes (file
))
10644 /* Find SHNDX in the shndx pool. */
10645 for (i
= 0; i
< shndx_pool_used
; i
++)
10646 if (shndx_pool
[i
] == shndx
)
10649 if (i
>= shndx_pool_used
)
10652 /* Now backup to find the first entry in the set. */
10653 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10656 return shndx_pool
+ i
;
10659 /* Display a .debug_cu_index or .debug_tu_index section. */
10662 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10664 return process_cu_tu_index (section
, 1);
10668 display_debug_not_supported (struct dwarf_section
*section
,
10669 void *file ATTRIBUTE_UNUSED
)
10671 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10677 /* Like malloc, but takes two parameters like calloc.
10678 Verifies that the first parameter is not too large.
10679 Note: does *not* initialise the allocated memory to zero. */
10682 cmalloc (size_t nmemb
, size_t size
)
10684 /* Check for overflow. */
10685 if (nmemb
>= ~(size_t) 0 / size
)
10688 return xmalloc (nmemb
* size
);
10691 /* Like xmalloc, 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 xcmalloc (size_t nmemb
, size_t size
)
10698 /* Check for overflow. */
10699 if (nmemb
>= ~(size_t) 0 / size
)
10702 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10707 return xmalloc (nmemb
* size
);
10710 /* Like xrealloc, but takes three parameters.
10711 Verifies that the second parameter is not too large.
10712 Note: does *not* initialise any new memory to zero. */
10715 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10717 /* Check for overflow. */
10718 if (nmemb
>= ~(size_t) 0 / size
)
10720 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10725 return xrealloc (ptr
, nmemb
* size
);
10728 /* Like xcalloc, but verifies that the first parameter is not too large. */
10731 xcalloc2 (size_t nmemb
, size_t size
)
10733 /* Check for overflow. */
10734 if (nmemb
>= ~(size_t) 0 / size
)
10736 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10741 return xcalloc (nmemb
, size
);
10744 static unsigned long
10745 calc_gnu_debuglink_crc32 (unsigned long crc
,
10746 const unsigned char * buf
,
10749 static const unsigned long crc32_table
[256] =
10751 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10752 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10753 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10754 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10755 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10756 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10757 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10758 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10759 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10760 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10761 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10762 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10763 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10764 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10765 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10766 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10767 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10768 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10769 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10770 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10771 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10772 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10773 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10774 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10775 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10776 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10777 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10778 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10779 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10780 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10781 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10782 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10783 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10784 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10785 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10786 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10787 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10788 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10789 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10790 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10791 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10792 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10793 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10794 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10795 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10796 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10797 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10798 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10799 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10800 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10801 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10804 const unsigned char *end
;
10806 crc
= ~crc
& 0xffffffff;
10807 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10808 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10809 return ~crc
& 0xffffffff;
10812 typedef bool (*check_func_type
) (const char *, void *);
10813 typedef const char *(* parse_func_type
) (struct dwarf_section
*, void *);
10816 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10818 static unsigned char buffer
[8 * 1024];
10820 bfd_size_type count
;
10821 unsigned long crc
= 0;
10824 sep_data
= open_debug_file (pathname
);
10825 if (sep_data
== NULL
)
10828 /* Yes - we are opening the file twice... */
10829 f
= fopen (pathname
, "rb");
10832 /* Paranoia: This should never happen. */
10833 close_debug_file (sep_data
);
10834 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10838 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10839 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10843 if (crc
!= * (unsigned long *) crc_pointer
)
10845 close_debug_file (sep_data
);
10846 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10854 static const char *
10855 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10858 unsigned int crc_offset
;
10859 unsigned long * crc32
= (unsigned long *) data
;
10861 /* The name is first.
10862 The CRC value is stored after the filename, aligned up to 4 bytes. */
10863 name
= (const char *) section
->start
;
10865 crc_offset
= strnlen (name
, section
->size
) + 1;
10866 if (crc_offset
== 1)
10868 crc_offset
= (crc_offset
+ 3) & ~3;
10869 if (crc_offset
+ 4 > section
->size
)
10872 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10877 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10879 void * sep_data
= open_debug_file (filename
);
10881 if (sep_data
== NULL
)
10884 /* FIXME: We should now extract the build-id in the separate file
10890 typedef struct build_id_data
10893 const unsigned char * data
;
10896 static const char *
10897 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10900 bfd_size_type namelen
;
10901 bfd_size_type id_len
;
10902 Build_id_data
* build_id_data
;
10904 /* The name is first.
10905 The build-id follows immediately, with no padding, up to the section's end. */
10907 name
= (const char *) section
->start
;
10908 namelen
= strnlen (name
, section
->size
) + 1;
10911 if (namelen
>= section
->size
)
10914 id_len
= section
->size
- namelen
;
10918 build_id_data
= (Build_id_data
*) data
;
10919 build_id_data
->len
= id_len
;
10920 build_id_data
->data
= section
->start
+ namelen
;
10926 add_separate_debug_file (const char * filename
, void * handle
)
10928 separate_info
* i
= xmalloc (sizeof * i
);
10930 i
->filename
= filename
;
10931 i
->handle
= handle
;
10932 i
->next
= first_separate_info
;
10933 first_separate_info
= i
;
10936 #if HAVE_LIBDEBUGINFOD
10937 /* Query debuginfod servers for the target debuglink or debugaltlink
10938 file. If successful, store the path of the file in filename and
10939 return TRUE, otherwise return FALSE. */
10942 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10946 size_t build_id_len
;
10947 unsigned char * build_id
;
10949 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10951 /* Get the build-id of file. */
10952 build_id
= get_build_id (file
);
10955 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10957 /* Get the build-id of the debugaltlink file. */
10958 unsigned int filelen
;
10960 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10961 if (filelen
== section
->size
)
10962 /* Corrupt debugaltlink. */
10965 build_id
= section
->start
+ filelen
+ 1;
10966 build_id_len
= section
->size
- (filelen
+ 1);
10968 if (build_id_len
== 0)
10977 debuginfod_client
* client
;
10979 client
= debuginfod_begin ();
10980 if (client
== NULL
)
10983 /* Query debuginfod servers for the target file. If found its path
10984 will be stored in filename. */
10985 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10986 debuginfod_end (client
);
10988 /* Only free build_id if we allocated space for a hex string
10989 in get_build_id (). */
10990 if (build_id_len
== 0)
10995 /* File successfully retrieved. Close fd since we want to
10996 use open_debug_file () on filename instead. */
11007 load_separate_debug_info (const char * main_filename
,
11008 struct dwarf_section
* xlink
,
11009 parse_func_type parse_func
,
11010 check_func_type check_func
,
11012 void * file ATTRIBUTE_UNUSED
)
11014 const char * separate_filename
;
11015 char * debug_filename
;
11017 size_t canon_dirlen
;
11020 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
11022 warn (_("Corrupt debuglink section: %s\n"),
11023 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
11027 /* Attempt to locate the separate file.
11028 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
11030 canon_dir
= lrealpath (main_filename
);
11032 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
11033 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
11035 canon_dir
[canon_dirlen
] = '\0';
11038 #define DEBUGDIR "/lib/debug"
11040 #ifndef EXTRA_DEBUG_ROOT1
11041 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
11043 #ifndef EXTRA_DEBUG_ROOT2
11044 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
11047 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
11049 + strlen (".debug/")
11050 #ifdef EXTRA_DEBUG_ROOT1
11051 + strlen (EXTRA_DEBUG_ROOT1
)
11053 #ifdef EXTRA_DEBUG_ROOT2
11054 + strlen (EXTRA_DEBUG_ROOT2
)
11056 + strlen (separate_filename
)
11058 if (debug_filename
== NULL
)
11060 warn (_("Out of memory"));
11065 /* First try in the current directory. */
11066 sprintf (debug_filename
, "%s", separate_filename
);
11067 if (check_func (debug_filename
, func_data
))
11070 /* Then try in a subdirectory called .debug. */
11071 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11072 if (check_func (debug_filename
, func_data
))
11075 /* Then try in the same directory as the original file. */
11076 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11077 if (check_func (debug_filename
, func_data
))
11080 /* And the .debug subdirectory of that directory. */
11081 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11082 if (check_func (debug_filename
, func_data
))
11085 #ifdef EXTRA_DEBUG_ROOT1
11086 /* Try the first extra debug file root. */
11087 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11088 if (check_func (debug_filename
, func_data
))
11091 /* Try the first extra debug file root. */
11092 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
11093 if (check_func (debug_filename
, func_data
))
11097 #ifdef EXTRA_DEBUG_ROOT2
11098 /* Try the second extra debug file root. */
11099 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
11100 if (check_func (debug_filename
, func_data
))
11104 /* Then try in the global debug_filename directory. */
11105 strcpy (debug_filename
, DEBUGDIR
);
11106 dirlen
= strlen (DEBUGDIR
) - 1;
11107 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
11108 strcat (debug_filename
, "/");
11109 strcat (debug_filename
, (const char *) separate_filename
);
11111 if (check_func (debug_filename
, func_data
))
11114 #if HAVE_LIBDEBUGINFOD
11116 char * tmp_filename
;
11118 if (debuginfod_fetch_separate_debug_info (xlink
,
11122 /* File successfully downloaded from server, replace
11123 debug_filename with the file's path. */
11124 free (debug_filename
);
11125 debug_filename
= tmp_filename
;
11131 if (do_debug_links
)
11133 /* Failed to find the file. */
11134 warn (_("could not find separate debug file '%s'\n"),
11135 separate_filename
);
11136 warn (_("tried: %s\n"), debug_filename
);
11138 #ifdef EXTRA_DEBUG_ROOT2
11139 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
,
11140 separate_filename
);
11141 warn (_("tried: %s\n"), debug_filename
);
11144 #ifdef EXTRA_DEBUG_ROOT1
11145 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
,
11146 canon_dir
, separate_filename
);
11147 warn (_("tried: %s\n"), debug_filename
);
11149 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
,
11150 separate_filename
);
11151 warn (_("tried: %s\n"), debug_filename
);
11154 sprintf (debug_filename
, "%s.debug/%s", canon_dir
,
11155 separate_filename
);
11156 warn (_("tried: %s\n"), debug_filename
);
11158 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11159 warn (_("tried: %s\n"), debug_filename
);
11161 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11162 warn (_("tried: %s\n"), debug_filename
);
11164 sprintf (debug_filename
, "%s", separate_filename
);
11165 warn (_("tried: %s\n"), debug_filename
);
11167 #if HAVE_LIBDEBUGINFOD
11169 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11173 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11179 free (debug_filename
);
11185 void * debug_handle
;
11187 /* Now open the file.... */
11188 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11190 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11191 free (debug_filename
);
11195 /* FIXME: We do not check to see if there are any other separate debug info
11196 files that would also match. */
11198 if (do_debug_links
)
11199 printf (_("\n%s: Found separate debug info file: %s\n"), main_filename
, debug_filename
);
11200 add_separate_debug_file (debug_filename
, debug_handle
);
11202 /* Do not free debug_filename - it might be referenced inside
11203 the structure returned by open_debug_file(). */
11204 return debug_handle
;
11207 /* Attempt to load a separate dwarf object file. */
11210 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11212 char * separate_filename
;
11213 void * separate_handle
;
11215 if (IS_ABSOLUTE_PATH (name
))
11216 separate_filename
= strdup (name
);
11218 /* FIXME: Skip adding / if dwo_dir ends in /. */
11219 separate_filename
= concat (dir
, "/", name
, NULL
);
11220 if (separate_filename
== NULL
)
11222 warn (_("Out of memory allocating dwo filename\n"));
11226 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11228 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11229 free (separate_filename
);
11233 /* FIXME: We should check the dwo_id. */
11235 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11237 add_separate_debug_file (separate_filename
, separate_handle
);
11238 /* Note - separate_filename will be freed in free_debug_memory(). */
11239 return separate_handle
;
11243 load_debug_sup_file (const char * main_filename
, void * file
)
11245 if (! load_debug_section (debug_sup
, file
))
11246 return; /* No .debug_sup section. */
11248 struct dwarf_section
* section
;
11249 section
= & debug_displays
[debug_sup
].section
;
11250 assert (section
!= NULL
);
11252 if (section
->start
== NULL
|| section
->size
< 5)
11254 warn (_(".debug_sup section is corrupt/empty\n"));
11258 if (section
->start
[2] != 0)
11259 return; /* This is a supplementary file. */
11261 const char * filename
= (const char *) section
->start
+ 3;
11262 if (strnlen (filename
, section
->size
- 3) == section
->size
- 3)
11264 warn (_("filename in .debug_sup section is corrupt\n"));
11268 if (filename
[0] != '/' && strchr (main_filename
, '/'))
11273 new_len
= asprintf (& new_name
, "%.*s/%s",
11274 (int) (strrchr (main_filename
, '/') - main_filename
),
11279 warn (_("unable to construct path for supplementary debug file"));
11284 filename
= new_name
;
11288 /* PR 27796: Make sure that we pass a filename that can be free'd to
11289 add_separate_debug_file(). */
11290 filename
= strdup (filename
);
11291 if (filename
== NULL
)
11293 warn (_("out of memory constructing filename for .debug_sup link\n"));
11298 void * handle
= open_debug_file (filename
);
11299 if (handle
== NULL
)
11301 warn (_("unable to open file '%s' referenced from .debug_sup section\n"), filename
);
11302 free ((void *) filename
);
11306 printf (_("%s: Found supplementary debug file: %s\n\n"), main_filename
, filename
);
11308 /* FIXME: Compare the checksums, if present. */
11309 add_separate_debug_file (filename
, handle
);
11312 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11313 Recursively check the loaded files for more of these sections.
11314 Also follow any links in .debug_sup sections.
11315 FIXME: Should also check for DWO_* entries in the newly loaded files. */
11318 check_for_and_load_links (void * file
, const char * filename
)
11320 void * handle
= NULL
;
11322 if (load_debug_section (gnu_debugaltlink
, file
))
11324 Build_id_data build_id_data
;
11326 handle
= load_separate_debug_info (filename
,
11327 & debug_displays
[gnu_debugaltlink
].section
,
11328 parse_gnu_debugaltlink
,
11329 check_gnu_debugaltlink
,
11334 assert (handle
== first_separate_info
->handle
);
11335 check_for_and_load_links (first_separate_info
->handle
,
11336 first_separate_info
->filename
);
11340 if (load_debug_section (gnu_debuglink
, file
))
11342 unsigned long crc32
;
11344 handle
= load_separate_debug_info (filename
,
11345 & debug_displays
[gnu_debuglink
].section
,
11346 parse_gnu_debuglink
,
11347 check_gnu_debuglink
,
11352 assert (handle
== first_separate_info
->handle
);
11353 check_for_and_load_links (first_separate_info
->handle
,
11354 first_separate_info
->filename
);
11358 load_debug_sup_file (filename
, file
);
11361 /* Load the separate debug info file(s) attached to FILE, if any exist.
11362 Returns TRUE if any were found, FALSE otherwise.
11363 If TRUE is returned then the linked list starting at first_separate_info
11364 will be populated with open file handles. */
11367 load_separate_debug_files (void * file
, const char * filename
)
11369 /* Skip this operation if we are not interested in debug links. */
11370 if (! do_follow_links
&& ! do_debug_links
)
11373 /* See if there are any dwo links. */
11374 if (load_debug_section (str
, file
)
11375 && load_debug_section (abbrev
, file
)
11376 && load_debug_section (info
, file
))
11380 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
,
11383 bool introduced
= false;
11385 const char *dir
= NULL
;
11386 const char *id
= NULL
;
11387 const char *name
= NULL
;
11389 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11391 /* Accumulate NAME, DIR and ID fields. */
11392 switch (dwinfo
->type
)
11396 warn (_("Multiple DWO_NAMEs encountered for the same CU\n"));
11397 name
= dwinfo
->value
;
11401 /* There can be multiple DW_AT_comp_dir entries in a CU,
11402 so do not complain. */
11403 dir
= dwinfo
->value
;
11408 warn (_("multiple DWO_IDs encountered for the same CU\n"));
11409 id
= dwinfo
->value
;
11413 error (_("Unexpected DWO INFO type"));
11417 /* If we have reached the end of our list, or we are changing
11418 CUs, then display the information that we have accumulated
11421 && (dwinfo
->next
== NULL
11422 || dwinfo
->next
->cu_offset
!= dwinfo
->cu_offset
))
11424 if (do_debug_links
)
11428 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11429 debug_displays
[info
].section
.uncompressed_name
);
11433 printf (_(" Name: %s\n"), name
);
11434 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11436 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11438 printf (_(" ID: <not specified>\n"));
11442 if (do_follow_links
)
11443 load_dwo_file (filename
, name
, dir
, id
);
11445 name
= dir
= id
= NULL
;
11451 if (! do_follow_links
)
11452 /* The other debug links will be displayed by display_debug_links()
11453 so we do not need to do any further processing here. */
11456 /* FIXME: We do not check for the presence of both link sections in the same file. */
11457 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11458 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11460 check_for_and_load_links (file
, filename
);
11461 if (first_separate_info
!= NULL
)
11464 do_follow_links
= 0;
11469 free_debug_memory (void)
11473 free_all_abbrevs ();
11475 free (cu_abbrev_map
);
11476 cu_abbrev_map
= NULL
;
11477 next_free_abbrev_map_entry
= 0;
11481 shndx_pool_size
= 0;
11482 shndx_pool_used
= 0;
11490 memset (level_type_signed
, 0, sizeof level_type_signed
);
11491 cu_tu_indexes_read
= -1;
11493 for (i
= 0; i
< max
; i
++)
11494 free_debug_section ((enum dwarf_section_display_enum
) i
);
11496 if (debug_information
!= NULL
)
11498 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
11500 if (debug_information
[i
].max_loc_offsets
)
11502 free (debug_information
[i
].loc_offsets
);
11503 free (debug_information
[i
].have_frame_base
);
11505 if (debug_information
[i
].max_range_lists
)
11506 free (debug_information
[i
].range_lists
);
11508 free (debug_information
);
11509 debug_information
= NULL
;
11510 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
11514 separate_info
* next
;
11516 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
11518 close_debug_file (d
->handle
);
11519 free ((void *) d
->filename
);
11523 first_separate_info
= NULL
;
11529 dwarf_select_sections_by_names (const char *names
)
11533 const char * option
;
11537 debug_dump_long_opts
;
11539 static const debug_dump_long_opts opts_table
[] =
11541 /* Please keep this table alpha- sorted. */
11542 { "Ranges", & do_debug_ranges
, 1 },
11543 { "abbrev", & do_debug_abbrevs
, 1 },
11544 { "addr", & do_debug_addr
, 1 },
11545 { "aranges", & do_debug_aranges
, 1 },
11546 { "cu_index", & do_debug_cu_index
, 1 },
11547 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
11548 { "follow-links", & do_follow_links
, 1 },
11549 { "frames", & do_debug_frames
, 1 },
11550 { "frames-interp", & do_debug_frames_interp
, 1 },
11551 /* The special .gdb_index section. */
11552 { "gdb_index", & do_gdb_index
, 1 },
11553 { "info", & do_debug_info
, 1 },
11554 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
11555 { "links", & do_debug_links
, 1 },
11556 { "loc", & do_debug_loc
, 1 },
11557 { "macro", & do_debug_macinfo
, 1 },
11558 { "no-follow-links", & do_follow_links
, 0 },
11559 { "pubnames", & do_debug_pubnames
, 1 },
11560 { "pubtypes", & do_debug_pubtypes
, 1 },
11561 /* This entry is for compatibility
11562 with earlier versions of readelf. */
11563 { "ranges", & do_debug_aranges
, 1 },
11564 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
11565 { "str", & do_debug_str
, 1 },
11566 { "str-offsets", & do_debug_str_offsets
, 1 },
11567 /* These trace_* sections are used by Itanium VMS. */
11568 { "trace_abbrev", & do_trace_abbrevs
, 1 },
11569 { "trace_aranges", & do_trace_aranges
, 1 },
11570 { "trace_info", & do_trace_info
, 1 },
11579 const debug_dump_long_opts
* entry
;
11581 for (entry
= opts_table
; entry
->option
; entry
++)
11583 size_t len
= strlen (entry
->option
);
11585 if (strncmp (p
, entry
->option
, len
) == 0
11586 && (p
[len
] == ',' || p
[len
] == '\0'))
11588 * entry
->variable
= entry
->val
;
11590 /* The --debug-dump=frames-interp option also
11591 enables the --debug-dump=frames option. */
11592 if (do_debug_frames_interp
)
11593 do_debug_frames
= 1;
11600 if (entry
->option
== NULL
)
11602 warn (_("Unrecognized debug option '%s'\n"), p
);
11603 p
= strchr (p
, ',');
11614 dwarf_select_sections_by_letters (const char *letters
)
11616 unsigned int lindex
= 0;
11618 while (letters
[lindex
])
11619 switch (letters
[lindex
++])
11621 case 'A': do_debug_addr
= 1; break;
11622 case 'a': do_debug_abbrevs
= 1; break;
11623 case 'c': do_debug_cu_index
= 1; break;
11624 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
11625 case 'f': do_debug_frames
= 1; break;
11626 case 'g': do_gdb_index
= 1; break;
11627 case 'i': do_debug_info
= 1; break;
11628 case 'K': do_follow_links
= 1; break;
11629 case 'N': do_follow_links
= 0; break;
11630 case 'k': do_debug_links
= 1; break;
11631 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
11632 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
11633 case 'm': do_debug_macinfo
= 1; break;
11634 case 'O': do_debug_str_offsets
= 1; break;
11635 case 'o': do_debug_loc
= 1; break;
11636 case 'p': do_debug_pubnames
= 1; break;
11637 case 'R': do_debug_ranges
= 1; break;
11638 case 'r': do_debug_aranges
= 1; break;
11639 case 's': do_debug_str
= 1; break;
11640 case 'T': do_trace_aranges
= 1; break;
11641 case 't': do_debug_pubtypes
= 1; break;
11642 case 'U': do_trace_info
= 1; break;
11643 case 'u': do_trace_abbrevs
= 1; break;
11646 warn (_("Unrecognized debug option '%s'\n"), letters
);
11652 dwarf_select_sections_all (void)
11655 do_debug_abbrevs
= 1;
11656 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
11657 do_debug_pubnames
= 1;
11658 do_debug_pubtypes
= 1;
11659 do_debug_aranges
= 1;
11660 do_debug_ranges
= 1;
11661 do_debug_frames
= 1;
11662 do_debug_macinfo
= 1;
11667 do_trace_abbrevs
= 1;
11668 do_trace_aranges
= 1;
11670 do_debug_cu_index
= 1;
11671 do_follow_links
= 1;
11672 do_debug_links
= 1;
11673 do_debug_str_offsets
= 1;
11676 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0
11677 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0
11679 /* N.B. The order here must match the order in section_display_enum. */
11681 struct dwarf_section_display debug_displays
[] =
11683 { { ".debug_abbrev", ".zdebug_abbrev", ".dwabrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11684 { { ".debug_aranges", ".zdebug_aranges", ".dwarnge", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, true },
11685 { { ".debug_frame", ".zdebug_frame", ".dwframe", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11686 { { ".debug_info", ".zdebug_info", ".dwinfo", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, true },
11687 { { ".debug_line", ".zdebug_line", ".dwline", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11688 { { ".debug_pubnames", ".zdebug_pubnames", ".dwpbnms", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, false },
11689 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, false },
11690 { { ".eh_frame", "", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, true },
11691 { { ".debug_macinfo", ".zdebug_macinfo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11692 { { ".debug_macro", ".zdebug_macro", ".dwmac", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11693 { { ".debug_str", ".zdebug_str", ".dwstr", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11694 { { ".debug_line_str", ".zdebug_line_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11695 { { ".debug_loc", ".zdebug_loc", ".dwloc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11696 { { ".debug_loclists", ".zdebug_loclists", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11697 { { ".debug_pubtypes", ".zdebug_pubtypes", ".dwpbtyp", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, false },
11698 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", "", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, false },
11699 { { ".debug_ranges", ".zdebug_ranges", ".dwrnges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11700 { { ".debug_rnglists", ".zdebug_rnglists", "", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, true },
11701 { { ".debug_static_func", ".zdebug_static_func", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11702 { { ".debug_static_vars", ".zdebug_static_vars", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11703 { { ".debug_types", ".zdebug_types", "", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, true },
11704 { { ".debug_weaknames", ".zdebug_weaknames", "", NO_ABBREVS
}, display_debug_not_supported
, NULL
, false },
11705 { { ".gdb_index", "", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, false },
11706 { { ".debug_names", "", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, false },
11707 { { ".trace_info", "", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, true },
11708 { { ".trace_abbrev", "", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, false },
11709 { { ".trace_aranges", "", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, false },
11710 { { ".debug_info.dwo", ".zdebug_info.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, true },
11711 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", "", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, false },
11712 { { ".debug_types.dwo", ".zdebug_types.dwo", "", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, true },
11713 { { ".debug_line.dwo", ".zdebug_line.dwo", "", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, true },
11714 { { ".debug_loc.dwo", ".zdebug_loc.dwo", "", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, true },
11715 { { ".debug_macro.dwo", ".zdebug_macro.dwo", "", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, true },
11716 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", "", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, false },
11717 { { ".debug_str.dwo", ".zdebug_str.dwo", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, true },
11718 { { ".debug_str_offsets", ".zdebug_str_offsets", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11719 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", "", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, true },
11720 { { ".debug_addr", ".zdebug_addr", "", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, true },
11721 { { ".debug_cu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11722 { { ".debug_tu_index", "", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, false },
11723 { { ".gnu_debuglink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11724 { { ".gnu_debugaltlink", "", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, false },
11725 { { ".debug_sup", "", "", NO_ABBREVS
}, display_debug_sup
, &do_debug_links
, false },
11726 /* Separate debug info files can containt their own .debug_str section,
11727 and this might be in *addition* to a .debug_str section already present
11728 in the main file. Hence we need to have two entries for .debug_str. */
11729 { { ".debug_str", ".zdebug_str", "", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, false },
11732 /* A static assertion. */
11733 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];