1 /* dwarf.c -- display DWARF contents of a BFD binary file
2 Copyright (C) 2005-2020 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 #include "libiberty.h"
24 #include "bfd_stdint.h"
27 #include "elf/common.h"
30 #include "gdb/gdb-index.h"
31 #include "filenames.h"
32 #include "safe-ctype.h"
35 #ifdef HAVE_LIBDEBUGINFOD
36 #include <elfutils/debuginfod.h>
41 #define MAX(a, b) ((a) > (b) ? (a) : (b))
42 #define MIN(a, b) ((a) < (b) ? (a) : (b))
44 static const char *regname (unsigned int regno
, int row
);
45 static const char *regname_internal_by_table_only (unsigned int regno
);
47 static int have_frame_base
;
48 static int need_base_address
;
50 static unsigned int num_debug_info_entries
= 0;
51 static unsigned int alloc_num_debug_info_entries
= 0;
52 static debug_info
*debug_information
= NULL
;
53 /* Special value for num_debug_info_entries to indicate
54 that the .debug_info section could not be loaded/parsed. */
55 #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1
57 /* A .debug_info section can contain multiple links to separate
58 DWO object files. We use these structures to record these links. */
66 typedef struct dwo_info
70 struct dwo_info
* next
;
73 static dwo_info
* first_dwo_info
= NULL
;
74 static bfd_boolean need_dwo_info
;
76 separate_info
* first_separate_info
= NULL
;
78 unsigned int eh_addr_size
;
83 int do_debug_pubnames
;
84 int do_debug_pubtypes
;
88 int do_debug_frames_interp
;
91 int do_debug_str_offsets
;
98 int do_debug_cu_index
;
102 bfd_boolean do_checks
;
104 int dwarf_cutoff_level
= -1;
105 unsigned long dwarf_start_die
;
109 /* Convenient constant, to avoid having to cast -1 to dwarf_vma when
110 testing whether e.g. a locview list is present. */
111 static const dwarf_vma vm1
= -1;
113 /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index
114 sections. For version 1 package files, each set is stored in SHNDX_POOL
115 as a zero-terminated list of section indexes comprising one set of debug
116 sections from a .dwo file. */
118 static unsigned int *shndx_pool
= NULL
;
119 static unsigned int shndx_pool_size
= 0;
120 static unsigned int shndx_pool_used
= 0;
122 /* For version 2 package files, each set contains an array of section offsets
123 and an array of section sizes, giving the offset and size of the
124 contribution from a CU or TU within one of the debug sections.
125 When displaying debug info from a package file, we need to use these
126 tables to locate the corresponding contributions to each section. */
131 dwarf_vma section_offsets
[DW_SECT_MAX
];
132 size_t section_sizes
[DW_SECT_MAX
];
135 static int cu_count
= 0;
136 static int tu_count
= 0;
137 static struct cu_tu_set
*cu_sets
= NULL
;
138 static struct cu_tu_set
*tu_sets
= NULL
;
140 static bfd_boolean
load_cu_tu_indexes (void *);
142 /* An array that indicates for a given level of CU nesting whether
143 the latest DW_AT_type seen for that level was a signed type or
145 #define MAX_CU_NESTING (1 << 8)
146 static bfd_boolean level_type_signed
[MAX_CU_NESTING
];
148 /* Values for do_debug_lines. */
149 #define FLAG_DEBUG_LINES_RAW 1
150 #define FLAG_DEBUG_LINES_DECODED 2
153 size_of_encoded_value (int encoding
)
155 switch (encoding
& 0x7)
158 case 0: return eh_addr_size
;
166 get_encoded_value (unsigned char **pdata
,
168 struct dwarf_section
*section
,
171 unsigned char * data
= * pdata
;
172 unsigned int size
= size_of_encoded_value (encoding
);
175 if (data
+ size
>= end
)
177 warn (_("Encoded value extends past end of section\n"));
182 /* PR 17512: file: 002-829853-0.004. */
185 warn (_("Encoded size of %d is too large to read\n"), size
);
190 /* PR 17512: file: 1085-5603-0.004. */
193 warn (_("Encoded size of 0 is too small to read\n"));
198 if (encoding
& DW_EH_PE_signed
)
199 val
= byte_get_signed (data
, size
);
201 val
= byte_get (data
, size
);
203 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
204 val
+= section
->address
+ (data
- section
->start
);
206 * pdata
= data
+ size
;
210 #if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG
212 # define DWARF_VMA_FMT "ll"
213 # define DWARF_VMA_FMT_LONG "%16.16llx"
215 # define DWARF_VMA_FMT "I64"
216 # define DWARF_VMA_FMT_LONG "%016I64x"
219 # define DWARF_VMA_FMT "l"
220 # define DWARF_VMA_FMT_LONG "%16.16lx"
223 /* Convert a dwarf vma value into a string. Returns a pointer to a static
224 buffer containing the converted VALUE. The value is converted according
225 to the printf formating character FMTCH. If NUM_BYTES is non-zero then
226 it specifies the maximum number of bytes to be displayed in the converted
227 value and FMTCH is ignored - hex is always used. */
230 dwarf_vmatoa_1 (const char *fmtch
, dwarf_vma value
, unsigned num_bytes
)
232 /* As dwarf_vmatoa is used more then once in a printf call
233 for output, we are cycling through an fixed array of pointers
234 for return address. */
235 static int buf_pos
= 0;
236 static struct dwarf_vmatoa_buf
242 ret
= buf
[buf_pos
++].place
;
243 buf_pos
%= ARRAY_SIZE (buf
);
247 /* Printf does not have a way of specifying a maximum field width for an
248 integer value, so we print the full value into a buffer and then select
249 the precision we need. */
250 snprintf (ret
, sizeof (buf
[0].place
), DWARF_VMA_FMT_LONG
, value
);
253 return ret
+ (16 - 2 * num_bytes
);
260 sprintf (fmt
, "%%%s%s", DWARF_VMA_FMT
, fmtch
);
262 sprintf (fmt
, "%%%s", DWARF_VMA_FMT
);
263 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
268 static inline const char *
269 dwarf_vmatoa (const char * fmtch
, dwarf_vma value
)
271 return dwarf_vmatoa_1 (fmtch
, value
, 0);
274 /* Print a dwarf_vma value (typically an address, offset or length) in
275 hexadecimal format, followed by a space. The length of the VALUE (and
276 hence the precision displayed) is determined by the NUM_BYTES parameter. */
279 print_dwarf_vma (dwarf_vma value
, unsigned num_bytes
)
281 printf ("%s ", dwarf_vmatoa_1 (NULL
, value
, num_bytes
));
284 /* Print a view number in hexadecimal value, with the same width
285 print_dwarf_vma would have printed it with the same num_bytes.
286 Print blanks for zero view, unless force is nonzero. */
289 print_dwarf_view (dwarf_vma value
, unsigned num_bytes
, int force
)
297 assert (value
== (unsigned long) value
);
299 printf ("v%0*lx ", len
- 1, (unsigned long) value
);
301 printf ("%*s", len
+ 1, "");
304 /* Format a 64-bit value, given as two 32-bit values, in hex.
305 For reentrancy, this uses a buffer provided by the caller. */
308 dwarf_vmatoa64 (dwarf_vma hvalue
, dwarf_vma lvalue
, char *buf
,
309 unsigned int buf_len
)
314 snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", lvalue
);
317 len
= snprintf (buf
, buf_len
, "%" DWARF_VMA_FMT
"x", hvalue
);
318 snprintf (buf
+ len
, buf_len
- len
,
319 "%08" DWARF_VMA_FMT
"x", lvalue
);
325 /* Read in a LEB128 encoded value starting at address DATA.
326 If SIGN is true, return a signed LEB128 value.
327 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
328 If STATUS_RETURN in not NULL, return with bit 0 (LSB) set if the
329 terminating byte was not found and with bit 1 set if the value
330 overflows a dwarf_vma.
331 No bytes will be read at address END or beyond. */
334 read_leb128 (unsigned char *data
,
335 const unsigned char *const end
,
337 unsigned int *length_return
,
340 dwarf_vma result
= 0;
341 unsigned int num_read
= 0;
342 unsigned int shift
= 0;
347 unsigned char byte
= *data
++;
348 bfd_boolean cont
= (byte
& 0x80) ? TRUE
: FALSE
;
353 if (shift
< sizeof (result
) * 8)
355 result
|= ((dwarf_vma
) byte
) << shift
;
358 if ((((dwarf_signed_vma
) result
>> shift
) & 0x7f) != byte
)
362 else if ((result
>> shift
) != byte
)
378 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
379 result
|= -((dwarf_vma
) 1 << shift
);
384 if (length_return
!= NULL
)
385 *length_return
= num_read
;
386 if (status_return
!= NULL
)
387 *status_return
= status
;
392 /* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value.
393 Checks to make sure that the read will not reach or pass END
394 and that VAL is big enough to hold AMOUNT bytes. */
395 #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \
398 unsigned int amount = (AMOUNT); \
399 if (sizeof (VAL) < amount) \
401 error (ngettext ("internal error: attempt to read %d byte " \
402 "of data in to %d sized variable", \
403 "internal error: attempt to read %d bytes " \
404 "of data in to %d sized variable", \
406 amount, (int) sizeof (VAL)); \
407 amount = sizeof (VAL); \
409 if (((PTR) + amount) >= (END)) \
412 amount = (END) - (PTR); \
416 if (amount == 0 || amount > 8) \
419 VAL = byte_get ((PTR), amount); \
423 /* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */
424 #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
427 SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \
432 /* Like SAFE_BYTE_GET, but reads a signed value. */
433 #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \
436 unsigned int amount = (AMOUNT); \
437 if (((PTR) + amount) >= (END)) \
440 amount = (END) - (PTR); \
445 VAL = byte_get_signed ((PTR), amount); \
451 /* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */
452 #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \
455 SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \
460 #define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \
463 if (((PTR) + 8) <= (END)) \
465 byte_get_64 ((PTR), (HIGH), (LOW)); \
469 * (LOW) = * (HIGH) = 0; \
474 typedef struct State_Machine_Registers
483 unsigned char op_index
;
484 unsigned char end_sequence
;
485 /* This variable hold the number of the last entry seen
486 in the File Table. */
487 unsigned int last_file_entry
;
490 static SMR state_machine_regs
;
493 reset_state_machine (int is_stmt
)
495 state_machine_regs
.address
= 0;
496 state_machine_regs
.view
= 0;
497 state_machine_regs
.op_index
= 0;
498 state_machine_regs
.file
= 1;
499 state_machine_regs
.line
= 1;
500 state_machine_regs
.column
= 0;
501 state_machine_regs
.is_stmt
= is_stmt
;
502 state_machine_regs
.basic_block
= 0;
503 state_machine_regs
.end_sequence
= 0;
504 state_machine_regs
.last_file_entry
= 0;
507 /* Handled an extend line op.
508 Returns the number of bytes read. */
511 process_extended_line_op (unsigned char * data
,
515 unsigned char op_code
;
516 size_t len
, header_len
;
518 unsigned char *orig_data
= data
;
521 READ_ULEB (len
, data
, end
);
522 header_len
= data
- orig_data
;
524 if (len
== 0 || data
== end
|| len
> (size_t) (end
- data
))
526 warn (_("Badly formed extended line op encountered!\n"));
532 printf (_(" Extended opcode %d: "), op_code
);
536 case DW_LNE_end_sequence
:
537 printf (_("End of Sequence\n\n"));
538 reset_state_machine (is_stmt
);
541 case DW_LNE_set_address
:
542 /* PR 17512: file: 002-100480-0.004. */
545 warn (_("Length (%lu) of DW_LNE_set_address op is too long\n"),
546 (unsigned long) len
- 1);
550 SAFE_BYTE_GET (adr
, data
, len
- 1, end
);
551 printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr
));
552 state_machine_regs
.address
= adr
;
553 state_machine_regs
.view
= 0;
554 state_machine_regs
.op_index
= 0;
557 case DW_LNE_define_file
:
558 printf (_("define new File Table entry\n"));
559 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
560 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
566 l
= strnlen ((char *) data
, end
- data
);
568 READ_ULEB (val
, data
, end
);
569 printf ("%s\t", dwarf_vmatoa ("u", val
));
570 READ_ULEB (val
, data
, end
);
571 printf ("%s\t", dwarf_vmatoa ("u", val
));
572 READ_ULEB (val
, data
, end
);
573 printf ("%s\t", dwarf_vmatoa ("u", val
));
574 printf ("%.*s\n\n", (int) l
, name
);
577 if (((size_t) (data
- orig_data
) != len
+ header_len
) || data
== end
)
578 warn (_("DW_LNE_define_file: Bad opcode length\n"));
581 case DW_LNE_set_discriminator
:
582 READ_ULEB (val
, data
, end
);
583 printf (_("set Discriminator to %s\n"), dwarf_vmatoa ("u", val
));
587 case DW_LNE_HP_negate_is_UV_update
:
588 printf ("DW_LNE_HP_negate_is_UV_update\n");
590 case DW_LNE_HP_push_context
:
591 printf ("DW_LNE_HP_push_context\n");
593 case DW_LNE_HP_pop_context
:
594 printf ("DW_LNE_HP_pop_context\n");
596 case DW_LNE_HP_set_file_line_column
:
597 printf ("DW_LNE_HP_set_file_line_column\n");
599 case DW_LNE_HP_set_routine_name
:
600 printf ("DW_LNE_HP_set_routine_name\n");
602 case DW_LNE_HP_set_sequence
:
603 printf ("DW_LNE_HP_set_sequence\n");
605 case DW_LNE_HP_negate_post_semantics
:
606 printf ("DW_LNE_HP_negate_post_semantics\n");
608 case DW_LNE_HP_negate_function_exit
:
609 printf ("DW_LNE_HP_negate_function_exit\n");
611 case DW_LNE_HP_negate_front_end_logical
:
612 printf ("DW_LNE_HP_negate_front_end_logical\n");
614 case DW_LNE_HP_define_proc
:
615 printf ("DW_LNE_HP_define_proc\n");
617 case DW_LNE_HP_source_file_correlation
:
619 unsigned char *edata
= data
+ len
- 1;
621 printf ("DW_LNE_HP_source_file_correlation\n");
627 READ_ULEB (opc
, data
, edata
);
631 case DW_LNE_HP_SFC_formfeed
:
632 printf (" DW_LNE_HP_SFC_formfeed\n");
634 case DW_LNE_HP_SFC_set_listing_line
:
635 READ_ULEB (val
, data
, edata
);
636 printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n",
637 dwarf_vmatoa ("u", val
));
639 case DW_LNE_HP_SFC_associate
:
640 printf (" DW_LNE_HP_SFC_associate ");
641 READ_ULEB (val
, data
, edata
);
642 printf ("(%s", dwarf_vmatoa ("u", val
));
643 READ_ULEB (val
, data
, edata
);
644 printf (",%s", dwarf_vmatoa ("u", val
));
645 READ_ULEB (val
, data
, edata
);
646 printf (",%s)\n", dwarf_vmatoa ("u", val
));
649 printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc
);
659 unsigned int rlen
= len
- 1;
661 if (op_code
>= DW_LNE_lo_user
662 /* The test against DW_LNW_hi_user is redundant due to
663 the limited range of the unsigned char data type used
665 /*&& op_code <= DW_LNE_hi_user*/)
666 printf (_("user defined: "));
668 printf (_("UNKNOWN: "));
669 printf (_("length %d ["), rlen
);
671 printf (" %02x", *data
++);
677 return len
+ header_len
;
680 static const unsigned char *
681 fetch_indirect_string (dwarf_vma offset
)
683 struct dwarf_section
*section
= &debug_displays
[str
].section
;
684 const unsigned char * ret
;
686 if (section
->start
== NULL
)
687 return (const unsigned char *) _("<no .debug_str section>");
689 if (offset
>= section
->size
)
691 warn (_("DW_FORM_strp offset too big: %s\n"),
692 dwarf_vmatoa ("x", offset
));
693 return (const unsigned char *) _("<offset is too big>");
696 ret
= section
->start
+ offset
;
697 /* Unfortunately we cannot rely upon the .debug_str section ending with a
698 NUL byte. Since our caller is expecting to receive a well formed C
699 string we test for the lack of a terminating byte here. */
700 if (strnlen ((const char *) ret
, section
->size
- offset
)
701 == section
->size
- offset
)
702 ret
= (const unsigned char *)
703 _("<no NUL byte at end of .debug_str section>");
708 static const unsigned char *
709 fetch_indirect_line_string (dwarf_vma offset
)
711 struct dwarf_section
*section
= &debug_displays
[line_str
].section
;
712 const unsigned char * ret
;
714 if (section
->start
== NULL
)
715 return (const unsigned char *) _("<no .debug_line_str section>");
717 if (offset
>= section
->size
)
719 warn (_("DW_FORM_line_strp offset too big: %s\n"),
720 dwarf_vmatoa ("x", offset
));
721 return (const unsigned char *) _("<offset is too big>");
724 ret
= section
->start
+ offset
;
725 /* Unfortunately we cannot rely upon the .debug_line_str section ending
726 with a NUL byte. Since our caller is expecting to receive a well formed
727 C string we test for the lack of a terminating byte here. */
728 if (strnlen ((const char *) ret
, section
->size
- offset
)
729 == section
->size
- offset
)
730 ret
= (const unsigned char *)
731 _("<no NUL byte at end of .debug_line_str section>");
737 fetch_indexed_string (dwarf_vma idx
, struct cu_tu_set
*this_set
,
738 dwarf_vma offset_size
, bfd_boolean dwo
)
740 enum dwarf_section_display_enum str_sec_idx
= dwo
? str_dwo
: str
;
741 enum dwarf_section_display_enum idx_sec_idx
= dwo
? str_index_dwo
: str_index
;
742 struct dwarf_section
*index_section
= &debug_displays
[idx_sec_idx
].section
;
743 struct dwarf_section
*str_section
= &debug_displays
[str_sec_idx
].section
;
744 dwarf_vma index_offset
;
745 dwarf_vma str_offset
;
747 unsigned char *curr
= index_section
->start
;
748 const unsigned char *end
= curr
+ index_section
->size
;
751 if (index_section
->start
== NULL
)
752 return (dwo
? _("<no .debug_str_offsets.dwo section>")
753 : _("<no .debug_str_offsets section>"));
755 if (str_section
->start
== NULL
)
756 return (dwo
? _("<no .debug_str.dwo section>")
757 : _("<no .debug_str section>"));
759 /* FIXME: We should cache the length... */
760 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
761 if (length
== 0xffffffff)
763 if (offset_size
!= 8)
764 warn (_("Expected offset size of 8 but given %s"), dwarf_vmatoa ("x", offset_size
));
765 SAFE_BYTE_GET_AND_INC (length
, curr
, 8, end
);
767 else if (offset_size
!= 4)
769 warn (_("Expected offset size of 4 but given %s"), dwarf_vmatoa ("x", offset_size
));
774 /* This is probably an old style .debug_str_offset section which
775 just contains offsets and no header (and the first offset is 0). */
776 curr
= index_section
->start
;
777 length
= index_section
->size
;
781 /* Skip the version and padding bytes.
782 We assume that they are correct. */
785 /* FIXME: The code below assumes that there is only one table
786 in the .debug_str_offsets section, so check that now. */
787 if ((offset_size
== 4 && curr
+ length
< (end
- 8))
788 || (offset_size
== 8 && curr
+ length
< (end
- 16)))
790 warn (_("index table size is too small %s vs %s\n"),
791 dwarf_vmatoa ("x", length
),
792 dwarf_vmatoa ("x", index_section
->size
));
793 return _("<table too small>");
797 index_offset
= idx
* offset_size
;
799 if (this_set
!= NULL
)
800 index_offset
+= this_set
->section_offsets
[DW_SECT_STR_OFFSETS
];
802 if (index_offset
>= length
)
804 warn (_("DW_FORM_GNU_str_index offset too big: %s vs %s\n"),
805 dwarf_vmatoa ("x", index_offset
),
806 dwarf_vmatoa ("x", length
));
807 return _("<index offset is too big>");
810 str_offset
= byte_get (curr
+ index_offset
, offset_size
);
811 str_offset
-= str_section
->address
;
812 if (str_offset
>= str_section
->size
)
814 warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),
815 dwarf_vmatoa ("x", str_offset
));
816 return _("<indirect index offset is too big>");
819 ret
= (const char *) str_section
->start
+ str_offset
;
820 /* Unfortunately we cannot rely upon str_section ending with a NUL byte.
821 Since our caller is expecting to receive a well formed C string we test
822 for the lack of a terminating byte here. */
823 if (strnlen (ret
, str_section
->size
- str_offset
)
824 == str_section
->size
- str_offset
)
825 ret
= (const char *) _("<no NUL byte at end of section>");
831 fetch_indexed_value (dwarf_vma offset
, dwarf_vma bytes
)
833 struct dwarf_section
*section
= &debug_displays
[debug_addr
].section
;
835 if (section
->start
== NULL
)
836 return (_("<no .debug_addr section>"));
838 if (offset
+ bytes
> section
->size
)
840 warn (_("Offset into section %s too big: %s\n"),
841 section
->name
, dwarf_vmatoa ("x", offset
));
842 return "<offset too big>";
845 return dwarf_vmatoa ("x", byte_get (section
->start
+ offset
, bytes
));
849 /* FIXME: There are better and more efficient ways to handle
850 these structures. For now though, I just want something that
851 is simple to implement. */
852 /* Records a single attribute in an abbrev. */
853 typedef struct abbrev_attr
855 unsigned long attribute
;
857 bfd_signed_vma implicit_const
;
858 struct abbrev_attr
* next
;
862 /* Records a single abbrev. */
863 typedef struct abbrev_entry
865 unsigned long number
;
868 struct abbrev_attr
* first_attr
;
869 struct abbrev_attr
* last_attr
;
870 struct abbrev_entry
* next
;
874 /* Records a set of abbreviations. */
875 typedef struct abbrev_list
877 abbrev_entry
* first_abbrev
;
878 abbrev_entry
* last_abbrev
;
879 dwarf_vma abbrev_base
;
880 dwarf_vma abbrev_offset
;
881 struct abbrev_list
* next
;
882 unsigned char * start_of_next_abbrevs
;
886 /* Records all the abbrevs found so far. */
887 static struct abbrev_list
* abbrev_lists
= NULL
;
889 typedef struct abbrev_map
896 /* Maps between CU offsets and abbrev sets. */
897 static abbrev_map
* cu_abbrev_map
= NULL
;
898 static unsigned long num_abbrev_map_entries
= 0;
899 static unsigned long next_free_abbrev_map_entry
= 0;
901 #define INITIAL_NUM_ABBREV_MAP_ENTRIES 8
902 #define ABBREV_MAP_ENTRIES_INCREMENT 8
905 record_abbrev_list_for_cu (dwarf_vma start
, dwarf_vma end
, abbrev_list
* list
)
907 if (cu_abbrev_map
== NULL
)
909 num_abbrev_map_entries
= INITIAL_NUM_ABBREV_MAP_ENTRIES
;
910 cu_abbrev_map
= xmalloc (num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
912 else if (next_free_abbrev_map_entry
== num_abbrev_map_entries
)
914 num_abbrev_map_entries
+= ABBREV_MAP_ENTRIES_INCREMENT
;
915 cu_abbrev_map
= xrealloc (cu_abbrev_map
, num_abbrev_map_entries
* sizeof (* cu_abbrev_map
));
918 cu_abbrev_map
[next_free_abbrev_map_entry
].start
= start
;
919 cu_abbrev_map
[next_free_abbrev_map_entry
].end
= end
;
920 cu_abbrev_map
[next_free_abbrev_map_entry
].list
= list
;
921 next_free_abbrev_map_entry
++;
925 free_all_abbrevs (void)
929 for (list
= abbrev_lists
; list
!= NULL
;)
931 abbrev_list
* next
= list
->next
;
932 abbrev_entry
* abbrv
;
934 for (abbrv
= list
->first_abbrev
; abbrv
!= NULL
;)
936 abbrev_entry
* next_abbrev
= abbrv
->next
;
939 for (attr
= abbrv
->first_attr
; attr
;)
941 abbrev_attr
*next_attr
= attr
->next
;
959 new_abbrev_list (dwarf_vma abbrev_base
, dwarf_vma abbrev_offset
)
961 abbrev_list
* list
= (abbrev_list
*) xcalloc (sizeof * list
, 1);
963 list
->abbrev_base
= abbrev_base
;
964 list
->abbrev_offset
= abbrev_offset
;
966 list
->next
= abbrev_lists
;
973 find_abbrev_list_by_abbrev_offset (dwarf_vma abbrev_base
,
974 dwarf_vma abbrev_offset
)
978 for (list
= abbrev_lists
; list
!= NULL
; list
= list
->next
)
979 if (list
->abbrev_base
== abbrev_base
980 && list
->abbrev_offset
== abbrev_offset
)
986 /* Find the abbreviation map for the CU that includes OFFSET.
987 OFFSET is an absolute offset from the start of the .debug_info section. */
988 /* FIXME: This function is going to slow down readelf & objdump.
989 Consider using a better algorithm to mitigate this effect. */
992 find_abbrev_map_by_offset (dwarf_vma offset
)
996 for (i
= 0; i
< next_free_abbrev_map_entry
; i
++)
997 if (cu_abbrev_map
[i
].start
<= offset
998 && cu_abbrev_map
[i
].end
> offset
)
999 return cu_abbrev_map
+ i
;
1005 add_abbrev (unsigned long number
,
1010 abbrev_entry
* entry
;
1012 entry
= (abbrev_entry
*) xmalloc (sizeof (*entry
));
1014 entry
->number
= number
;
1016 entry
->children
= children
;
1017 entry
->first_attr
= NULL
;
1018 entry
->last_attr
= NULL
;
1021 assert (list
!= NULL
);
1023 if (list
->first_abbrev
== NULL
)
1024 list
->first_abbrev
= entry
;
1026 list
->last_abbrev
->next
= entry
;
1028 list
->last_abbrev
= entry
;
1032 add_abbrev_attr (unsigned long attribute
,
1034 bfd_signed_vma implicit_const
,
1039 attr
= (abbrev_attr
*) xmalloc (sizeof (*attr
));
1041 attr
->attribute
= attribute
;
1043 attr
->implicit_const
= implicit_const
;
1046 assert (list
!= NULL
&& list
->last_abbrev
!= NULL
);
1048 if (list
->last_abbrev
->first_attr
== NULL
)
1049 list
->last_abbrev
->first_attr
= attr
;
1051 list
->last_abbrev
->last_attr
->next
= attr
;
1053 list
->last_abbrev
->last_attr
= attr
;
1056 /* Processes the (partial) contents of a .debug_abbrev section.
1057 Returns NULL if the end of the section was encountered.
1058 Returns the address after the last byte read if the end of
1059 an abbreviation set was found. */
1061 static unsigned char *
1062 process_abbrev_set (unsigned char * start
,
1063 const unsigned char * end
,
1068 unsigned long entry
;
1070 unsigned long attribute
;
1073 READ_ULEB (entry
, start
, end
);
1075 /* A single zero is supposed to end the set according
1076 to the standard. If there's more, then signal that to
1083 READ_ULEB (tag
, start
, end
);
1087 children
= *start
++;
1089 add_abbrev (entry
, tag
, children
, list
);
1094 /* Initialize it due to a false compiler warning. */
1095 bfd_signed_vma implicit_const
= -1;
1097 READ_ULEB (attribute
, start
, end
);
1101 READ_ULEB (form
, start
, end
);
1105 if (form
== DW_FORM_implicit_const
)
1107 READ_SLEB (implicit_const
, start
, end
);
1112 add_abbrev_attr (attribute
, form
, implicit_const
, list
);
1114 while (attribute
!= 0);
1117 /* Report the missing single zero which ends the section. */
1118 error (_(".debug_abbrev section not zero terminated\n"));
1124 get_TAG_name (unsigned long tag
)
1126 const char *name
= get_DW_TAG_name ((unsigned int) tag
);
1130 static char buffer
[100];
1132 if (tag
>= DW_TAG_lo_user
&& tag
<= DW_TAG_hi_user
)
1133 snprintf (buffer
, sizeof (buffer
), _("User TAG value: %#lx"), tag
);
1135 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %#lx"), tag
);
1143 get_FORM_name (unsigned long form
)
1148 return "DW_FORM value: 0";
1150 name
= get_DW_FORM_name (form
);
1153 static char buffer
[100];
1155 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
1163 get_IDX_name (unsigned long idx
)
1165 const char *name
= get_DW_IDX_name ((unsigned int) idx
);
1169 static char buffer
[100];
1171 snprintf (buffer
, sizeof (buffer
), _("Unknown IDX value: %lx"), idx
);
1178 static unsigned char *
1179 display_block (unsigned char *data
,
1181 const unsigned char * const end
, char delimiter
)
1185 printf (_("%c%s byte block: "), delimiter
, dwarf_vmatoa ("u", length
));
1187 return (unsigned char *) end
;
1189 maxlen
= (dwarf_vma
) (end
- data
);
1190 length
= length
> maxlen
? maxlen
: length
;
1193 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
1199 decode_location_expression (unsigned char * data
,
1200 unsigned int pointer_size
,
1201 unsigned int offset_size
,
1204 dwarf_vma cu_offset
,
1205 struct dwarf_section
* section
)
1209 dwarf_signed_vma svalue
;
1210 unsigned char *end
= data
+ length
;
1211 int need_frame_base
= 0;
1220 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1221 printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue
));
1224 printf ("DW_OP_deref");
1227 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1228 printf ("DW_OP_const1u: %lu", (unsigned long) uvalue
);
1231 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 1, end
);
1232 printf ("DW_OP_const1s: %ld", (long) svalue
);
1235 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
1236 printf ("DW_OP_const2u: %lu", (unsigned long) uvalue
);
1239 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1240 printf ("DW_OP_const2s: %ld", (long) svalue
);
1243 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1244 printf ("DW_OP_const4u: %lu", (unsigned long) uvalue
);
1247 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1248 printf ("DW_OP_const4s: %ld", (long) svalue
);
1251 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1252 printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue
);
1253 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1254 printf ("%lu", (unsigned long) uvalue
);
1257 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1258 printf ("DW_OP_const8s: %ld ", (long) svalue
);
1259 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1260 printf ("%ld", (long) svalue
);
1263 READ_ULEB (uvalue
, data
, end
);
1264 printf ("DW_OP_constu: %s", dwarf_vmatoa ("u", uvalue
));
1267 READ_SLEB (svalue
, data
, end
);
1268 printf ("DW_OP_consts: %s", dwarf_vmatoa ("d", svalue
));
1271 printf ("DW_OP_dup");
1274 printf ("DW_OP_drop");
1277 printf ("DW_OP_over");
1280 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1281 printf ("DW_OP_pick: %ld", (unsigned long) uvalue
);
1284 printf ("DW_OP_swap");
1287 printf ("DW_OP_rot");
1290 printf ("DW_OP_xderef");
1293 printf ("DW_OP_abs");
1296 printf ("DW_OP_and");
1299 printf ("DW_OP_div");
1302 printf ("DW_OP_minus");
1305 printf ("DW_OP_mod");
1308 printf ("DW_OP_mul");
1311 printf ("DW_OP_neg");
1314 printf ("DW_OP_not");
1317 printf ("DW_OP_or");
1320 printf ("DW_OP_plus");
1322 case DW_OP_plus_uconst
:
1323 READ_ULEB (uvalue
, data
, end
);
1324 printf ("DW_OP_plus_uconst: %s", dwarf_vmatoa ("u", uvalue
));
1327 printf ("DW_OP_shl");
1330 printf ("DW_OP_shr");
1333 printf ("DW_OP_shra");
1336 printf ("DW_OP_xor");
1339 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1340 printf ("DW_OP_bra: %ld", (long) svalue
);
1343 printf ("DW_OP_eq");
1346 printf ("DW_OP_ge");
1349 printf ("DW_OP_gt");
1352 printf ("DW_OP_le");
1355 printf ("DW_OP_lt");
1358 printf ("DW_OP_ne");
1361 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 2, end
);
1362 printf ("DW_OP_skip: %ld", (long) svalue
);
1397 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
1432 printf ("DW_OP_reg%d (%s)", op
- DW_OP_reg0
,
1433 regname (op
- DW_OP_reg0
, 1));
1468 READ_SLEB (svalue
, data
, end
);
1469 printf ("DW_OP_breg%d (%s): %s", op
- DW_OP_breg0
,
1470 regname (op
- DW_OP_breg0
, 1), dwarf_vmatoa ("d", svalue
));
1474 READ_ULEB (uvalue
, data
, end
);
1475 printf ("DW_OP_regx: %s (%s)",
1476 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1479 need_frame_base
= 1;
1480 READ_SLEB (svalue
, data
, end
);
1481 printf ("DW_OP_fbreg: %s", dwarf_vmatoa ("d", svalue
));
1484 READ_ULEB (uvalue
, data
, end
);
1485 READ_SLEB (svalue
, data
, end
);
1486 printf ("DW_OP_bregx: %s (%s) %s",
1487 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1),
1488 dwarf_vmatoa ("d", svalue
));
1491 READ_ULEB (uvalue
, data
, end
);
1492 printf ("DW_OP_piece: %s", dwarf_vmatoa ("u", uvalue
));
1494 case DW_OP_deref_size
:
1495 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1496 printf ("DW_OP_deref_size: %ld", (long) uvalue
);
1498 case DW_OP_xderef_size
:
1499 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1500 printf ("DW_OP_xderef_size: %ld", (long) uvalue
);
1503 printf ("DW_OP_nop");
1506 /* DWARF 3 extensions. */
1507 case DW_OP_push_object_address
:
1508 printf ("DW_OP_push_object_address");
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
, 2, end
);
1514 printf ("DW_OP_call2: <0x%s>",
1515 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1518 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1519 this ought to be an 8-byte wide computation. */
1520 SAFE_SIGNED_BYTE_GET_AND_INC (svalue
, data
, 4, end
);
1521 printf ("DW_OP_call4: <0x%s>",
1522 dwarf_vmatoa ("x", svalue
+ cu_offset
));
1524 case DW_OP_call_ref
:
1525 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1526 this ought to be an 8-byte wide computation. */
1527 if (dwarf_version
== -1)
1529 printf (_("(DW_OP_call_ref in frame info)"));
1530 /* No way to tell where the next op is, so just bail. */
1531 return need_frame_base
;
1533 if (dwarf_version
== 2)
1535 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1539 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1541 printf ("DW_OP_call_ref: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1543 case DW_OP_form_tls_address
:
1544 printf ("DW_OP_form_tls_address");
1546 case DW_OP_call_frame_cfa
:
1547 printf ("DW_OP_call_frame_cfa");
1549 case DW_OP_bit_piece
:
1550 printf ("DW_OP_bit_piece: ");
1551 READ_ULEB (uvalue
, data
, end
);
1552 printf (_("size: %s "), dwarf_vmatoa ("u", uvalue
));
1553 READ_ULEB (uvalue
, data
, end
);
1554 printf (_("offset: %s "), dwarf_vmatoa ("u", uvalue
));
1557 /* DWARF 4 extensions. */
1558 case DW_OP_stack_value
:
1559 printf ("DW_OP_stack_value");
1562 case DW_OP_implicit_value
:
1563 printf ("DW_OP_implicit_value");
1564 READ_ULEB (uvalue
, data
, end
);
1565 data
= display_block (data
, uvalue
, end
, ' ');
1568 /* GNU extensions. */
1569 case DW_OP_GNU_push_tls_address
:
1570 printf (_("DW_OP_GNU_push_tls_address or DW_OP_HP_unknown"));
1572 case DW_OP_GNU_uninit
:
1573 printf ("DW_OP_GNU_uninit");
1574 /* FIXME: Is there data associated with this OP ? */
1576 case DW_OP_GNU_encoded_addr
:
1583 addr
= get_encoded_value (&data
, encoding
, section
, end
);
1585 printf ("DW_OP_GNU_encoded_addr: fmt:%02x addr:", encoding
);
1586 print_dwarf_vma (addr
, pointer_size
);
1589 case DW_OP_implicit_pointer
:
1590 case DW_OP_GNU_implicit_pointer
:
1591 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1592 this ought to be an 8-byte wide computation. */
1593 if (dwarf_version
== -1)
1595 printf (_("(%s in frame info)"),
1596 (op
== DW_OP_implicit_pointer
1597 ? "DW_OP_implicit_pointer"
1598 : "DW_OP_GNU_implicit_pointer"));
1599 /* No way to tell where the next op is, so just bail. */
1600 return need_frame_base
;
1602 if (dwarf_version
== 2)
1604 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1608 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1610 READ_SLEB (svalue
, data
, end
);
1611 printf ("%s: <0x%s> %s",
1612 (op
== DW_OP_implicit_pointer
1613 ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"),
1614 dwarf_vmatoa ("x", uvalue
),
1615 dwarf_vmatoa ("d", svalue
));
1617 case DW_OP_entry_value
:
1618 case DW_OP_GNU_entry_value
:
1619 READ_ULEB (uvalue
, data
, end
);
1620 /* PR 17531: file: 0cc9cd00. */
1621 if (uvalue
> (dwarf_vma
) (end
- data
))
1622 uvalue
= end
- data
;
1623 printf ("%s: (", (op
== DW_OP_entry_value
? "DW_OP_entry_value"
1624 : "DW_OP_GNU_entry_value"));
1625 if (decode_location_expression (data
, pointer_size
, offset_size
,
1626 dwarf_version
, uvalue
,
1627 cu_offset
, section
))
1628 need_frame_base
= 1;
1634 case DW_OP_const_type
:
1635 case DW_OP_GNU_const_type
:
1636 READ_ULEB (uvalue
, data
, end
);
1637 printf ("%s: <0x%s> ",
1638 (op
== DW_OP_const_type
? "DW_OP_const_type"
1639 : "DW_OP_GNU_const_type"),
1640 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1641 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1642 data
= display_block (data
, uvalue
, end
, ' ');
1644 case DW_OP_regval_type
:
1645 case DW_OP_GNU_regval_type
:
1646 READ_ULEB (uvalue
, data
, end
);
1647 printf ("%s: %s (%s)",
1648 (op
== DW_OP_regval_type
? "DW_OP_regval_type"
1649 : "DW_OP_GNU_regval_type"),
1650 dwarf_vmatoa ("u", uvalue
), regname (uvalue
, 1));
1651 READ_ULEB (uvalue
, data
, end
);
1652 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1654 case DW_OP_deref_type
:
1655 case DW_OP_GNU_deref_type
:
1656 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
1658 (op
== DW_OP_deref_type
? "DW_OP_deref_type"
1659 : "DW_OP_GNU_deref_type"),
1661 READ_ULEB (uvalue
, data
, end
);
1662 printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1665 case DW_OP_GNU_convert
:
1666 READ_ULEB (uvalue
, data
, end
);
1667 printf ("%s <0x%s>",
1668 (op
== DW_OP_convert
? "DW_OP_convert" : "DW_OP_GNU_convert"),
1669 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1671 case DW_OP_reinterpret
:
1672 case DW_OP_GNU_reinterpret
:
1673 READ_ULEB (uvalue
, data
, end
);
1674 printf ("%s <0x%s>",
1675 (op
== DW_OP_reinterpret
? "DW_OP_reinterpret"
1676 : "DW_OP_GNU_reinterpret"),
1677 dwarf_vmatoa ("x", uvalue
? cu_offset
+ uvalue
: 0));
1679 case DW_OP_GNU_parameter_ref
:
1680 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
1681 printf ("DW_OP_GNU_parameter_ref: <0x%s>",
1682 dwarf_vmatoa ("x", cu_offset
+ uvalue
));
1684 case DW_OP_GNU_addr_index
:
1685 READ_ULEB (uvalue
, data
, end
);
1686 printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1688 case DW_OP_GNU_const_index
:
1689 READ_ULEB (uvalue
, data
, end
);
1690 printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue
));
1692 case DW_OP_GNU_variable_value
:
1693 /* FIXME: Strictly speaking for 64-bit DWARF3 files
1694 this ought to be an 8-byte wide computation. */
1695 if (dwarf_version
== -1)
1697 printf (_("(DW_OP_GNU_variable_value in frame info)"));
1698 /* No way to tell where the next op is, so just bail. */
1699 return need_frame_base
;
1701 if (dwarf_version
== 2)
1703 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1707 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1709 printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue
));
1712 /* HP extensions. */
1713 case DW_OP_HP_is_value
:
1714 printf ("DW_OP_HP_is_value");
1715 /* FIXME: Is there data associated with this OP ? */
1717 case DW_OP_HP_fltconst4
:
1718 printf ("DW_OP_HP_fltconst4");
1719 /* FIXME: Is there data associated with this OP ? */
1721 case DW_OP_HP_fltconst8
:
1722 printf ("DW_OP_HP_fltconst8");
1723 /* FIXME: Is there data associated with this OP ? */
1725 case DW_OP_HP_mod_range
:
1726 printf ("DW_OP_HP_mod_range");
1727 /* FIXME: Is there data associated with this OP ? */
1729 case DW_OP_HP_unmod_range
:
1730 printf ("DW_OP_HP_unmod_range");
1731 /* FIXME: Is there data associated with this OP ? */
1734 printf ("DW_OP_HP_tls");
1735 /* FIXME: Is there data associated with this OP ? */
1738 /* PGI (STMicroelectronics) extensions. */
1739 case DW_OP_PGI_omp_thread_num
:
1740 /* Pushes the thread number for the current thread as it would be
1741 returned by the standard OpenMP library function:
1742 omp_get_thread_num(). The "current thread" is the thread for
1743 which the expression is being evaluated. */
1744 printf ("DW_OP_PGI_omp_thread_num");
1748 if (op
>= DW_OP_lo_user
1749 && op
<= DW_OP_hi_user
)
1750 printf (_("(User defined location op 0x%x)"), op
);
1752 printf (_("(Unknown location op 0x%x)"), op
);
1753 /* No way to tell where the next op is, so just bail. */
1754 return need_frame_base
;
1757 /* Separate the ops. */
1762 return need_frame_base
;
1765 /* Find the CU or TU set corresponding to the given CU_OFFSET.
1766 This is used for DWARF package files. */
1768 static struct cu_tu_set
*
1769 find_cu_tu_set_v2 (dwarf_vma cu_offset
, int do_types
)
1771 struct cu_tu_set
*p
;
1773 unsigned int dw_sect
;
1779 dw_sect
= DW_SECT_TYPES
;
1785 dw_sect
= DW_SECT_INFO
;
1789 if (p
->section_offsets
[dw_sect
] == cu_offset
)
1797 /* Add INC to HIGH_BITS:LOW_BITS. */
1799 add64 (dwarf_vma
* high_bits
, dwarf_vma
* low_bits
, dwarf_vma inc
)
1801 dwarf_vma tmp
= * low_bits
;
1805 /* FIXME: There is probably a better way of handling this:
1807 We need to cope with dwarf_vma being a 32-bit or 64-bit
1808 type. Plus regardless of its size LOW_BITS is meant to
1809 only hold 32-bits, so if there is overflow or wrap around
1810 we must propagate into HIGH_BITS. */
1811 if (tmp
< * low_bits
)
1815 else if (sizeof (tmp
) > 8
1826 fetch_alt_indirect_string (dwarf_vma offset
)
1830 if (! do_follow_links
)
1833 if (first_separate_info
== NULL
)
1834 return _("<no links available>");
1836 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
1838 struct dwarf_section
* section
;
1841 if (! load_debug_section (separate_debug_str
, i
->handle
))
1844 section
= &debug_displays
[separate_debug_str
].section
;
1846 if (section
->start
== NULL
)
1849 if (offset
>= section
->size
)
1852 ret
= (const char *) (section
->start
+ offset
);
1853 /* Unfortunately we cannot rely upon the .debug_str section ending with a
1854 NUL byte. Since our caller is expecting to receive a well formed C
1855 string we test for the lack of a terminating byte here. */
1856 if (strnlen ((const char *) ret
, section
->size
- offset
)
1857 == section
->size
- offset
)
1858 return _("<no NUL byte at end of alt .debug_str section>");
1863 warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"),
1864 dwarf_vmatoa ("x", offset
));
1865 return _("<offset is too big>");
1869 get_AT_name (unsigned long attribute
)
1874 return "DW_AT value: 0";
1876 /* One value is shared by the MIPS and HP extensions: */
1877 if (attribute
== DW_AT_MIPS_fde
)
1878 return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable";
1880 name
= get_DW_AT_name (attribute
);
1884 static char buffer
[100];
1886 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
1895 add_dwo_info (const char * field
, dwo_type type
)
1897 dwo_info
* dwinfo
= xmalloc (sizeof * dwinfo
);
1899 dwinfo
->type
= type
;
1900 dwinfo
->value
= field
;
1901 dwinfo
->next
= first_dwo_info
;
1902 first_dwo_info
= dwinfo
;
1906 add_dwo_name (const char * name
)
1908 add_dwo_info (name
, DWO_NAME
);
1912 add_dwo_dir (const char * dir
)
1914 add_dwo_info (dir
, DWO_DIR
);
1918 add_dwo_id (const char * id
)
1920 add_dwo_info (id
, DWO_ID
);
1924 free_dwo_info (void)
1929 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= next
)
1931 next
= dwinfo
->next
;
1934 first_dwo_info
= NULL
;
1937 /* Ensure that START + UVALUE is less than END.
1938 Return an adjusted UVALUE if necessary to ensure this relationship. */
1940 static inline dwarf_vma
1941 check_uvalue (const unsigned char * start
,
1943 const unsigned char * end
)
1945 dwarf_vma max_uvalue
= end
- start
;
1947 /* See PR 17512: file: 008-103549-0.001:0.1.
1948 and PR 24829 for examples of where these tests are triggered. */
1949 if (uvalue
> max_uvalue
)
1951 warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue
);
1952 uvalue
= max_uvalue
;
1958 static unsigned char *
1959 skip_attr_bytes (unsigned long form
,
1960 unsigned char * data
,
1961 unsigned const char * end
,
1962 dwarf_vma pointer_size
,
1963 dwarf_vma offset_size
,
1965 dwarf_vma
* value_return
)
1967 dwarf_signed_vma svalue
;
1968 dwarf_vma uvalue
= 0;
1974 case DW_FORM_ref_addr
:
1975 if (dwarf_version
== 2)
1976 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1977 else if (dwarf_version
> 2)
1978 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1984 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
1988 case DW_FORM_line_strp
:
1989 case DW_FORM_sec_offset
:
1990 case DW_FORM_GNU_ref_alt
:
1991 case DW_FORM_GNU_strp_alt
:
1992 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
1995 case DW_FORM_flag_present
:
2002 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2007 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2012 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2016 READ_SLEB (svalue
, data
, end
);
2020 case DW_FORM_ref_udata
:
2022 case DW_FORM_GNU_str_index
:
2023 case DW_FORM_GNU_addr_index
:
2024 READ_ULEB (uvalue
, data
, end
);
2029 dwarf_vma high_bits
;
2031 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2033 if (sizeof (uvalue
) > 4)
2034 uvalue
+= high_bits
<< 32;
2035 else if (high_bits
!= 0)
2037 /* FIXME: What to do ? */
2044 case DW_FORM_ref_sig8
:
2048 case DW_FORM_data16
:
2052 case DW_FORM_string
:
2053 data
+= strnlen ((char *) data
, end
- data
) + 1;
2057 case DW_FORM_exprloc
:
2058 READ_ULEB (uvalue
, data
, end
);
2062 case DW_FORM_block1
:
2063 SAFE_BYTE_GET (uvalue
, data
, 1, end
);
2067 case DW_FORM_block2
:
2068 SAFE_BYTE_GET (uvalue
, data
, 2, end
);
2072 case DW_FORM_block4
:
2073 SAFE_BYTE_GET (uvalue
, data
, 4, end
);
2077 case DW_FORM_indirect
:
2078 READ_ULEB (form
, data
, end
);
2079 if (form
== DW_FORM_implicit_const
)
2080 SKIP_ULEB (data
, end
);
2081 return skip_attr_bytes (form
, data
, end
, pointer_size
, offset_size
, dwarf_version
, value_return
);
2087 * value_return
= uvalue
;
2089 data
= (unsigned char *) end
;
2093 /* Given form FORM with value UVALUE, locate and return the abbreviation
2094 associated with it. */
2096 static abbrev_entry
*
2097 get_type_abbrev_from_form (unsigned long form
,
2098 unsigned long uvalue
,
2099 dwarf_vma cu_offset
,
2100 const struct dwarf_section
* section
,
2101 unsigned long * abbrev_num_return
,
2102 unsigned char ** data_return
,
2103 unsigned long * cu_offset_return
)
2105 unsigned long abbrev_number
;
2107 abbrev_entry
* entry
;
2108 unsigned char * data
;
2110 if (abbrev_num_return
!= NULL
)
2111 * abbrev_num_return
= 0;
2112 if (data_return
!= NULL
)
2113 * data_return
= NULL
;
2117 case DW_FORM_GNU_ref_alt
:
2118 /* FIXME: We are unable to handle this form at the moment. */
2121 case DW_FORM_ref_addr
:
2122 if (uvalue
>= section
->size
)
2124 warn (_("Unable to resolve ref_addr form: uvalue %lx > section size %lx (%s)\n"),
2125 uvalue
, (long) section
->size
, section
->name
);
2134 case DW_FORM_ref_udata
:
2135 if (uvalue
+ cu_offset
> section
->size
)
2137 warn (_("Unable to resolve ref form: uvalue %lx + cu_offset %lx > section size %lx\n"),
2138 uvalue
, (long) cu_offset
, (long) section
->size
);
2141 uvalue
+= cu_offset
;
2144 /* FIXME: Are there other DW_FORMs that can be used by types ? */
2147 warn (_("Unexpected form %lx encountered whilst finding abbreviation for type\n"), form
);
2151 data
= (unsigned char *) section
->start
+ uvalue
;
2152 map
= find_abbrev_map_by_offset (uvalue
);
2156 warn (_("Unable to find abbreviations for CU offset %#lx\n"), uvalue
);
2159 if (map
->list
== NULL
)
2161 warn (_("Empty abbreviation list encountered for CU offset %lx\n"), uvalue
);
2165 if (cu_offset_return
!= NULL
)
2167 if (form
== DW_FORM_ref_addr
)
2168 * cu_offset_return
= map
->start
;
2170 * cu_offset_return
= cu_offset
;
2173 READ_ULEB (abbrev_number
, data
, section
->start
+ section
->size
);
2175 for (entry
= map
->list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
2176 if (entry
->number
== abbrev_number
)
2179 if (abbrev_num_return
!= NULL
)
2180 * abbrev_num_return
= abbrev_number
;
2182 if (data_return
!= NULL
)
2183 * data_return
= data
;
2186 warn (_("Unable to find entry for abbreviation %lu\n"), abbrev_number
);
2191 /* Return IS_SIGNED set to TRUE if the type using abbreviation ENTRY
2192 can be determined to be a signed type. The data for ENTRY can be
2193 found starting at DATA. */
2196 get_type_signedness (abbrev_entry
* entry
,
2197 const struct dwarf_section
* section
,
2198 unsigned char * data
,
2199 unsigned const char * end
,
2200 dwarf_vma cu_offset
,
2201 dwarf_vma pointer_size
,
2202 dwarf_vma offset_size
,
2204 bfd_boolean
* is_signed
,
2205 unsigned int nesting
)
2209 * is_signed
= FALSE
;
2211 #define MAX_NESTING 20
2212 if (nesting
> MAX_NESTING
)
2214 /* FIXME: Warn - or is this expected ?
2215 NB/ We need to avoid infinite recursion. */
2219 for (attr
= entry
->first_attr
;
2220 attr
!= NULL
&& attr
->attribute
;
2223 unsigned char * orig_data
= data
;
2224 dwarf_vma uvalue
= 0;
2226 data
= skip_attr_bytes (attr
->form
, data
, end
, pointer_size
,
2227 offset_size
, dwarf_version
, & uvalue
);
2231 switch (attr
->attribute
)
2233 case DW_AT_linkage_name
:
2237 if (attr
->form
== DW_FORM_strp
)
2238 printf (", %s", fetch_indirect_string (uvalue
));
2239 else if (attr
->form
== DW_FORM_string
)
2240 printf (", %s", orig_data
);
2247 abbrev_entry
* type_abbrev
;
2248 unsigned char * type_data
;
2249 unsigned long type_cu_offset
;
2251 type_abbrev
= get_type_abbrev_from_form (attr
->form
,
2255 NULL
/* abbrev num return */,
2258 if (type_abbrev
== NULL
)
2261 get_type_signedness (type_abbrev
, section
, type_data
, end
, type_cu_offset
,
2262 pointer_size
, offset_size
, dwarf_version
,
2263 is_signed
, nesting
+ 1);
2267 case DW_AT_encoding
:
2268 /* Determine signness. */
2271 case DW_ATE_address
:
2272 /* FIXME - some architectures have signed addresses. */
2273 case DW_ATE_boolean
:
2274 case DW_ATE_unsigned
:
2275 case DW_ATE_unsigned_char
:
2276 case DW_ATE_unsigned_fixed
:
2277 * is_signed
= FALSE
;
2281 case DW_ATE_complex_float
:
2284 case DW_ATE_signed_char
:
2285 case DW_ATE_imaginary_float
:
2286 case DW_ATE_decimal_float
:
2287 case DW_ATE_signed_fixed
:
2297 read_and_print_leb128 (unsigned char * data
,
2298 unsigned int * bytes_read
,
2299 unsigned const char * end
,
2300 bfd_boolean is_signed
)
2303 dwarf_vma val
= read_leb128 (data
, end
, is_signed
, bytes_read
, &status
);
2305 report_leb_status (status
, __FILE__
, __LINE__
);
2307 printf ("%s", dwarf_vmatoa (is_signed
? "d" : "u", val
));
2311 display_discr_list (unsigned long form
,
2313 unsigned char * data
,
2314 unsigned const char * end
,
2319 printf ("[default]");
2326 case DW_FORM_block1
:
2327 case DW_FORM_block2
:
2328 case DW_FORM_block4
:
2329 /* Move data pointer back to the start of the byte array. */
2333 printf ("<corrupt>\n");
2334 warn (_("corrupt discr_list - not using a block form\n"));
2340 printf ("<corrupt>\n");
2341 warn (_("corrupt discr_list - block not long enough\n"));
2345 bfd_boolean is_signed
=
2346 (level
> 0 && level
<= MAX_CU_NESTING
)
2347 ? level_type_signed
[level
- 1] : FALSE
;
2352 unsigned char discriminant
;
2353 unsigned int bytes_read
;
2355 SAFE_BYTE_GET (discriminant
, data
, 1, end
);
2359 assert (uvalue
> 0);
2360 switch (discriminant
)
2364 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2365 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2366 uvalue
-= bytes_read
;
2372 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2373 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2374 uvalue
-= bytes_read
;
2378 read_and_print_leb128 (data
, & bytes_read
, end
, is_signed
);
2379 assert (bytes_read
<= uvalue
&& bytes_read
> 0);
2380 uvalue
-= bytes_read
;
2385 printf ("<corrupt>\n");
2386 warn (_("corrupt discr_list - unrecognised discriminant byte %#x\n"),
2396 printf (")(signed)");
2398 printf (")(unsigned)");
2401 static unsigned char *
2402 read_and_display_attr_value (unsigned long attribute
,
2404 dwarf_signed_vma implicit_const
,
2405 unsigned char * start
,
2406 unsigned char * data
,
2407 unsigned char * end
,
2408 dwarf_vma cu_offset
,
2409 dwarf_vma pointer_size
,
2410 dwarf_vma offset_size
,
2412 debug_info
* debug_info_p
,
2414 struct dwarf_section
* section
,
2415 struct cu_tu_set
* this_set
,
2419 dwarf_signed_vma svalue
;
2420 dwarf_vma uvalue
= 0;
2421 unsigned char * block_start
= NULL
;
2422 unsigned char * orig_data
= data
;
2424 if (data
> end
|| (data
== end
&& form
!= DW_FORM_flag_present
))
2426 warn (_("Corrupt attribute\n"));
2430 if (do_wide
&& ! do_loc
)
2432 /* PR 26847: Display the name of the form. */
2433 const char * name
= get_FORM_name (form
);
2435 /* For convenience we skip the DW_FORM_ prefix to the name. */
2437 name
+= 8; /* strlen ("DW_FORM_") */
2438 printf ("%c(%s)", delimiter
, name
);
2446 case DW_FORM_ref_addr
:
2447 if (dwarf_version
== 2)
2448 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2449 else if (dwarf_version
> 2)
2450 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2452 error (_("Internal error: DW_FORM_ref_addr is not supported in DWARF version 1.\n"));
2456 SAFE_BYTE_GET_AND_INC (uvalue
, data
, pointer_size
, end
);
2460 case DW_FORM_line_strp
:
2461 case DW_FORM_sec_offset
:
2462 case DW_FORM_GNU_ref_alt
:
2463 case DW_FORM_GNU_strp_alt
:
2464 SAFE_BYTE_GET_AND_INC (uvalue
, data
, offset_size
, end
);
2467 case DW_FORM_flag_present
:
2474 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2479 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2484 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2488 READ_SLEB (svalue
, data
, end
);
2492 case DW_FORM_GNU_str_index
:
2493 case DW_FORM_ref_udata
:
2495 case DW_FORM_GNU_addr_index
:
2496 READ_ULEB (uvalue
, data
, end
);
2499 case DW_FORM_indirect
:
2500 READ_ULEB (form
, data
, end
);
2502 printf ("%c%s", delimiter
, get_FORM_name (form
));
2503 if (form
== DW_FORM_implicit_const
)
2504 READ_SLEB (implicit_const
, data
, end
);
2505 return read_and_display_attr_value (attribute
, form
, implicit_const
,
2507 cu_offset
, pointer_size
,
2508 offset_size
, dwarf_version
,
2509 debug_info_p
, do_loc
,
2510 section
, this_set
, delimiter
, level
);
2515 case DW_FORM_ref_addr
:
2517 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2520 case DW_FORM_GNU_ref_alt
:
2524 /* We have already printed the form name. */
2525 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2527 printf ("%c<alt 0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
));
2529 /* FIXME: Follow the reference... */
2535 case DW_FORM_ref_udata
:
2537 printf ("%c<0x%s>", delimiter
, dwarf_vmatoa ("x", uvalue
+ cu_offset
));
2542 case DW_FORM_sec_offset
:
2544 printf ("%c0x%s", delimiter
, dwarf_vmatoa ("x", uvalue
));
2547 case DW_FORM_flag_present
:
2554 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", uvalue
));
2557 case DW_FORM_implicit_const
:
2559 printf ("%c%s", delimiter
, dwarf_vmatoa ("d", implicit_const
));
2566 dwarf_vma high_bits
;
2570 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2572 if (form
== DW_FORM_ref8
)
2573 add64 (& high_bits
, & utmp
, cu_offset
);
2574 printf ("%c0x%s", delimiter
,
2575 dwarf_vmatoa64 (high_bits
, utmp
, buf
, sizeof (buf
)));
2578 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2579 && num_debug_info_entries
== 0)
2581 if (sizeof (uvalue
) == 8)
2582 SAFE_BYTE_GET (uvalue
, data
, 8, end
);
2584 error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n"));
2590 case DW_FORM_data16
:
2593 dwarf_vma left_high_bits
, left_low_bits
;
2594 dwarf_vma right_high_bits
, right_low_bits
;
2596 SAFE_BYTE_GET64 (data
, &left_high_bits
, &left_low_bits
, end
);
2597 SAFE_BYTE_GET64 (data
+ 8, &right_high_bits
, &right_low_bits
, end
);
2598 if (byte_get
== byte_get_little_endian
)
2601 left_high_bits
^= right_high_bits
;
2602 right_high_bits
^= left_high_bits
;
2603 left_high_bits
^= right_high_bits
;
2604 left_low_bits
^= right_low_bits
;
2605 right_low_bits
^= left_low_bits
;
2606 left_low_bits
^= right_low_bits
;
2608 printf (" 0x%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x"
2609 "%08" DWARF_VMA_FMT
"x%08" DWARF_VMA_FMT
"x",
2610 left_high_bits
, left_low_bits
, right_high_bits
,
2616 case DW_FORM_string
:
2618 printf ("%c%.*s", delimiter
, (int) (end
- data
), data
);
2619 data
+= strnlen ((char *) data
, end
- data
) + 1;
2623 case DW_FORM_exprloc
:
2624 READ_ULEB (uvalue
, data
, end
);
2627 if (block_start
>= end
)
2629 warn (_("Block ends prematurely\n"));
2634 uvalue
= check_uvalue (block_start
, uvalue
, end
);
2637 data
= block_start
+ uvalue
;
2639 data
= display_block (block_start
, uvalue
, end
, delimiter
);
2642 case DW_FORM_block1
:
2643 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 1, end
);
2646 case DW_FORM_block2
:
2647 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 2, end
);
2650 case DW_FORM_block4
:
2651 SAFE_BYTE_GET_AND_INC (uvalue
, data
, 4, end
);
2658 /* We have already displayed the form name. */
2659 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2660 dwarf_vmatoa ("x", uvalue
),
2661 fetch_indirect_string (uvalue
));
2663 printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter
,
2664 dwarf_vmatoa ("x", uvalue
),
2665 fetch_indirect_string (uvalue
));
2669 case DW_FORM_line_strp
:
2673 /* We have already displayed the form name. */
2674 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2675 dwarf_vmatoa ("x", uvalue
),
2676 fetch_indirect_line_string (uvalue
));
2678 printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter
,
2679 dwarf_vmatoa ("x", uvalue
),
2680 fetch_indirect_line_string (uvalue
));
2684 case DW_FORM_GNU_str_index
:
2687 const char * suffix
= strrchr (section
->name
, '.');
2688 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
2691 /* We have already displayed the form name. */
2692 printf (_("%c(offset: 0x%s): %s"), delimiter
,
2693 dwarf_vmatoa ("x", uvalue
),
2694 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2696 printf (_("%c(indexed string: 0x%s): %s"), delimiter
,
2697 dwarf_vmatoa ("x", uvalue
),
2698 fetch_indexed_string (uvalue
, this_set
, offset_size
, dwo
));
2702 case DW_FORM_GNU_strp_alt
:
2706 /* We have already displayed the form name. */
2707 printf (_("%c(offset: 0x%s) %s"), delimiter
,
2708 dwarf_vmatoa ("x", uvalue
),
2709 fetch_alt_indirect_string (uvalue
));
2711 printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter
,
2712 dwarf_vmatoa ("x", uvalue
),
2713 fetch_alt_indirect_string (uvalue
));
2717 case DW_FORM_indirect
:
2718 /* Handled above. */
2721 case DW_FORM_ref_sig8
:
2724 dwarf_vma high_bits
;
2727 SAFE_BYTE_GET64 (data
, &high_bits
, &uvalue
, end
);
2729 /* We have already displayed the form name. */
2730 printf ("%c: 0x%s", delimiter
,
2731 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2733 printf ("%csignature: 0x%s", delimiter
,
2734 dwarf_vmatoa64 (high_bits
, uvalue
, buf
, sizeof (buf
)));
2739 case DW_FORM_GNU_addr_index
:
2743 /* We have already displayed the form name. */
2744 printf (_("%c(index: 0x%s): %s"), delimiter
,
2745 dwarf_vmatoa ("x", uvalue
),
2746 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2748 printf (_("%c(addr_index: 0x%s): %s"), delimiter
,
2749 dwarf_vmatoa ("x", uvalue
),
2750 fetch_indexed_value (uvalue
* pointer_size
, pointer_size
));
2755 warn (_("Unrecognized form: %lu\n"), form
);
2759 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
2760 && num_debug_info_entries
== 0
2761 && debug_info_p
!= NULL
)
2765 case DW_AT_frame_base
:
2766 have_frame_base
= 1;
2768 case DW_AT_location
:
2769 case DW_AT_GNU_locviews
:
2770 case DW_AT_string_length
:
2771 case DW_AT_return_addr
:
2772 case DW_AT_data_member_location
:
2773 case DW_AT_vtable_elem_location
:
2775 case DW_AT_static_link
:
2776 case DW_AT_use_location
:
2777 case DW_AT_call_value
:
2778 case DW_AT_GNU_call_site_value
:
2779 case DW_AT_call_data_value
:
2780 case DW_AT_GNU_call_site_data_value
:
2781 case DW_AT_call_target
:
2782 case DW_AT_GNU_call_site_target
:
2783 case DW_AT_call_target_clobbered
:
2784 case DW_AT_GNU_call_site_target_clobbered
:
2785 if ((dwarf_version
< 4
2786 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2787 || form
== DW_FORM_sec_offset
)
2789 /* Process location list. */
2790 unsigned int lmax
= debug_info_p
->max_loc_offsets
;
2791 unsigned int num
= debug_info_p
->num_loc_offsets
;
2793 if (lmax
== 0 || num
>= lmax
)
2796 debug_info_p
->loc_offsets
= (dwarf_vma
*)
2797 xcrealloc (debug_info_p
->loc_offsets
,
2798 lmax
, sizeof (*debug_info_p
->loc_offsets
));
2799 debug_info_p
->loc_views
= (dwarf_vma
*)
2800 xcrealloc (debug_info_p
->loc_views
,
2801 lmax
, sizeof (*debug_info_p
->loc_views
));
2802 debug_info_p
->have_frame_base
= (int *)
2803 xcrealloc (debug_info_p
->have_frame_base
,
2804 lmax
, sizeof (*debug_info_p
->have_frame_base
));
2805 debug_info_p
->max_loc_offsets
= lmax
;
2807 if (this_set
!= NULL
)
2808 uvalue
+= this_set
->section_offsets
[DW_SECT_LOC
];
2809 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
2810 if (attribute
!= DW_AT_GNU_locviews
)
2812 /* Corrupt DWARF info can produce more offsets than views.
2813 See PR 23062 for an example. */
2814 if (debug_info_p
->num_loc_offsets
2815 > debug_info_p
->num_loc_views
)
2816 warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n"));
2819 debug_info_p
->loc_offsets
[num
] = uvalue
;
2820 debug_info_p
->num_loc_offsets
++;
2825 assert (debug_info_p
->num_loc_views
<= num
);
2826 num
= debug_info_p
->num_loc_views
;
2827 if (num
> debug_info_p
->num_loc_offsets
)
2828 warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n"));
2831 debug_info_p
->loc_views
[num
] = uvalue
;
2832 debug_info_p
->num_loc_views
++;
2839 if (need_base_address
)
2840 debug_info_p
->base_address
= uvalue
;
2843 case DW_AT_GNU_addr_base
:
2844 debug_info_p
->addr_base
= uvalue
;
2847 case DW_AT_GNU_ranges_base
:
2848 debug_info_p
->ranges_base
= uvalue
;
2852 if ((dwarf_version
< 4
2853 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
2854 || form
== DW_FORM_sec_offset
)
2856 /* Process range list. */
2857 unsigned int lmax
= debug_info_p
->max_range_lists
;
2858 unsigned int num
= debug_info_p
->num_range_lists
;
2860 if (lmax
== 0 || num
>= lmax
)
2863 debug_info_p
->range_lists
= (dwarf_vma
*)
2864 xcrealloc (debug_info_p
->range_lists
,
2865 lmax
, sizeof (*debug_info_p
->range_lists
));
2866 debug_info_p
->max_range_lists
= lmax
;
2868 debug_info_p
->range_lists
[num
] = uvalue
;
2869 debug_info_p
->num_range_lists
++;
2873 case DW_AT_GNU_dwo_name
:
2874 case DW_AT_dwo_name
:
2879 add_dwo_name ((const char *) fetch_indirect_string (uvalue
));
2881 case DW_FORM_GNU_strp_alt
:
2882 add_dwo_name ((const char *) fetch_alt_indirect_string (uvalue
));
2884 case DW_FORM_GNU_str_index
:
2885 add_dwo_name (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2887 case DW_FORM_string
:
2888 add_dwo_name ((const char *) orig_data
);
2891 warn (_("Unsupported form (%s) for attribute %s\n"),
2892 get_FORM_name (form
), get_AT_name (attribute
));
2897 case DW_AT_comp_dir
:
2898 /* FIXME: Also extract a build-id in a CU/TU. */
2903 add_dwo_dir ((const char *) fetch_indirect_string (uvalue
));
2905 case DW_FORM_GNU_strp_alt
:
2906 add_dwo_dir (fetch_alt_indirect_string (uvalue
));
2908 case DW_FORM_line_strp
:
2909 add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue
));
2911 case DW_FORM_GNU_str_index
:
2912 add_dwo_dir (fetch_indexed_string (uvalue
, this_set
, offset_size
, FALSE
));
2914 case DW_FORM_string
:
2915 add_dwo_dir ((const char *) orig_data
);
2918 warn (_("Unsupported form (%s) for attribute %s\n"),
2919 get_FORM_name (form
), get_AT_name (attribute
));
2924 case DW_AT_GNU_dwo_id
:
2929 /* FIXME: Record the length of the ID as well ? */
2930 add_dwo_id ((const char *) (data
- 8));
2933 warn (_("Unsupported form (%s) for attribute %s\n"),
2934 get_FORM_name (form
), get_AT_name (attribute
));
2944 if (do_loc
|| attribute
== 0)
2947 /* For some attributes we can display further information. */
2951 if (level
>= 0 && level
< MAX_CU_NESTING
2952 && uvalue
< (size_t) (end
- start
))
2954 bfd_boolean is_signed
= FALSE
;
2955 abbrev_entry
* type_abbrev
;
2956 unsigned char * type_data
;
2957 unsigned long type_cu_offset
;
2959 type_abbrev
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
2960 section
, NULL
, & type_data
, & type_cu_offset
);
2961 if (type_abbrev
!= NULL
)
2963 get_type_signedness (type_abbrev
, section
, type_data
, end
, type_cu_offset
,
2964 pointer_size
, offset_size
, dwarf_version
,
2967 level_type_signed
[level
] = is_signed
;
2975 case DW_INL_not_inlined
:
2976 printf (_("(not inlined)"));
2978 case DW_INL_inlined
:
2979 printf (_("(inlined)"));
2981 case DW_INL_declared_not_inlined
:
2982 printf (_("(declared as inline but ignored)"));
2984 case DW_INL_declared_inlined
:
2985 printf (_("(declared as inline and inlined)"));
2988 printf (_(" (Unknown inline attribute value: %s)"),
2989 dwarf_vmatoa ("x", uvalue
));
2994 case DW_AT_language
:
2998 /* Ordered by the numeric value of these constants. */
2999 case DW_LANG_C89
: printf ("(ANSI C)"); break;
3000 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
3001 case DW_LANG_Ada83
: printf ("(Ada)"); break;
3002 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
3003 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
3004 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
3005 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
3006 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
3007 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
3008 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
3009 /* DWARF 2.1 values. */
3010 case DW_LANG_Java
: printf ("(Java)"); break;
3011 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
3012 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
3013 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
3014 /* DWARF 3 values. */
3015 case DW_LANG_PLI
: printf ("(PLI)"); break;
3016 case DW_LANG_ObjC
: printf ("(Objective C)"); break;
3017 case DW_LANG_ObjC_plus_plus
: printf ("(Objective C++)"); break;
3018 case DW_LANG_UPC
: printf ("(Unified Parallel C)"); break;
3019 case DW_LANG_D
: printf ("(D)"); break;
3020 /* DWARF 4 values. */
3021 case DW_LANG_Python
: printf ("(Python)"); break;
3022 /* DWARF 5 values. */
3023 case DW_LANG_OpenCL
: printf ("(OpenCL)"); break;
3024 case DW_LANG_Go
: printf ("(Go)"); break;
3025 case DW_LANG_Modula3
: printf ("(Modula 3)"); break;
3026 case DW_LANG_Haskell
: printf ("(Haskell)"); break;
3027 case DW_LANG_C_plus_plus_03
: printf ("(C++03)"); break;
3028 case DW_LANG_C_plus_plus_11
: printf ("(C++11)"); break;
3029 case DW_LANG_OCaml
: printf ("(OCaml)"); break;
3030 case DW_LANG_Rust
: printf ("(Rust)"); break;
3031 case DW_LANG_C11
: printf ("(C11)"); break;
3032 case DW_LANG_Swift
: printf ("(Swift)"); break;
3033 case DW_LANG_Julia
: printf ("(Julia)"); break;
3034 case DW_LANG_Dylan
: printf ("(Dylan)"); break;
3035 case DW_LANG_C_plus_plus_14
: printf ("(C++14)"); break;
3036 case DW_LANG_Fortran03
: printf ("(Fortran 03)"); break;
3037 case DW_LANG_Fortran08
: printf ("(Fortran 08)"); break;
3038 case DW_LANG_RenderScript
: printf ("(RenderScript)"); break;
3039 /* MIPS extension. */
3040 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
3041 /* UPC extension. */
3042 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
3044 if (uvalue
>= DW_LANG_lo_user
&& uvalue
<= DW_LANG_hi_user
)
3045 printf (_("(implementation defined: %s)"),
3046 dwarf_vmatoa ("x", uvalue
));
3048 printf (_("(Unknown: %s)"), dwarf_vmatoa ("x", uvalue
));
3053 case DW_AT_encoding
:
3057 case DW_ATE_void
: printf ("(void)"); break;
3058 case DW_ATE_address
: printf ("(machine address)"); break;
3059 case DW_ATE_boolean
: printf ("(boolean)"); break;
3060 case DW_ATE_complex_float
: printf ("(complex float)"); break;
3061 case DW_ATE_float
: printf ("(float)"); break;
3062 case DW_ATE_signed
: printf ("(signed)"); break;
3063 case DW_ATE_signed_char
: printf ("(signed char)"); break;
3064 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
3065 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
3066 /* DWARF 2.1 values: */
3067 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
3068 case DW_ATE_decimal_float
: printf ("(decimal float)"); break;
3069 /* DWARF 3 values: */
3070 case DW_ATE_packed_decimal
: printf ("(packed_decimal)"); break;
3071 case DW_ATE_numeric_string
: printf ("(numeric_string)"); break;
3072 case DW_ATE_edited
: printf ("(edited)"); break;
3073 case DW_ATE_signed_fixed
: printf ("(signed_fixed)"); break;
3074 case DW_ATE_unsigned_fixed
: printf ("(unsigned_fixed)"); break;
3075 /* DWARF 4 values: */
3076 case DW_ATE_UTF
: printf ("(unicode string)"); break;
3077 /* DWARF 5 values: */
3078 case DW_ATE_UCS
: printf ("(UCS)"); break;
3079 case DW_ATE_ASCII
: printf ("(ASCII)"); break;
3081 /* HP extensions: */
3082 case DW_ATE_HP_float80
: printf ("(HP_float80)"); break;
3083 case DW_ATE_HP_complex_float80
: printf ("(HP_complex_float80)"); break;
3084 case DW_ATE_HP_float128
: printf ("(HP_float128)"); break;
3085 case DW_ATE_HP_complex_float128
:printf ("(HP_complex_float128)"); break;
3086 case DW_ATE_HP_floathpintel
: printf ("(HP_floathpintel)"); break;
3087 case DW_ATE_HP_imaginary_float80
: printf ("(HP_imaginary_float80)"); break;
3088 case DW_ATE_HP_imaginary_float128
: printf ("(HP_imaginary_float128)"); break;
3091 if (uvalue
>= DW_ATE_lo_user
3092 && uvalue
<= DW_ATE_hi_user
)
3093 printf (_("(user defined type)"));
3095 printf (_("(unknown type)"));
3100 case DW_AT_accessibility
:
3104 case DW_ACCESS_public
: printf ("(public)"); break;
3105 case DW_ACCESS_protected
: printf ("(protected)"); break;
3106 case DW_ACCESS_private
: printf ("(private)"); break;
3108 printf (_("(unknown accessibility)"));
3113 case DW_AT_visibility
:
3117 case DW_VIS_local
: printf ("(local)"); break;
3118 case DW_VIS_exported
: printf ("(exported)"); break;
3119 case DW_VIS_qualified
: printf ("(qualified)"); break;
3120 default: printf (_("(unknown visibility)")); break;
3124 case DW_AT_endianity
:
3128 case DW_END_default
: printf ("(default)"); break;
3129 case DW_END_big
: printf ("(big)"); break;
3130 case DW_END_little
: printf ("(little)"); break;
3132 if (uvalue
>= DW_END_lo_user
&& uvalue
<= DW_END_hi_user
)
3133 printf (_("(user specified)"));
3135 printf (_("(unknown endianity)"));
3140 case DW_AT_virtuality
:
3144 case DW_VIRTUALITY_none
: printf ("(none)"); break;
3145 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
3146 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
3147 default: printf (_("(unknown virtuality)")); break;
3151 case DW_AT_identifier_case
:
3155 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
3156 case DW_ID_up_case
: printf ("(up_case)"); break;
3157 case DW_ID_down_case
: printf ("(down_case)"); break;
3158 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
3159 default: printf (_("(unknown case)")); break;
3163 case DW_AT_calling_convention
:
3167 case DW_CC_normal
: printf ("(normal)"); break;
3168 case DW_CC_program
: printf ("(program)"); break;
3169 case DW_CC_nocall
: printf ("(nocall)"); break;
3170 case DW_CC_pass_by_reference
: printf ("(pass by ref)"); break;
3171 case DW_CC_pass_by_value
: printf ("(pass by value)"); break;
3172 case DW_CC_GNU_renesas_sh
: printf ("(Rensas SH)"); break;
3173 case DW_CC_GNU_borland_fastcall_i386
: printf ("(Borland fastcall i386)"); break;
3175 if (uvalue
>= DW_CC_lo_user
3176 && uvalue
<= DW_CC_hi_user
)
3177 printf (_("(user defined)"));
3179 printf (_("(unknown convention)"));
3183 case DW_AT_ordering
:
3188 case -1: printf (_("(undefined)")); break;
3189 case 0: printf ("(row major)"); break;
3190 case 1: printf ("(column major)"); break;
3194 case DW_AT_decimal_sign
:
3198 case DW_DS_unsigned
: printf (_("(unsigned)")); break;
3199 case DW_DS_leading_overpunch
: printf (_("(leading overpunch)")); break;
3200 case DW_DS_trailing_overpunch
: printf (_("(trailing overpunch)")); break;
3201 case DW_DS_leading_separate
: printf (_("(leading separate)")); break;
3202 case DW_DS_trailing_separate
: printf (_("(trailing separate)")); break;
3203 default: printf (_("(unrecognised)")); break;
3207 case DW_AT_defaulted
:
3211 case DW_DEFAULTED_no
: printf (_("(no)")); break;
3212 case DW_DEFAULTED_in_class
: printf (_("(in class)")); break;
3213 case DW_DEFAULTED_out_of_class
: printf (_("(out of class)")); break;
3214 default: printf (_("(unrecognised)")); break;
3218 case DW_AT_discr_list
:
3220 display_discr_list (form
, uvalue
, data
, end
, level
);
3223 case DW_AT_frame_base
:
3224 have_frame_base
= 1;
3226 case DW_AT_location
:
3227 case DW_AT_string_length
:
3228 case DW_AT_return_addr
:
3229 case DW_AT_data_member_location
:
3230 case DW_AT_vtable_elem_location
:
3232 case DW_AT_static_link
:
3233 case DW_AT_use_location
:
3234 case DW_AT_call_value
:
3235 case DW_AT_GNU_call_site_value
:
3236 case DW_AT_call_data_value
:
3237 case DW_AT_GNU_call_site_data_value
:
3238 case DW_AT_call_target
:
3239 case DW_AT_GNU_call_site_target
:
3240 case DW_AT_call_target_clobbered
:
3241 case DW_AT_GNU_call_site_target_clobbered
:
3242 if ((dwarf_version
< 4
3243 && (form
== DW_FORM_data4
|| form
== DW_FORM_data8
))
3244 || form
== DW_FORM_sec_offset
)
3245 printf (_(" (location list)"));
3247 case DW_AT_allocated
:
3248 case DW_AT_associated
:
3249 case DW_AT_data_location
:
3251 case DW_AT_upper_bound
:
3252 case DW_AT_lower_bound
:
3255 int need_frame_base
;
3258 need_frame_base
= decode_location_expression (block_start
,
3263 cu_offset
, section
);
3265 if (need_frame_base
&& !have_frame_base
)
3266 printf (_(" [without DW_AT_frame_base]"));
3270 case DW_AT_data_bit_offset
:
3271 case DW_AT_byte_size
:
3272 case DW_AT_bit_size
:
3273 case DW_AT_string_length_byte_size
:
3274 case DW_AT_string_length_bit_size
:
3275 case DW_AT_bit_stride
:
3276 if (form
== DW_FORM_exprloc
)
3279 (void) decode_location_expression (block_start
, pointer_size
,
3280 offset_size
, dwarf_version
,
3281 uvalue
, cu_offset
, section
);
3288 unsigned long abbrev_number
;
3289 abbrev_entry
*entry
;
3291 entry
= get_type_abbrev_from_form (form
, uvalue
, cu_offset
,
3292 section
, & abbrev_number
, NULL
, NULL
);
3295 if (form
!= DW_FORM_GNU_ref_alt
)
3296 warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
3297 dwarf_vmatoa ("x", uvalue
),
3298 (unsigned long) (orig_data
- section
->start
));
3302 printf (_("\t[Abbrev Number: %ld"), abbrev_number
);
3303 printf (" (%s)", get_TAG_name (entry
->tag
));
3316 static unsigned char *
3317 read_and_display_attr (unsigned long attribute
,
3319 dwarf_signed_vma implicit_const
,
3320 unsigned char * start
,
3321 unsigned char * data
,
3322 unsigned char * end
,
3323 dwarf_vma cu_offset
,
3324 dwarf_vma pointer_size
,
3325 dwarf_vma offset_size
,
3327 debug_info
* debug_info_p
,
3329 struct dwarf_section
* section
,
3330 struct cu_tu_set
* this_set
,
3334 printf (" %-18s:", get_AT_name (attribute
));
3335 data
= read_and_display_attr_value (attribute
, form
, implicit_const
,
3337 cu_offset
, pointer_size
, offset_size
,
3338 dwarf_version
, debug_info_p
,
3339 do_loc
, section
, this_set
, ' ', level
);
3345 /* Like load_debug_section, but if the ordinary call fails, and we are
3346 following debug links, then attempt to load the requested section
3347 from one of the separate debug info files. */
3350 load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum
,
3353 if (load_debug_section (sec_enum
, handle
))
3355 if (debug_displays
[sec_enum
].section
.filename
== NULL
)
3357 /* See if we can associate a filename with this section. */
3360 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3361 if (i
->handle
== handle
)
3363 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3371 if (do_follow_links
)
3375 for (i
= first_separate_info
; i
!= NULL
; i
= i
->next
)
3377 if (load_debug_section (sec_enum
, i
->handle
))
3379 debug_displays
[sec_enum
].section
.filename
= i
->filename
;
3381 /* FIXME: We should check to see if any of the remaining debug info
3382 files also contain this section, and, umm, do something about it. */
3392 introduce (struct dwarf_section
* section
, bfd_boolean raw
)
3396 if (do_follow_links
&& section
->filename
)
3397 printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"),
3398 section
->name
, section
->filename
);
3400 printf (_("Raw dump of debug contents of section %s:\n\n"), section
->name
);
3404 if (do_follow_links
&& section
->filename
)
3405 printf (_("Contents of the %s section (loaded from %s):\n\n"),
3406 section
->name
, section
->filename
);
3408 printf (_("Contents of the %s section:\n\n"), section
->name
);
3412 /* Process the contents of a .debug_info section.
3413 If do_loc is TRUE then we are scanning for location lists and dwo tags
3414 and we do not want to display anything to the user.
3415 If do_types is TRUE, we are processing a .debug_types section instead of
3416 a .debug_info section.
3417 The information displayed is restricted by the values in DWARF_START_DIE
3418 and DWARF_CUTOFF_LEVEL.
3419 Returns TRUE upon success. Otherwise an error or warning message is
3420 printed and FALSE is returned. */
3423 process_debug_info (struct dwarf_section
* section
,
3425 enum dwarf_section_display_enum abbrev_sec
,
3427 bfd_boolean do_types
)
3429 unsigned char *start
= section
->start
;
3430 unsigned char *end
= start
+ section
->size
;
3431 unsigned char *section_begin
;
3433 unsigned int num_units
= 0;
3435 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3436 && num_debug_info_entries
== 0
3441 /* First scan the section to get the number of comp units. */
3442 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
3445 /* Read the first 4 bytes. For a 32-bit DWARF section, this
3446 will be the length. For a 64-bit DWARF section, it'll be
3447 the escape code 0xffffffff followed by an 8 byte length. */
3448 SAFE_BYTE_GET (length
, section_begin
, 4, end
);
3450 if (length
== 0xffffffff)
3452 SAFE_BYTE_GET (length
, section_begin
+ 4, 8, end
);
3453 section_begin
+= length
+ 12;
3455 else if (length
>= 0xfffffff0 && length
< 0xffffffff)
3457 warn (_("Reserved length value (0x%s) found in section %s\n"),
3458 dwarf_vmatoa ("x", length
), section
->name
);
3462 section_begin
+= length
+ 4;
3464 /* Negative values are illegal, they may even cause infinite
3465 looping. This can happen if we can't accurately apply
3466 relocations to an object file, or if the file is corrupt. */
3467 if ((signed long) length
<= 0 || section_begin
< start
)
3469 warn (_("Corrupt unit length (0x%s) found in section %s\n"),
3470 dwarf_vmatoa ("x", length
), section
->name
);
3477 error (_("No comp units in %s section ?\n"), section
->name
);
3481 /* Then allocate an array to hold the information. */
3482 debug_information
= (debug_info
*) cmalloc (num_units
,
3483 sizeof (* debug_information
));
3484 if (debug_information
== NULL
)
3486 error (_("Not enough memory for a debug info array of %u entries\n"),
3488 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
3492 /* PR 17531: file: 92ca3797.
3493 We cannot rely upon the debug_information array being initialised
3494 before it is used. A corrupt file could easily contain references
3495 to a unit for which information has not been made available. So
3496 we ensure that the array is zeroed here. */
3497 memset (debug_information
, 0, num_units
* sizeof (*debug_information
));
3499 alloc_num_debug_info_entries
= num_units
;
3504 load_debug_section_with_follow (str
, file
);
3505 load_debug_section_with_follow (line_str
, file
);
3506 load_debug_section_with_follow (str_dwo
, file
);
3507 load_debug_section_with_follow (str_index
, file
);
3508 load_debug_section_with_follow (str_index_dwo
, file
);
3509 load_debug_section_with_follow (debug_addr
, file
);
3512 load_debug_section_with_follow (abbrev_sec
, file
);
3513 if (debug_displays
[abbrev_sec
].section
.start
== NULL
)
3515 warn (_("Unable to locate %s section!\n"),
3516 debug_displays
[abbrev_sec
].section
.uncompressed_name
);
3520 if (!do_loc
&& dwarf_start_die
== 0)
3521 introduce (section
, FALSE
);
3523 free_all_abbrevs ();
3524 free (cu_abbrev_map
);
3525 cu_abbrev_map
= NULL
;
3526 next_free_abbrev_map_entry
= 0;
3528 /* In order to be able to resolve DW_FORM_ref_attr forms we need
3529 to load *all* of the abbrevs for all CUs in this .debug_info
3530 section. This does effectively mean that we (partially) read
3531 every CU header twice. */
3532 for (section_begin
= start
; start
< end
;)
3534 DWARF2_Internal_CompUnit compunit
;
3535 unsigned char * hdrptr
;
3536 dwarf_vma abbrev_base
;
3538 dwarf_vma cu_offset
;
3539 unsigned int offset_size
;
3540 unsigned int initial_length_size
;
3541 struct cu_tu_set
* this_set
;
3546 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3548 if (compunit
.cu_length
== 0xffffffff)
3550 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3552 initial_length_size
= 12;
3557 initial_length_size
= 4;
3560 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3562 cu_offset
= start
- section_begin
;
3564 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3566 if (compunit
.cu_version
< 5)
3568 compunit
.cu_unit_type
= DW_UT_compile
;
3569 /* Initialize it due to a false compiler warning. */
3570 compunit
.cu_pointer_size
= -1;
3574 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3575 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3577 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3580 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3582 if (this_set
== NULL
)
3585 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3589 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3590 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3593 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3594 compunit
.cu_abbrev_offset
);
3597 unsigned char * next
;
3599 list
= new_abbrev_list (abbrev_base
,
3600 compunit
.cu_abbrev_offset
);
3601 next
= process_abbrev_set
3602 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3603 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3604 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3605 + abbrev_base
+ abbrev_size
),
3607 list
->start_of_next_abbrevs
= next
;
3610 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3611 + initial_length_size
;
3612 record_abbrev_list_for_cu (cu_offset
, start
- section_begin
, list
);
3615 for (start
= section_begin
, unit
= 0; start
< end
; unit
++)
3617 DWARF2_Internal_CompUnit compunit
;
3618 unsigned char *hdrptr
;
3619 unsigned char *tags
;
3620 int level
, last_level
, saved_level
;
3621 dwarf_vma cu_offset
;
3622 unsigned long sec_off
;
3623 unsigned int offset_size
;
3624 unsigned int initial_length_size
;
3625 dwarf_vma signature_high
= 0;
3626 dwarf_vma signature_low
= 0;
3627 dwarf_vma type_offset
= 0;
3628 struct cu_tu_set
*this_set
;
3629 dwarf_vma abbrev_base
;
3631 abbrev_list
* list
= NULL
;
3635 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 4, end
);
3637 if (compunit
.cu_length
== 0xffffffff)
3639 SAFE_BYTE_GET_AND_INC (compunit
.cu_length
, hdrptr
, 8, end
);
3641 initial_length_size
= 12;
3646 initial_length_size
= 4;
3649 SAFE_BYTE_GET_AND_INC (compunit
.cu_version
, hdrptr
, 2, end
);
3651 cu_offset
= start
- section_begin
;
3653 this_set
= find_cu_tu_set_v2 (cu_offset
, do_types
);
3655 if (compunit
.cu_version
< 5)
3657 compunit
.cu_unit_type
= DW_UT_compile
;
3658 /* Initialize it due to a false compiler warning. */
3659 compunit
.cu_pointer_size
= -1;
3663 SAFE_BYTE_GET_AND_INC (compunit
.cu_unit_type
, hdrptr
, 1, end
);
3664 do_types
= (compunit
.cu_unit_type
== DW_UT_type
);
3666 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3669 SAFE_BYTE_GET_AND_INC (compunit
.cu_abbrev_offset
, hdrptr
, offset_size
, end
);
3671 if (this_set
== NULL
)
3674 abbrev_size
= debug_displays
[abbrev_sec
].section
.size
;
3678 abbrev_base
= this_set
->section_offsets
[DW_SECT_ABBREV
];
3679 abbrev_size
= this_set
->section_sizes
[DW_SECT_ABBREV
];
3682 if (compunit
.cu_version
< 5)
3683 SAFE_BYTE_GET_AND_INC (compunit
.cu_pointer_size
, hdrptr
, 1, end
);
3685 /* PR 17512: file: 001-108546-0.001:0.1. */
3686 if (compunit
.cu_pointer_size
< 2 || compunit
.cu_pointer_size
> 8)
3688 warn (_("Invalid pointer size (%d) in compunit header, using %d instead\n"),
3689 compunit
.cu_pointer_size
, offset_size
);
3690 compunit
.cu_pointer_size
= offset_size
;
3695 SAFE_BYTE_GET64 (hdrptr
, &signature_high
, &signature_low
, end
);
3697 SAFE_BYTE_GET_AND_INC (type_offset
, hdrptr
, offset_size
, end
);
3700 if (dwarf_start_die
> (cu_offset
+ compunit
.cu_length
3701 + initial_length_size
))
3703 start
= section_begin
+ cu_offset
+ compunit
.cu_length
3704 + initial_length_size
;
3708 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
3709 && num_debug_info_entries
== 0
3710 && alloc_num_debug_info_entries
> unit
3713 debug_information
[unit
].cu_offset
= cu_offset
;
3714 debug_information
[unit
].pointer_size
3715 = compunit
.cu_pointer_size
;
3716 debug_information
[unit
].offset_size
= offset_size
;
3717 debug_information
[unit
].dwarf_version
= compunit
.cu_version
;
3718 debug_information
[unit
].base_address
= 0;
3719 debug_information
[unit
].addr_base
= DEBUG_INFO_UNAVAILABLE
;
3720 debug_information
[unit
].ranges_base
= DEBUG_INFO_UNAVAILABLE
;
3721 debug_information
[unit
].loc_offsets
= NULL
;
3722 debug_information
[unit
].have_frame_base
= NULL
;
3723 debug_information
[unit
].max_loc_offsets
= 0;
3724 debug_information
[unit
].num_loc_offsets
= 0;
3725 debug_information
[unit
].range_lists
= NULL
;
3726 debug_information
[unit
].max_range_lists
= 0;
3727 debug_information
[unit
].num_range_lists
= 0;
3730 if (!do_loc
&& dwarf_start_die
== 0)
3732 printf (_(" Compilation Unit @ offset 0x%s:\n"),
3733 dwarf_vmatoa ("x", cu_offset
));
3734 printf (_(" Length: 0x%s (%s)\n"),
3735 dwarf_vmatoa ("x", compunit
.cu_length
),
3736 offset_size
== 8 ? "64-bit" : "32-bit");
3737 printf (_(" Version: %d\n"), compunit
.cu_version
);
3738 if (compunit
.cu_version
>= 5)
3739 printf (_(" Unit Type: %s (%x)\n"),
3740 get_DW_UT_name (compunit
.cu_unit_type
) ?: "???",
3741 compunit
.cu_unit_type
);
3742 printf (_(" Abbrev Offset: 0x%s\n"),
3743 dwarf_vmatoa ("x", compunit
.cu_abbrev_offset
));
3744 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
3749 printf (_(" Signature: 0x%s\n"),
3750 dwarf_vmatoa64 (signature_high
, signature_low
,
3751 buf
, sizeof (buf
)));
3752 printf (_(" Type Offset: 0x%s\n"),
3753 dwarf_vmatoa ("x", type_offset
));
3755 if (this_set
!= NULL
)
3757 dwarf_vma
*offsets
= this_set
->section_offsets
;
3758 size_t *sizes
= this_set
->section_sizes
;
3760 printf (_(" Section contributions:\n"));
3761 printf (_(" .debug_abbrev.dwo: 0x%s 0x%s\n"),
3762 dwarf_vmatoa ("x", offsets
[DW_SECT_ABBREV
]),
3763 dwarf_vmatoa ("x", sizes
[DW_SECT_ABBREV
]));
3764 printf (_(" .debug_line.dwo: 0x%s 0x%s\n"),
3765 dwarf_vmatoa ("x", offsets
[DW_SECT_LINE
]),
3766 dwarf_vmatoa ("x", sizes
[DW_SECT_LINE
]));
3767 printf (_(" .debug_loc.dwo: 0x%s 0x%s\n"),
3768 dwarf_vmatoa ("x", offsets
[DW_SECT_LOC
]),
3769 dwarf_vmatoa ("x", sizes
[DW_SECT_LOC
]));
3770 printf (_(" .debug_str_offsets.dwo: 0x%s 0x%s\n"),
3771 dwarf_vmatoa ("x", offsets
[DW_SECT_STR_OFFSETS
]),
3772 dwarf_vmatoa ("x", sizes
[DW_SECT_STR_OFFSETS
]));
3776 sec_off
= cu_offset
+ initial_length_size
;
3777 if (sec_off
+ compunit
.cu_length
< sec_off
3778 || sec_off
+ compunit
.cu_length
> section
->size
)
3780 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
3782 (unsigned long) cu_offset
,
3783 dwarf_vmatoa ("x", compunit
.cu_length
));
3789 start
+= compunit
.cu_length
+ initial_length_size
;
3791 if (compunit
.cu_version
< 2 || compunit
.cu_version
> 5)
3793 warn (_("CU at offset %s contains corrupt or "
3794 "unsupported version number: %d.\n"),
3795 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_version
);
3799 if (compunit
.cu_unit_type
!= DW_UT_compile
3800 && compunit
.cu_unit_type
!= DW_UT_partial
3801 && compunit
.cu_unit_type
!= DW_UT_type
)
3803 warn (_("CU at offset %s contains corrupt or "
3804 "unsupported unit type: %d.\n"),
3805 dwarf_vmatoa ("x", cu_offset
), compunit
.cu_unit_type
);
3809 /* Process the abbrevs used by this compilation unit. */
3810 if (compunit
.cu_abbrev_offset
>= abbrev_size
)
3811 warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
3812 (unsigned long) compunit
.cu_abbrev_offset
,
3813 (unsigned long) abbrev_size
);
3814 /* PR 17531: file:4bcd9ce9. */
3815 else if ((abbrev_base
+ abbrev_size
)
3816 > debug_displays
[abbrev_sec
].section
.size
)
3817 warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"),
3818 (unsigned long) abbrev_base
+ abbrev_size
,
3819 (unsigned long) debug_displays
[abbrev_sec
].section
.size
);
3822 list
= find_abbrev_list_by_abbrev_offset (abbrev_base
,
3823 compunit
.cu_abbrev_offset
);
3826 unsigned char * next
;
3828 list
= new_abbrev_list (abbrev_base
,
3829 compunit
.cu_abbrev_offset
);
3830 next
= process_abbrev_set
3831 (((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3832 + abbrev_base
+ compunit
.cu_abbrev_offset
),
3833 ((unsigned char *) debug_displays
[abbrev_sec
].section
.start
3834 + abbrev_base
+ abbrev_size
),
3836 list
->start_of_next_abbrevs
= next
;
3843 while (tags
< start
)
3845 unsigned long abbrev_number
;
3846 unsigned long die_offset
;
3847 abbrev_entry
*entry
;
3849 int do_printing
= 1;
3851 die_offset
= tags
- section_begin
;
3853 READ_ULEB (abbrev_number
, tags
, start
);
3855 /* A null DIE marks the end of a list of siblings or it may also be
3856 a section padding. */
3857 if (abbrev_number
== 0)
3859 /* Check if it can be a section padding for the last CU. */
3860 if (level
== 0 && start
== end
)
3864 for (chk
= tags
; chk
< start
; chk
++)
3871 if (!do_loc
&& die_offset
>= dwarf_start_die
3872 && (dwarf_cutoff_level
== -1
3873 || level
< dwarf_cutoff_level
))
3874 printf (_(" <%d><%lx>: Abbrev Number: 0\n"),
3880 static unsigned num_bogus_warns
= 0;
3882 if (num_bogus_warns
< 3)
3884 warn (_("Bogus end-of-siblings marker detected at offset %lx in %s section\n"),
3885 die_offset
, section
->name
);
3887 if (num_bogus_warns
== 3)
3888 warn (_("Further warnings about bogus end-of-sibling markers suppressed\n"));
3891 if (dwarf_start_die
!= 0 && level
< saved_level
)
3898 if (dwarf_start_die
!= 0 && die_offset
< dwarf_start_die
)
3902 if (dwarf_start_die
!= 0 && die_offset
== dwarf_start_die
)
3903 saved_level
= level
;
3904 do_printing
= (dwarf_cutoff_level
== -1
3905 || level
< dwarf_cutoff_level
);
3907 printf (_(" <%d><%lx>: Abbrev Number: %lu"),
3908 level
, die_offset
, abbrev_number
);
3909 else if (dwarf_cutoff_level
== -1
3910 || last_level
< dwarf_cutoff_level
)
3911 printf (_(" <%d><%lx>: ...\n"), level
, die_offset
);
3916 /* Scan through the abbreviation list until we reach the
3921 for (entry
= list
->first_abbrev
; entry
!= NULL
; entry
= entry
->next
)
3922 if (entry
->number
== abbrev_number
)
3927 if (!do_loc
&& do_printing
)
3932 warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
3933 die_offset
, abbrev_number
);
3937 if (!do_loc
&& do_printing
)
3938 printf (" (%s)\n", get_TAG_name (entry
->tag
));
3943 need_base_address
= 0;
3945 case DW_TAG_compile_unit
:
3946 need_base_address
= 1;
3947 need_dwo_info
= do_loc
;
3949 case DW_TAG_entry_point
:
3950 case DW_TAG_subprogram
:
3951 need_base_address
= 0;
3952 /* Assuming that there is no DW_AT_frame_base. */
3953 have_frame_base
= 0;
3957 debug_info
*debug_info_p
=
3958 (debug_information
&& unit
< alloc_num_debug_info_entries
)
3959 ? debug_information
+ unit
: NULL
;
3961 assert (!debug_info_p
3962 || (debug_info_p
->num_loc_offsets
3963 == debug_info_p
->num_loc_views
));
3965 for (attr
= entry
->first_attr
;
3966 attr
&& attr
->attribute
;
3969 if (! do_loc
&& do_printing
)
3970 /* Show the offset from where the tag was extracted. */
3971 printf (" <%lx>", (unsigned long)(tags
- section_begin
));
3972 tags
= read_and_display_attr (attr
->attribute
,
3974 attr
->implicit_const
,
3979 compunit
.cu_pointer_size
,
3981 compunit
.cu_version
,
3983 do_loc
|| ! do_printing
,
3989 /* If a locview attribute appears before a location one,
3990 make sure we don't associate it with an earlier
3993 switch (debug_info_p
->num_loc_offsets
- debug_info_p
->num_loc_views
)
3996 debug_info_p
->loc_views
[debug_info_p
->num_loc_views
] = vm1
;
3997 debug_info_p
->num_loc_views
++;
3998 assert (debug_info_p
->num_loc_views
3999 == debug_info_p
->num_loc_offsets
);
4006 warn(_("DIE has locviews without loclist\n"));
4007 debug_info_p
->num_loc_views
--;
4014 if (entry
->children
)
4019 /* Set num_debug_info_entries here so that it can be used to check if
4020 we need to process .debug_loc and .debug_ranges sections. */
4021 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
4022 && num_debug_info_entries
== 0
4025 if (num_units
> alloc_num_debug_info_entries
)
4026 num_debug_info_entries
= alloc_num_debug_info_entries
;
4028 num_debug_info_entries
= num_units
;
4037 /* Locate and scan the .debug_info section in the file and record the pointer
4038 sizes and offsets for the compilation units in it. Usually an executable
4039 will have just one pointer size, but this is not guaranteed, and so we try
4040 not to make any assumptions. Returns zero upon failure, or the number of
4041 compilation units upon success. */
4044 load_debug_info (void * file
)
4046 /* If we have already tried and failed to load the .debug_info
4047 section then do not bother to repeat the task. */
4048 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
4051 /* If we already have the information there is nothing else to do. */
4052 if (num_debug_info_entries
> 0)
4053 return num_debug_info_entries
;
4055 /* If this is a DWARF package file, load the CU and TU indexes. */
4056 (void) load_cu_tu_indexes (file
);
4058 if (load_debug_section_with_follow (info
, file
)
4059 && process_debug_info (&debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
4060 return num_debug_info_entries
;
4062 if (load_debug_section_with_follow (info_dwo
, file
)
4063 && process_debug_info (&debug_displays
[info_dwo
].section
, file
,
4064 abbrev_dwo
, TRUE
, FALSE
))
4065 return num_debug_info_entries
;
4067 num_debug_info_entries
= DEBUG_INFO_UNAVAILABLE
;
4071 /* Read a DWARF .debug_line section header starting at DATA.
4072 Upon success returns an updated DATA pointer and the LINFO
4073 structure and the END_OF_SEQUENCE pointer will be filled in.
4074 Otherwise returns NULL. */
4076 static unsigned char *
4077 read_debug_line_header (struct dwarf_section
* section
,
4078 unsigned char * data
,
4079 unsigned char * end
,
4080 DWARF2_Internal_LineInfo
* linfo
,
4081 unsigned char ** end_of_sequence
)
4083 unsigned char *hdrptr
;
4084 unsigned int initial_length_size
;
4086 /* Extract information from the Line Number Program Header.
4087 (section 6.2.4 in the Dwarf3 doc). */
4090 /* Get and check the length of the block. */
4091 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 4, end
);
4093 if (linfo
->li_length
== 0xffffffff)
4095 /* This section is 64-bit DWARF 3. */
4096 SAFE_BYTE_GET_AND_INC (linfo
->li_length
, hdrptr
, 8, end
);
4097 linfo
->li_offset_size
= 8;
4098 initial_length_size
= 12;
4102 linfo
->li_offset_size
= 4;
4103 initial_length_size
= 4;
4106 if (linfo
->li_length
+ initial_length_size
> section
->size
)
4108 /* If the length field has a relocation against it, then we should
4109 not complain if it is inaccurate (and probably negative). This
4110 happens in object files when the .debug_line section is actually
4111 comprised of several different .debug_line.* sections, (some of
4112 which may be removed by linker garbage collection), and a relocation
4113 is used to compute the correct length once that is done. */
4114 if (reloc_at (section
, (hdrptr
- section
->start
) - linfo
->li_offset_size
))
4116 linfo
->li_length
= (end
- data
) - initial_length_size
;
4120 warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"),
4121 (long) linfo
->li_length
);
4126 /* Get and check the version number. */
4127 SAFE_BYTE_GET_AND_INC (linfo
->li_version
, hdrptr
, 2, end
);
4129 if (linfo
->li_version
!= 2
4130 && linfo
->li_version
!= 3
4131 && linfo
->li_version
!= 4
4132 && linfo
->li_version
!= 5)
4134 warn (_("Only DWARF version 2, 3, 4 and 5 line info "
4135 "is currently supported.\n"));
4139 if (linfo
->li_version
>= 5)
4141 SAFE_BYTE_GET_AND_INC (linfo
->li_address_size
, hdrptr
, 1, end
);
4143 SAFE_BYTE_GET_AND_INC (linfo
->li_segment_size
, hdrptr
, 1, end
);
4144 if (linfo
->li_segment_size
!= 0)
4146 warn (_("The %s section contains "
4147 "unsupported segment selector size: %d.\n"),
4148 section
->name
, linfo
->li_segment_size
);
4153 SAFE_BYTE_GET_AND_INC (linfo
->li_prologue_length
, hdrptr
,
4154 linfo
->li_offset_size
, end
);
4155 SAFE_BYTE_GET_AND_INC (linfo
->li_min_insn_length
, hdrptr
, 1, end
);
4157 if (linfo
->li_version
>= 4)
4159 SAFE_BYTE_GET_AND_INC (linfo
->li_max_ops_per_insn
, hdrptr
, 1, end
);
4161 if (linfo
->li_max_ops_per_insn
== 0)
4163 warn (_("Invalid maximum operations per insn.\n"));
4168 linfo
->li_max_ops_per_insn
= 1;
4170 SAFE_BYTE_GET_AND_INC (linfo
->li_default_is_stmt
, hdrptr
, 1, end
);
4171 SAFE_SIGNED_BYTE_GET_AND_INC (linfo
->li_line_base
, hdrptr
, 1, end
);
4172 SAFE_BYTE_GET_AND_INC (linfo
->li_line_range
, hdrptr
, 1, end
);
4173 SAFE_BYTE_GET_AND_INC (linfo
->li_opcode_base
, hdrptr
, 1, end
);
4175 * end_of_sequence
= data
+ linfo
->li_length
+ initial_length_size
;
4176 /* PR 17512: file:002-117414-0.004. */
4177 if (* end_of_sequence
> end
)
4179 warn (_("Line length %s extends beyond end of section\n"),
4180 dwarf_vmatoa ("u", linfo
->li_length
));
4181 * end_of_sequence
= end
;
4188 static unsigned char *
4189 display_formatted_table (unsigned char * data
,
4190 unsigned char * start
,
4191 unsigned char * end
,
4192 const DWARF2_Internal_LineInfo
* linfo
,
4193 struct dwarf_section
* section
,
4196 unsigned char *format_start
, format_count
, *format
, formati
;
4197 dwarf_vma data_count
, datai
;
4198 unsigned int namepass
, last_entry
= 0;
4199 const char * table_name
= is_dir
? N_("Directory Table") : N_("File Name Table");
4201 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4202 if (do_checks
&& format_count
> 5)
4203 warn (_("Unexpectedly large number of columns in the %s (%u)\n"),
4204 table_name
, format_count
);
4206 format_start
= data
;
4207 for (formati
= 0; formati
< format_count
; formati
++)
4209 SKIP_ULEB (data
, end
);
4210 SKIP_ULEB (data
, end
);
4213 warn (_("%s: Corrupt format description entry\n"), table_name
);
4218 READ_ULEB (data_count
, data
, end
);
4219 if (data_count
== 0)
4221 printf (_("\n The %s is empty.\n"), table_name
);
4224 else if (data
== end
)
4226 warn (_("%s: Corrupt entry count - expected %s but none found\n"),
4227 table_name
, dwarf_vmatoa ("x", data_count
));
4231 else if (format_count
== 0)
4233 warn (_("%s: format count is zero, but the table is not empty\n"),
4238 printf (_("\n The %s (offset 0x%lx, lines %s, columns %u):\n"),
4239 table_name
, (long) (data
- start
), dwarf_vmatoa ("u", data_count
),
4242 printf (_(" Entry"));
4243 /* Delay displaying name as the last entry for better screen layout. */
4244 for (namepass
= 0; namepass
< 2; namepass
++)
4246 format
= format_start
;
4247 for (formati
= 0; formati
< format_count
; formati
++)
4249 dwarf_vma content_type
;
4251 READ_ULEB (content_type
, format
, end
);
4252 if ((content_type
== DW_LNCT_path
) == (namepass
== 1))
4253 switch (content_type
)
4256 printf (_("\tName"));
4258 case DW_LNCT_directory_index
:
4259 printf (_("\tDir"));
4261 case DW_LNCT_timestamp
:
4262 printf (_("\tTime"));
4265 printf (_("\tSize"));
4268 printf (_("\tMD5\t\t\t"));
4271 printf (_("\t(Unknown format content type %s)"),
4272 dwarf_vmatoa ("u", content_type
));
4274 SKIP_ULEB (format
, end
);
4279 for (datai
= 0; datai
< data_count
; datai
++)
4281 unsigned char *datapass
= data
;
4283 printf (" %d", last_entry
++);
4284 /* Delay displaying name as the last entry for better screen layout. */
4285 for (namepass
= 0; namepass
< 2; namepass
++)
4287 format
= format_start
;
4289 for (formati
= 0; formati
< format_count
; formati
++)
4291 dwarf_vma content_type
, form
;
4293 READ_ULEB (content_type
, format
, end
);
4294 READ_ULEB (form
, format
, end
);
4295 data
= read_and_display_attr_value (0, form
, 0, start
, data
, end
,
4296 0, 0, linfo
->li_offset_size
,
4297 linfo
->li_version
, NULL
,
4298 ((content_type
== DW_LNCT_path
) != (namepass
== 1)),
4299 section
, NULL
, '\t', -1);
4303 if (data
== end
&& (datai
< data_count
- 1))
4305 warn (_("\n%s: Corrupt entries list\n"), table_name
);
4314 display_debug_lines_raw (struct dwarf_section
* section
,
4315 unsigned char * data
,
4316 unsigned char * end
,
4319 unsigned char *start
= section
->start
;
4320 int verbose_view
= 0;
4322 introduce (section
, TRUE
);
4326 static DWARF2_Internal_LineInfo saved_linfo
;
4327 DWARF2_Internal_LineInfo linfo
;
4328 unsigned char *standard_opcodes
;
4329 unsigned char *end_of_sequence
;
4332 if (const_strneq (section
->name
, ".debug_line.")
4333 /* Note: the following does not apply to .debug_line.dwo sections.
4334 These are full debug_line sections. */
4335 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4337 /* Sections named .debug_line.<foo> are fragments of a .debug_line
4338 section containing just the Line Number Statements. They are
4339 created by the assembler and intended to be used alongside gcc's
4340 -ffunction-sections command line option. When the linker's
4341 garbage collection decides to discard a .text.<foo> section it
4342 can then also discard the line number information in .debug_line.<foo>.
4344 Since the section is a fragment it does not have the details
4345 needed to fill out a LineInfo structure, so instead we use the
4346 details from the last full debug_line section that we processed. */
4347 end_of_sequence
= end
;
4348 standard_opcodes
= NULL
;
4349 linfo
= saved_linfo
;
4350 /* PR 17531: file: 0522b371. */
4351 if (linfo
.li_line_range
== 0)
4353 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4356 reset_state_machine (linfo
.li_default_is_stmt
);
4360 unsigned char * hdrptr
;
4362 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4363 & end_of_sequence
)) == NULL
)
4366 printf (_(" Offset: 0x%lx\n"), (long)(data
- start
));
4367 printf (_(" Length: %ld\n"), (long) linfo
.li_length
);
4368 printf (_(" DWARF Version: %d\n"), linfo
.li_version
);
4369 if (linfo
.li_version
>= 5)
4371 printf (_(" Address size (bytes): %d\n"), linfo
.li_address_size
);
4372 printf (_(" Segment selector (bytes): %d\n"), linfo
.li_segment_size
);
4374 printf (_(" Prologue Length: %d\n"), (int) linfo
.li_prologue_length
);
4375 printf (_(" Minimum Instruction Length: %d\n"), linfo
.li_min_insn_length
);
4376 if (linfo
.li_version
>= 4)
4377 printf (_(" Maximum Ops per Instruction: %d\n"), linfo
.li_max_ops_per_insn
);
4378 printf (_(" Initial value of 'is_stmt': %d\n"), linfo
.li_default_is_stmt
);
4379 printf (_(" Line Base: %d\n"), linfo
.li_line_base
);
4380 printf (_(" Line Range: %d\n"), linfo
.li_line_range
);
4381 printf (_(" Opcode Base: %d\n"), linfo
.li_opcode_base
);
4383 /* PR 17512: file: 1665-6428-0.004. */
4384 if (linfo
.li_line_range
== 0)
4386 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4387 linfo
.li_line_range
= 1;
4390 reset_state_machine (linfo
.li_default_is_stmt
);
4392 /* Display the contents of the Opcodes table. */
4393 standard_opcodes
= hdrptr
;
4395 /* PR 17512: file: 002-417945-0.004. */
4396 if (standard_opcodes
+ linfo
.li_opcode_base
>= end
)
4398 warn (_("Line Base extends beyond end of section\n"));
4402 printf (_("\n Opcodes:\n"));
4404 for (i
= 1; i
< linfo
.li_opcode_base
; i
++)
4405 printf (ngettext (" Opcode %d has %d arg\n",
4406 " Opcode %d has %d args\n",
4407 standard_opcodes
[i
- 1]),
4408 i
, standard_opcodes
[i
- 1]);
4410 /* Display the contents of the Directory table. */
4411 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4413 if (linfo
.li_version
>= 5)
4415 load_debug_section_with_follow (line_str
, file
);
4417 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4419 data
= display_formatted_table (data
, start
, end
, &linfo
, section
,
4425 printf (_("\n The Directory Table is empty.\n"));
4428 unsigned int last_dir_entry
= 0;
4430 printf (_("\n The Directory Table (offset 0x%lx):\n"),
4431 (long)(data
- start
));
4433 while (data
< end
&& *data
!= 0)
4435 printf (" %d\t%.*s\n", ++last_dir_entry
, (int) (end
- data
), data
);
4437 data
+= strnlen ((char *) data
, end
- data
) + 1;
4440 /* PR 17512: file: 002-132094-0.004. */
4441 if (data
>= end
- 1)
4445 /* Skip the NUL at the end of the table. */
4448 /* Display the contents of the File Name table. */
4450 printf (_("\n The File Name Table is empty.\n"));
4453 printf (_("\n The File Name Table (offset 0x%lx):\n"),
4454 (long)(data
- start
));
4455 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4457 while (data
< end
&& *data
!= 0)
4459 unsigned char *name
;
4462 printf (" %d\t", ++state_machine_regs
.last_file_entry
);
4464 data
+= strnlen ((char *) data
, end
- data
) + 1;
4466 READ_ULEB (val
, data
, end
);
4467 printf ("%s\t", dwarf_vmatoa ("u", val
));
4468 READ_ULEB (val
, data
, end
);
4469 printf ("%s\t", dwarf_vmatoa ("u", val
));
4470 READ_ULEB (val
, data
, end
);
4471 printf ("%s\t", dwarf_vmatoa ("u", val
));
4472 printf ("%.*s\n", (int)(end
- name
), name
);
4476 warn (_("Corrupt file name table entry\n"));
4482 /* Skip the NUL at the end of the table. */
4487 saved_linfo
= linfo
;
4490 /* Now display the statements. */
4491 if (data
>= end_of_sequence
)
4492 printf (_(" No Line Number Statements.\n"));
4495 printf (_(" Line Number Statements:\n"));
4497 while (data
< end_of_sequence
)
4499 unsigned char op_code
;
4500 dwarf_signed_vma adv
;
4503 printf (" [0x%08lx]", (long)(data
- start
));
4507 if (op_code
>= linfo
.li_opcode_base
)
4509 op_code
-= linfo
.li_opcode_base
;
4510 uladv
= (op_code
/ linfo
.li_line_range
);
4511 if (linfo
.li_max_ops_per_insn
== 1)
4513 uladv
*= linfo
.li_min_insn_length
;
4514 state_machine_regs
.address
+= uladv
;
4516 state_machine_regs
.view
= 0;
4517 printf (_(" Special opcode %d: "
4518 "advance Address by %s to 0x%s%s"),
4519 op_code
, dwarf_vmatoa ("u", uladv
),
4520 dwarf_vmatoa ("x", state_machine_regs
.address
),
4521 verbose_view
&& uladv
4522 ? _(" (reset view)") : "");
4527 = ((state_machine_regs
.op_index
+ uladv
)
4528 / linfo
.li_max_ops_per_insn
)
4529 * linfo
.li_min_insn_length
;
4531 state_machine_regs
.address
+= addrdelta
;
4532 state_machine_regs
.op_index
4533 = (state_machine_regs
.op_index
+ uladv
)
4534 % linfo
.li_max_ops_per_insn
;
4536 state_machine_regs
.view
= 0;
4537 printf (_(" Special opcode %d: "
4538 "advance Address by %s to 0x%s[%d]%s"),
4539 op_code
, dwarf_vmatoa ("u", uladv
),
4540 dwarf_vmatoa ("x", state_machine_regs
.address
),
4541 state_machine_regs
.op_index
,
4542 verbose_view
&& addrdelta
4543 ? _(" (reset view)") : "");
4545 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
4546 state_machine_regs
.line
+= adv
;
4547 printf (_(" and Line by %s to %d"),
4548 dwarf_vmatoa ("d", adv
), state_machine_regs
.line
);
4549 if (verbose_view
|| state_machine_regs
.view
)
4550 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4553 state_machine_regs
.view
++;
4558 case DW_LNS_extended_op
:
4559 data
+= process_extended_line_op (data
,
4560 linfo
.li_default_is_stmt
,
4565 printf (_(" Copy"));
4566 if (verbose_view
|| state_machine_regs
.view
)
4567 printf (_(" (view %u)\n"), state_machine_regs
.view
);
4570 state_machine_regs
.view
++;
4573 case DW_LNS_advance_pc
:
4574 READ_ULEB (uladv
, data
, end
);
4575 if (linfo
.li_max_ops_per_insn
== 1)
4577 uladv
*= linfo
.li_min_insn_length
;
4578 state_machine_regs
.address
+= uladv
;
4580 state_machine_regs
.view
= 0;
4581 printf (_(" Advance PC by %s to 0x%s%s\n"),
4582 dwarf_vmatoa ("u", uladv
),
4583 dwarf_vmatoa ("x", state_machine_regs
.address
),
4584 verbose_view
&& uladv
4585 ? _(" (reset view)") : "");
4590 = ((state_machine_regs
.op_index
+ uladv
)
4591 / linfo
.li_max_ops_per_insn
)
4592 * linfo
.li_min_insn_length
;
4593 state_machine_regs
.address
4595 state_machine_regs
.op_index
4596 = (state_machine_regs
.op_index
+ uladv
)
4597 % linfo
.li_max_ops_per_insn
;
4599 state_machine_regs
.view
= 0;
4600 printf (_(" Advance PC by %s to 0x%s[%d]%s\n"),
4601 dwarf_vmatoa ("u", uladv
),
4602 dwarf_vmatoa ("x", state_machine_regs
.address
),
4603 state_machine_regs
.op_index
,
4604 verbose_view
&& addrdelta
4605 ? _(" (reset view)") : "");
4609 case DW_LNS_advance_line
:
4610 READ_SLEB (adv
, data
, end
);
4611 state_machine_regs
.line
+= adv
;
4612 printf (_(" Advance Line by %s to %d\n"),
4613 dwarf_vmatoa ("d", adv
),
4614 state_machine_regs
.line
);
4617 case DW_LNS_set_file
:
4618 READ_ULEB (uladv
, data
, end
);
4619 printf (_(" Set File Name to entry %s in the File Name Table\n"),
4620 dwarf_vmatoa ("u", uladv
));
4621 state_machine_regs
.file
= uladv
;
4624 case DW_LNS_set_column
:
4625 READ_ULEB (uladv
, data
, end
);
4626 printf (_(" Set column to %s\n"),
4627 dwarf_vmatoa ("u", uladv
));
4628 state_machine_regs
.column
= uladv
;
4631 case DW_LNS_negate_stmt
:
4632 adv
= state_machine_regs
.is_stmt
;
4634 printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa ("d", adv
));
4635 state_machine_regs
.is_stmt
= adv
;
4638 case DW_LNS_set_basic_block
:
4639 printf (_(" Set basic block\n"));
4640 state_machine_regs
.basic_block
= 1;
4643 case DW_LNS_const_add_pc
:
4644 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
4645 if (linfo
.li_max_ops_per_insn
)
4647 uladv
*= linfo
.li_min_insn_length
;
4648 state_machine_regs
.address
+= uladv
;
4650 state_machine_regs
.view
= 0;
4651 printf (_(" Advance PC by constant %s to 0x%s%s\n"),
4652 dwarf_vmatoa ("u", uladv
),
4653 dwarf_vmatoa ("x", state_machine_regs
.address
),
4654 verbose_view
&& uladv
4655 ? _(" (reset view)") : "");
4660 = ((state_machine_regs
.op_index
+ uladv
)
4661 / linfo
.li_max_ops_per_insn
)
4662 * linfo
.li_min_insn_length
;
4663 state_machine_regs
.address
4665 state_machine_regs
.op_index
4666 = (state_machine_regs
.op_index
+ uladv
)
4667 % linfo
.li_max_ops_per_insn
;
4669 state_machine_regs
.view
= 0;
4670 printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"),
4671 dwarf_vmatoa ("u", uladv
),
4672 dwarf_vmatoa ("x", state_machine_regs
.address
),
4673 state_machine_regs
.op_index
,
4674 verbose_view
&& addrdelta
4675 ? _(" (reset view)") : "");
4679 case DW_LNS_fixed_advance_pc
:
4680 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
4681 state_machine_regs
.address
+= uladv
;
4682 state_machine_regs
.op_index
= 0;
4683 printf (_(" Advance PC by fixed size amount %s to 0x%s\n"),
4684 dwarf_vmatoa ("u", uladv
),
4685 dwarf_vmatoa ("x", state_machine_regs
.address
));
4686 /* Do NOT reset view. */
4689 case DW_LNS_set_prologue_end
:
4690 printf (_(" Set prologue_end to true\n"));
4693 case DW_LNS_set_epilogue_begin
:
4694 printf (_(" Set epilogue_begin to true\n"));
4697 case DW_LNS_set_isa
:
4698 READ_ULEB (uladv
, data
, end
);
4699 printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv
));
4703 printf (_(" Unknown opcode %d with operands: "), op_code
);
4705 if (standard_opcodes
!= NULL
)
4706 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
4708 READ_ULEB (uladv
, data
, end
);
4709 printf ("0x%s%s", dwarf_vmatoa ("x", uladv
),
4710 i
== 1 ? "" : ", ");
4725 unsigned char *name
;
4726 unsigned int directory_index
;
4727 unsigned int modification_date
;
4728 unsigned int length
;
4731 /* Output a decoded representation of the .debug_line section. */
4734 display_debug_lines_decoded (struct dwarf_section
* section
,
4735 unsigned char * start
,
4736 unsigned char * data
,
4737 unsigned char * end
,
4740 static DWARF2_Internal_LineInfo saved_linfo
;
4742 introduce (section
, FALSE
);
4746 /* This loop amounts to one iteration per compilation unit. */
4747 DWARF2_Internal_LineInfo linfo
;
4748 unsigned char *standard_opcodes
;
4749 unsigned char *end_of_sequence
;
4751 File_Entry
*file_table
= NULL
;
4752 unsigned int n_files
= 0;
4753 unsigned char **directory_table
= NULL
;
4754 dwarf_vma n_directories
= 0;
4756 if (const_strneq (section
->name
, ".debug_line.")
4757 /* Note: the following does not apply to .debug_line.dwo sections.
4758 These are full debug_line sections. */
4759 && strcmp (section
->name
, ".debug_line.dwo") != 0)
4761 /* See comment in display_debug_lines_raw(). */
4762 end_of_sequence
= end
;
4763 standard_opcodes
= NULL
;
4764 linfo
= saved_linfo
;
4765 /* PR 17531: file: 0522b371. */
4766 if (linfo
.li_line_range
== 0)
4768 warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n"));
4771 reset_state_machine (linfo
.li_default_is_stmt
);
4775 unsigned char *hdrptr
;
4777 if ((hdrptr
= read_debug_line_header (section
, data
, end
, & linfo
,
4778 & end_of_sequence
)) == NULL
)
4781 /* PR 17531: file: 0522b371. */
4782 if (linfo
.li_line_range
== 0)
4784 warn (_("Line range of 0 is invalid, using 1 instead\n"));
4785 linfo
.li_line_range
= 1;
4787 reset_state_machine (linfo
.li_default_is_stmt
);
4789 /* Save a pointer to the contents of the Opcodes table. */
4790 standard_opcodes
= hdrptr
;
4792 /* Traverse the Directory table just to count entries. */
4793 data
= standard_opcodes
+ linfo
.li_opcode_base
- 1;
4797 warn (_("opcode base of %d extends beyond end of section\n"),
4798 linfo
.li_opcode_base
);
4802 if (linfo
.li_version
>= 5)
4804 unsigned char *format_start
, format_count
, *format
;
4805 dwarf_vma formati
, entryi
;
4807 load_debug_section_with_follow (line_str
, fileptr
);
4809 /* Skip directories format. */
4810 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4811 if (do_checks
&& format_count
> 1)
4812 warn (_("Unexpectedly large number of columns in the directory name table (%u)\n"),
4814 format_start
= data
;
4815 for (formati
= 0; formati
< format_count
; formati
++)
4817 SKIP_ULEB (data
, end
);
4818 SKIP_ULEB (data
, end
);
4821 READ_ULEB (n_directories
, data
, end
);
4824 warn (_("Corrupt directories list\n"));
4828 if (n_directories
== 0)
4829 directory_table
= NULL
;
4831 directory_table
= (unsigned char **)
4832 xmalloc (n_directories
* sizeof (unsigned char *));
4834 for (entryi
= 0; entryi
< n_directories
; entryi
++)
4836 unsigned char **pathp
= &directory_table
[entryi
];
4838 format
= format_start
;
4839 for (formati
= 0; formati
< format_count
; formati
++)
4841 dwarf_vma content_type
, form
;
4844 READ_ULEB (content_type
, format
, end
);
4845 READ_ULEB (form
, format
, end
);
4848 warn (_("Corrupt directories list\n"));
4851 switch (content_type
)
4856 case DW_FORM_string
:
4859 case DW_FORM_line_strp
:
4860 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4862 /* Remove const by the cast. */
4863 *pathp
= (unsigned char *)
4864 fetch_indirect_line_string (uvalue
);
4869 data
= read_and_display_attr_value (0, form
, 0, start
,
4871 linfo
.li_offset_size
,
4878 warn (_("Corrupt directories list\n"));
4883 /* Skip files format. */
4884 SAFE_BYTE_GET_AND_INC (format_count
, data
, 1, end
);
4885 if (do_checks
&& format_count
> 5)
4886 warn (_("Unexpectedly large number of columns in the file name table (%u)\n"),
4888 format_start
= data
;
4889 for (formati
= 0; formati
< format_count
; formati
++)
4891 SKIP_ULEB (data
, end
);
4892 SKIP_ULEB (data
, end
);
4895 READ_ULEB (n_files
, data
, end
);
4896 if (data
== end
&& n_files
> 0)
4898 warn (_("Corrupt file name list\n"));
4905 file_table
= (File_Entry
*) xcalloc (1, n_files
4906 * sizeof (File_Entry
));
4908 for (entryi
= 0; entryi
< n_files
; entryi
++)
4910 File_Entry
*file
= &file_table
[entryi
];
4912 format
= format_start
;
4913 for (formati
= 0; formati
< format_count
; formati
++)
4915 dwarf_vma content_type
, form
;
4919 READ_ULEB (content_type
, format
, end
);
4920 READ_ULEB (form
, format
, end
);
4923 warn (_("Corrupt file name list\n"));
4926 switch (content_type
)
4931 case DW_FORM_string
:
4934 case DW_FORM_line_strp
:
4935 SAFE_BYTE_GET (uvalue
, data
, linfo
.li_offset_size
,
4937 /* Remove const by the cast. */
4938 file
->name
= (unsigned char *)
4939 fetch_indirect_line_string (uvalue
);
4943 case DW_LNCT_directory_index
:
4947 SAFE_BYTE_GET (file
->directory_index
, data
, 1,
4951 SAFE_BYTE_GET (file
->directory_index
, data
, 2,
4956 READ_ULEB (file
->directory_index
, tmp
, end
);
4961 data
= read_and_display_attr_value (0, form
, 0, start
,
4963 linfo
.li_offset_size
,
4970 warn (_("Corrupt file name list\n"));
4979 unsigned char *ptr_directory_table
= data
;
4981 while (data
< end
&& *data
!= 0)
4983 data
+= strnlen ((char *) data
, end
- data
) + 1;
4990 warn (_("directory table ends unexpectedly\n"));
4995 /* Go through the directory table again to save the directories. */
4996 directory_table
= (unsigned char **)
4997 xmalloc (n_directories
* sizeof (unsigned char *));
5000 while (*ptr_directory_table
!= 0)
5002 directory_table
[i
] = ptr_directory_table
;
5003 ptr_directory_table
+= strnlen ((char *) ptr_directory_table
,
5004 ptr_directory_table
- end
) + 1;
5008 /* Skip the NUL at the end of the table. */
5011 /* Traverse the File Name table just to count the entries. */
5012 if (data
< end
&& *data
!= 0)
5014 unsigned char *ptr_file_name_table
= data
;
5016 while (data
< end
&& *data
!= 0)
5018 /* Skip Name, directory index, last modification
5019 time and length of file. */
5020 data
+= strnlen ((char *) data
, end
- data
) + 1;
5021 SKIP_ULEB (data
, end
);
5022 SKIP_ULEB (data
, end
);
5023 SKIP_ULEB (data
, end
);
5029 warn (_("file table ends unexpectedly\n"));
5034 /* Go through the file table again to save the strings. */
5035 file_table
= (File_Entry
*) xmalloc (n_files
* sizeof (File_Entry
));
5038 while (*ptr_file_name_table
!= 0)
5040 file_table
[i
].name
= ptr_file_name_table
;
5041 ptr_file_name_table
+= strnlen ((char *) ptr_file_name_table
,
5042 end
- ptr_file_name_table
) + 1;
5044 /* We are not interested in directory, time or size. */
5045 READ_ULEB (file_table
[i
].directory_index
,
5046 ptr_file_name_table
, end
);
5047 READ_ULEB (file_table
[i
].modification_date
,
5048 ptr_file_name_table
, end
);
5049 READ_ULEB (file_table
[i
].length
,
5050 ptr_file_name_table
, end
);
5056 /* Skip the NUL at the end of the table. */
5060 /* Print the Compilation Unit's name and a header. */
5061 if (file_table
== NULL
)
5062 printf (_("CU: No directory table\n"));
5063 else if (directory_table
== NULL
)
5064 printf (_("CU: %s:\n"), file_table
[0].name
);
5067 unsigned int ix
= file_table
[0].directory_index
;
5068 const char *directory
;
5073 else if (n_directories
== 0)
5074 directory
= _("<unknown>");
5075 else if (ix
> n_directories
)
5077 warn (_("directory index %u > number of directories %s\n"),
5078 ix
, dwarf_vmatoa ("u", n_directories
));
5079 directory
= _("<corrupt>");
5082 directory
= (char *) directory_table
[ix
- 1];
5084 if (do_wide
|| strlen (directory
) < 76)
5085 printf (_("CU: %s/%s:\n"), directory
, file_table
[0].name
);
5087 printf ("%s:\n", file_table
[0].name
);
5091 printf (_("File name Line number Starting address View Stmt\n"));
5093 printf (_("CU: Empty file name table\n"));
5094 saved_linfo
= linfo
;
5097 /* This loop iterates through the Dwarf Line Number Program. */
5098 while (data
< end_of_sequence
)
5100 unsigned char op_code
;
5103 unsigned long int uladv
;
5104 int is_special_opcode
= 0;
5109 if (op_code
>= linfo
.li_opcode_base
)
5111 op_code
-= linfo
.li_opcode_base
;
5112 uladv
= (op_code
/ linfo
.li_line_range
);
5113 if (linfo
.li_max_ops_per_insn
== 1)
5115 uladv
*= linfo
.li_min_insn_length
;
5116 state_machine_regs
.address
+= uladv
;
5118 state_machine_regs
.view
= 0;
5123 = ((state_machine_regs
.op_index
+ uladv
)
5124 / linfo
.li_max_ops_per_insn
)
5125 * linfo
.li_min_insn_length
;
5126 state_machine_regs
.address
5128 state_machine_regs
.op_index
5129 = (state_machine_regs
.op_index
+ uladv
)
5130 % linfo
.li_max_ops_per_insn
;
5132 state_machine_regs
.view
= 0;
5135 adv
= (op_code
% linfo
.li_line_range
) + linfo
.li_line_base
;
5136 state_machine_regs
.line
+= adv
;
5137 is_special_opcode
= 1;
5138 /* Increment view after printing this row. */
5143 case DW_LNS_extended_op
:
5145 unsigned int ext_op_code_len
;
5146 unsigned char ext_op_code
;
5147 unsigned char *op_code_end
;
5148 unsigned char *op_code_data
= data
;
5150 READ_ULEB (ext_op_code_len
, op_code_data
, end_of_sequence
);
5151 op_code_end
= op_code_data
+ ext_op_code_len
;
5152 if (ext_op_code_len
== 0 || op_code_end
> end_of_sequence
)
5154 warn (_("Badly formed extended line op encountered!\n"));
5157 ext_op_code
= *op_code_data
++;
5161 switch (ext_op_code
)
5163 case DW_LNE_end_sequence
:
5164 /* Reset stuff after printing this row. */
5166 case DW_LNE_set_address
:
5167 SAFE_BYTE_GET_AND_INC (state_machine_regs
.address
,
5169 op_code_end
- op_code_data
,
5171 state_machine_regs
.op_index
= 0;
5172 state_machine_regs
.view
= 0;
5174 case DW_LNE_define_file
:
5175 file_table
= (File_Entry
*) xrealloc
5176 (file_table
, (n_files
+ 1) * sizeof (File_Entry
));
5178 ++state_machine_regs
.last_file_entry
;
5179 /* Source file name. */
5180 file_table
[n_files
].name
= op_code_data
;
5181 op_code_data
+= strlen ((char *) op_code_data
) + 1;
5182 /* Directory index. */
5183 READ_ULEB (file_table
[n_files
].directory_index
,
5184 op_code_data
, op_code_end
);
5185 /* Last modification time. */
5186 READ_ULEB (file_table
[n_files
].modification_date
,
5187 op_code_data
, op_code_end
);
5189 READ_ULEB (file_table
[n_files
].length
,
5190 op_code_data
, op_code_end
);
5194 case DW_LNE_set_discriminator
:
5195 case DW_LNE_HP_set_sequence
:
5196 /* Simply ignored. */
5200 printf (_("UNKNOWN (%u): length %ld\n"),
5201 ext_op_code
, (long int) (op_code_data
- data
));
5208 /* Increment view after printing this row. */
5211 case DW_LNS_advance_pc
:
5212 READ_ULEB (uladv
, data
, end
);
5213 if (linfo
.li_max_ops_per_insn
== 1)
5215 uladv
*= linfo
.li_min_insn_length
;
5216 state_machine_regs
.address
+= uladv
;
5218 state_machine_regs
.view
= 0;
5223 = ((state_machine_regs
.op_index
+ uladv
)
5224 / linfo
.li_max_ops_per_insn
)
5225 * linfo
.li_min_insn_length
;
5226 state_machine_regs
.address
5228 state_machine_regs
.op_index
5229 = (state_machine_regs
.op_index
+ uladv
)
5230 % linfo
.li_max_ops_per_insn
;
5232 state_machine_regs
.view
= 0;
5236 case DW_LNS_advance_line
:
5237 READ_SLEB (adv
, data
, end
);
5238 state_machine_regs
.line
+= adv
;
5241 case DW_LNS_set_file
:
5242 READ_ULEB (uladv
, data
, end
);
5243 state_machine_regs
.file
= uladv
;
5246 unsigned file
= state_machine_regs
.file
- 1;
5249 if (file_table
== NULL
|| n_files
== 0)
5250 printf (_("\n [Use file table entry %d]\n"), file
);
5252 else if (file
>= n_files
)
5254 warn (_("file index %u > number of files %u\n"), file
+ 1, n_files
);
5255 printf (_("\n <over large file table index %u>"), file
);
5257 else if ((dir
= file_table
[file
].directory_index
) == 0)
5258 /* If directory index is 0, that means current directory. */
5259 printf ("\n./%s:[++]\n", file_table
[file
].name
);
5260 else if (directory_table
== NULL
|| n_directories
== 0)
5261 printf (_("\n [Use file %s in directory table entry %d]\n"),
5262 file_table
[file
].name
, dir
);
5264 else if (dir
> n_directories
)
5266 warn (_("directory index %u > number of directories %s\n"),
5267 dir
, dwarf_vmatoa ("u", n_directories
));
5268 printf (_("\n <over large directory table entry %u>\n"), dir
);
5271 printf ("\n%s/%s:\n",
5272 /* The directory index starts counting at 1. */
5273 directory_table
[dir
- 1], file_table
[file
].name
);
5277 case DW_LNS_set_column
:
5278 READ_ULEB (uladv
, data
, end
);
5279 state_machine_regs
.column
= uladv
;
5282 case DW_LNS_negate_stmt
:
5283 adv
= state_machine_regs
.is_stmt
;
5285 state_machine_regs
.is_stmt
= adv
;
5288 case DW_LNS_set_basic_block
:
5289 state_machine_regs
.basic_block
= 1;
5292 case DW_LNS_const_add_pc
:
5293 uladv
= ((255 - linfo
.li_opcode_base
) / linfo
.li_line_range
);
5294 if (linfo
.li_max_ops_per_insn
== 1)
5296 uladv
*= linfo
.li_min_insn_length
;
5297 state_machine_regs
.address
+= uladv
;
5299 state_machine_regs
.view
= 0;
5304 = ((state_machine_regs
.op_index
+ uladv
)
5305 / linfo
.li_max_ops_per_insn
)
5306 * linfo
.li_min_insn_length
;
5307 state_machine_regs
.address
5309 state_machine_regs
.op_index
5310 = (state_machine_regs
.op_index
+ uladv
)
5311 % linfo
.li_max_ops_per_insn
;
5313 state_machine_regs
.view
= 0;
5317 case DW_LNS_fixed_advance_pc
:
5318 SAFE_BYTE_GET_AND_INC (uladv
, data
, 2, end
);
5319 state_machine_regs
.address
+= uladv
;
5320 state_machine_regs
.op_index
= 0;
5321 /* Do NOT reset view. */
5324 case DW_LNS_set_prologue_end
:
5327 case DW_LNS_set_epilogue_begin
:
5330 case DW_LNS_set_isa
:
5331 READ_ULEB (uladv
, data
, end
);
5332 printf (_(" Set ISA to %lu\n"), uladv
);
5336 printf (_(" Unknown opcode %d with operands: "), op_code
);
5338 if (standard_opcodes
!= NULL
)
5339 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5343 READ_ULEB (val
, data
, end
);
5344 printf ("0x%s%s", dwarf_vmatoa ("x", val
),
5345 i
== 1 ? "" : ", ");
5351 /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row
5352 to the DWARF address/line matrix. */
5353 if ((is_special_opcode
) || (xop
== -DW_LNE_end_sequence
)
5354 || (xop
== DW_LNS_copy
))
5356 const unsigned int MAX_FILENAME_LENGTH
= 35;
5358 char *newFileName
= NULL
;
5359 size_t fileNameLength
;
5363 unsigned indx
= state_machine_regs
.file
- 1;
5365 if (indx
>= n_files
)
5367 warn (_("corrupt file index %u encountered\n"), indx
);
5368 fileName
= _("<corrupt>");
5371 fileName
= (char *) file_table
[indx
].name
;
5374 fileName
= _("<unknown>");
5376 fileNameLength
= strlen (fileName
);
5378 if ((fileNameLength
> MAX_FILENAME_LENGTH
) && (!do_wide
))
5380 newFileName
= (char *) xmalloc (MAX_FILENAME_LENGTH
+ 1);
5381 /* Truncate file name */
5382 strncpy (newFileName
,
5383 fileName
+ fileNameLength
- MAX_FILENAME_LENGTH
,
5384 MAX_FILENAME_LENGTH
+ 1);
5385 /* FIXME: This is to pacify gcc-10 which can warn that the
5386 strncpy above might leave a non-NUL terminated string
5387 in newFileName. It won't, but gcc's analysis doesn't
5388 quite go far enough to discover this. */
5389 newFileName
[MAX_FILENAME_LENGTH
] = 0;
5393 newFileName
= (char *) xmalloc (fileNameLength
+ 1);
5394 strncpy (newFileName
, fileName
, fileNameLength
+ 1);
5397 /* A row with end_seq set to true has a meaningful address, but
5398 the other information in the same row is not significant.
5399 In such a row, print line as "-", and don't print
5401 if (!do_wide
|| (fileNameLength
<= MAX_FILENAME_LENGTH
))
5403 if (linfo
.li_max_ops_per_insn
== 1)
5405 if (xop
== -DW_LNE_end_sequence
)
5406 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x",
5408 state_machine_regs
.address
);
5410 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x",
5411 newFileName
, state_machine_regs
.line
,
5412 state_machine_regs
.address
);
5416 if (xop
== -DW_LNE_end_sequence
)
5417 printf ("%-35s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5419 state_machine_regs
.address
,
5420 state_machine_regs
.op_index
);
5422 printf ("%-35s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5423 newFileName
, state_machine_regs
.line
,
5424 state_machine_regs
.address
,
5425 state_machine_regs
.op_index
);
5430 if (linfo
.li_max_ops_per_insn
== 1)
5432 if (xop
== -DW_LNE_end_sequence
)
5433 printf ("%s %11s %#18" DWARF_VMA_FMT
"x",
5435 state_machine_regs
.address
);
5437 printf ("%s %11d %#18" DWARF_VMA_FMT
"x",
5438 newFileName
, state_machine_regs
.line
,
5439 state_machine_regs
.address
);
5443 if (xop
== -DW_LNE_end_sequence
)
5444 printf ("%s %11s %#18" DWARF_VMA_FMT
"x[%d]",
5446 state_machine_regs
.address
,
5447 state_machine_regs
.op_index
);
5449 printf ("%s %11d %#18" DWARF_VMA_FMT
"x[%d]",
5450 newFileName
, state_machine_regs
.line
,
5451 state_machine_regs
.address
,
5452 state_machine_regs
.op_index
);
5456 if (xop
!= -DW_LNE_end_sequence
)
5458 if (state_machine_regs
.view
)
5459 printf (" %6u", state_machine_regs
.view
);
5463 if (state_machine_regs
.is_stmt
)
5468 state_machine_regs
.view
++;
5470 if (xop
== -DW_LNE_end_sequence
)
5472 reset_state_machine (linfo
.li_default_is_stmt
);
5487 if (directory_table
)
5489 free (directory_table
);
5490 directory_table
= NULL
;
5501 display_debug_lines (struct dwarf_section
*section
, void *file
)
5503 unsigned char *data
= section
->start
;
5504 unsigned char *end
= data
+ section
->size
;
5506 int retValDecoded
= 1;
5508 if (do_debug_lines
== 0)
5509 do_debug_lines
|= FLAG_DEBUG_LINES_RAW
;
5511 if (do_debug_lines
& FLAG_DEBUG_LINES_RAW
)
5512 retValRaw
= display_debug_lines_raw (section
, data
, end
, file
);
5514 if (do_debug_lines
& FLAG_DEBUG_LINES_DECODED
)
5515 retValDecoded
= display_debug_lines_decoded (section
, data
, data
, end
, file
);
5517 if (!retValRaw
|| !retValDecoded
)
5524 find_debug_info_for_offset (unsigned long offset
)
5528 if (num_debug_info_entries
== DEBUG_INFO_UNAVAILABLE
)
5531 for (i
= 0; i
< num_debug_info_entries
; i
++)
5532 if (debug_information
[i
].cu_offset
== offset
)
5533 return debug_information
+ i
;
5539 get_gdb_index_symbol_kind_name (gdb_index_symbol_kind kind
)
5541 /* See gdb/gdb-index.h. */
5542 static const char * const kinds
[] =
5554 return _ (kinds
[kind
]);
5558 display_debug_pubnames_worker (struct dwarf_section
*section
,
5559 void *file ATTRIBUTE_UNUSED
,
5562 DWARF2_Internal_PubNames names
;
5563 unsigned char *start
= section
->start
;
5564 unsigned char *end
= start
+ section
->size
;
5566 /* It does not matter if this load fails,
5567 we test for that later on. */
5568 load_debug_info (file
);
5570 introduce (section
, FALSE
);
5574 unsigned char *data
;
5575 unsigned long sec_off
;
5576 unsigned int offset_size
, initial_length_size
;
5578 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 4, end
);
5579 if (names
.pn_length
== 0xffffffff)
5581 SAFE_BYTE_GET_AND_INC (names
.pn_length
, start
, 8, end
);
5583 initial_length_size
= 12;
5588 initial_length_size
= 4;
5591 sec_off
= start
- section
->start
;
5592 if (sec_off
+ names
.pn_length
< sec_off
5593 || sec_off
+ names
.pn_length
> section
->size
)
5595 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
5597 sec_off
- initial_length_size
,
5598 dwarf_vmatoa ("x", names
.pn_length
));
5603 start
+= names
.pn_length
;
5605 SAFE_BYTE_GET_AND_INC (names
.pn_version
, data
, 2, end
);
5606 SAFE_BYTE_GET_AND_INC (names
.pn_offset
, data
, offset_size
, end
);
5608 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
5609 && num_debug_info_entries
> 0
5610 && find_debug_info_for_offset (names
.pn_offset
) == NULL
)
5611 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
5612 (unsigned long) names
.pn_offset
, section
->name
);
5614 SAFE_BYTE_GET_AND_INC (names
.pn_size
, data
, offset_size
, end
);
5616 printf (_(" Length: %ld\n"),
5617 (long) names
.pn_length
);
5618 printf (_(" Version: %d\n"),
5620 printf (_(" Offset into .debug_info section: 0x%lx\n"),
5621 (unsigned long) names
.pn_offset
);
5622 printf (_(" Size of area in .debug_info section: %ld\n"),
5623 (long) names
.pn_size
);
5625 if (names
.pn_version
!= 2 && names
.pn_version
!= 3)
5627 static int warned
= 0;
5631 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
5639 printf (_("\n Offset Kind Name\n"));
5641 printf (_("\n Offset\tName\n"));
5645 bfd_size_type maxprint
;
5648 SAFE_BYTE_GET (offset
, data
, offset_size
, end
);
5653 data
+= offset_size
;
5656 maxprint
= (end
- data
) - 1;
5660 unsigned int kind_data
;
5661 gdb_index_symbol_kind kind
;
5662 const char *kind_name
;
5665 SAFE_BYTE_GET (kind_data
, data
, 1, end
);
5668 /* GCC computes the kind as the upper byte in the CU index
5669 word, and then right shifts it by the CU index size.
5670 Left shift KIND to where the gdb-index.h accessor macros
5672 kind_data
<<= GDB_INDEX_CU_BITSIZE
;
5673 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (kind_data
);
5674 kind_name
= get_gdb_index_symbol_kind_name (kind
);
5675 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data
);
5676 printf (" %-6lx %s,%-10s %.*s\n",
5677 (unsigned long) offset
, is_static
? _("s") : _("g"),
5678 kind_name
, (int) maxprint
, data
);
5681 printf (" %-6lx\t%.*s\n",
5682 (unsigned long) offset
, (int) maxprint
, data
);
5684 data
+= strnlen ((char *) data
, maxprint
) + 1;
5695 display_debug_pubnames (struct dwarf_section
*section
, void *file
)
5697 return display_debug_pubnames_worker (section
, file
, 0);
5701 display_debug_gnu_pubnames (struct dwarf_section
*section
, void *file
)
5703 return display_debug_pubnames_worker (section
, file
, 1);
5707 display_debug_macinfo (struct dwarf_section
*section
,
5708 void *file ATTRIBUTE_UNUSED
)
5710 unsigned char *start
= section
->start
;
5711 unsigned char *end
= start
+ section
->size
;
5712 unsigned char *curr
= start
;
5713 enum dwarf_macinfo_record_type op
;
5715 introduce (section
, FALSE
);
5719 unsigned int lineno
;
5720 const unsigned char *string
;
5722 op
= (enum dwarf_macinfo_record_type
) *curr
;
5727 case DW_MACINFO_start_file
:
5729 unsigned int filenum
;
5731 READ_ULEB (lineno
, curr
, end
);
5732 READ_ULEB (filenum
, curr
, end
);
5733 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
5738 case DW_MACINFO_end_file
:
5739 printf (_(" DW_MACINFO_end_file\n"));
5742 case DW_MACINFO_define
:
5743 READ_ULEB (lineno
, curr
, end
);
5745 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5746 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
5750 case DW_MACINFO_undef
:
5751 READ_ULEB (lineno
, curr
, end
);
5753 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5754 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
5758 case DW_MACINFO_vendor_ext
:
5760 unsigned int constant
;
5762 READ_ULEB (constant
, curr
, end
);
5764 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5765 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
5775 /* Given LINE_OFFSET into the .debug_line section, attempt to return
5776 filename and dirname corresponding to file name table entry with index
5777 FILEIDX. Return NULL on failure. */
5779 static unsigned char *
5780 get_line_filename_and_dirname (dwarf_vma line_offset
,
5782 unsigned char **dir_name
)
5784 struct dwarf_section
*section
= &debug_displays
[line
].section
;
5785 unsigned char *hdrptr
, *dirtable
, *file_name
;
5786 unsigned int offset_size
, initial_length_size
;
5787 unsigned int version
, opcode_base
;
5788 dwarf_vma length
, diridx
;
5789 const unsigned char * end
;
5792 if (section
->start
== NULL
5793 || line_offset
>= section
->size
5797 hdrptr
= section
->start
+ line_offset
;
5798 end
= section
->start
+ section
->size
;
5800 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 4, end
);
5801 if (length
== 0xffffffff)
5803 /* This section is 64-bit DWARF 3. */
5804 SAFE_BYTE_GET_AND_INC (length
, hdrptr
, 8, end
);
5806 initial_length_size
= 12;
5811 initial_length_size
= 4;
5813 if (length
+ initial_length_size
< length
5814 || length
+ initial_length_size
> section
->size
)
5817 SAFE_BYTE_GET_AND_INC (version
, hdrptr
, 2, end
);
5818 if (version
!= 2 && version
!= 3 && version
!= 4)
5820 hdrptr
+= offset_size
+ 1;/* Skip prologue_length and min_insn_length. */
5822 hdrptr
++; /* Skip max_ops_per_insn. */
5823 hdrptr
+= 3; /* Skip default_is_stmt, line_base, line_range. */
5825 SAFE_BYTE_GET_AND_INC (opcode_base
, hdrptr
, 1, end
);
5826 if (opcode_base
== 0)
5829 hdrptr
+= opcode_base
- 1;
5834 /* Skip over dirname table. */
5835 while (*hdrptr
!= '\0')
5837 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5841 hdrptr
++; /* Skip the NUL at the end of the table. */
5843 /* Now skip over preceding filename table entries. */
5844 for (; hdrptr
< end
&& *hdrptr
!= '\0' && fileidx
> 1; fileidx
--)
5846 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5847 SKIP_ULEB (hdrptr
, end
);
5848 SKIP_ULEB (hdrptr
, end
);
5849 SKIP_ULEB (hdrptr
, end
);
5851 if (hdrptr
>= end
|| *hdrptr
== '\0')
5855 hdrptr
+= strnlen ((char *) hdrptr
, end
- hdrptr
) + 1;
5858 READ_ULEB (diridx
, hdrptr
, end
);
5861 for (; dirtable
< end
&& *dirtable
!= '\0' && diridx
> 1; diridx
--)
5862 dirtable
+= strnlen ((char *) dirtable
, end
- dirtable
) + 1;
5863 if (dirtable
>= end
|| *dirtable
== '\0')
5865 *dir_name
= dirtable
;
5870 display_debug_macro (struct dwarf_section
*section
,
5873 unsigned char *start
= section
->start
;
5874 unsigned char *end
= start
+ section
->size
;
5875 unsigned char *curr
= start
;
5876 unsigned char *extended_op_buf
[256];
5878 load_debug_section_with_follow (str
, file
);
5879 load_debug_section_with_follow (line
, file
);
5880 load_debug_section_with_follow (str_index
, file
);
5882 introduce (section
, FALSE
);
5886 unsigned int lineno
, version
, flags
;
5887 unsigned int offset_size
= 4;
5888 const unsigned char *string
;
5889 dwarf_vma line_offset
= 0, sec_offset
= curr
- start
, offset
;
5890 unsigned char **extended_ops
= NULL
;
5892 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
5893 if (version
!= 4 && version
!= 5)
5895 error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"),
5900 SAFE_BYTE_GET_AND_INC (flags
, curr
, 1, end
);
5903 printf (_(" Offset: 0x%lx\n"),
5904 (unsigned long) sec_offset
);
5905 printf (_(" Version: %d\n"), version
);
5906 printf (_(" Offset size: %d\n"), offset_size
);
5909 SAFE_BYTE_GET_AND_INC (line_offset
, curr
, offset_size
, end
);
5910 printf (_(" Offset into .debug_line: 0x%lx\n"),
5911 (unsigned long) line_offset
);
5915 unsigned int i
, count
, op
;
5918 SAFE_BYTE_GET_AND_INC (count
, curr
, 1, end
);
5920 memset (extended_op_buf
, 0, sizeof (extended_op_buf
));
5921 extended_ops
= extended_op_buf
;
5924 printf (_(" Extension opcode arguments:\n"));
5925 for (i
= 0; i
< count
; i
++)
5927 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5928 extended_ops
[op
] = curr
;
5929 READ_ULEB (nargs
, curr
, end
);
5931 printf (_(" DW_MACRO_%02x has no arguments\n"), op
);
5934 printf (_(" DW_MACRO_%02x arguments: "), op
);
5935 for (n
= 0; n
< nargs
; n
++)
5939 SAFE_BYTE_GET_AND_INC (form
, curr
, 1, end
);
5940 printf ("%s%s", get_FORM_name (form
),
5941 n
== nargs
- 1 ? "\n" : ", ");
5951 case DW_FORM_block1
:
5952 case DW_FORM_block2
:
5953 case DW_FORM_block4
:
5955 case DW_FORM_string
:
5957 case DW_FORM_sec_offset
:
5960 error (_("Invalid extension opcode form %s\n"),
5961 get_FORM_name (form
));
5977 error (_(".debug_macro section not zero terminated\n"));
5981 SAFE_BYTE_GET_AND_INC (op
, curr
, 1, end
);
5987 case DW_MACRO_define
:
5988 READ_ULEB (lineno
, curr
, end
);
5990 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5991 printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"),
5995 case DW_MACRO_undef
:
5996 READ_ULEB (lineno
, curr
, end
);
5998 curr
+= strnlen ((char *) string
, end
- string
) + 1;
5999 printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"),
6003 case DW_MACRO_start_file
:
6005 unsigned int filenum
;
6006 unsigned char *file_name
= NULL
, *dir_name
= NULL
;
6008 READ_ULEB (lineno
, curr
, end
);
6009 READ_ULEB (filenum
, curr
, end
);
6011 if ((flags
& 2) == 0)
6012 error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n"));
6015 = get_line_filename_and_dirname (line_offset
, filenum
,
6017 if (file_name
== NULL
)
6018 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"),
6021 printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"),
6023 dir_name
!= NULL
? (const char *) dir_name
: "",
6024 dir_name
!= NULL
? "/" : "", file_name
);
6028 case DW_MACRO_end_file
:
6029 printf (_(" DW_MACRO_end_file\n"));
6032 case DW_MACRO_define_strp
:
6033 READ_ULEB (lineno
, curr
, end
);
6034 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6035 string
= fetch_indirect_string (offset
);
6036 printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"),
6040 case DW_MACRO_undef_strp
:
6041 READ_ULEB (lineno
, curr
, end
);
6042 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6043 string
= fetch_indirect_string (offset
);
6044 printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"),
6048 case DW_MACRO_import
:
6049 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6050 printf (_(" DW_MACRO_import - offset : 0x%lx\n"),
6051 (unsigned long) offset
);
6054 case DW_MACRO_define_sup
:
6055 READ_ULEB (lineno
, curr
, end
);
6056 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6057 printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"),
6058 lineno
, (unsigned long) offset
);
6061 case DW_MACRO_undef_sup
:
6062 READ_ULEB (lineno
, curr
, end
);
6063 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6064 printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"),
6065 lineno
, (unsigned long) offset
);
6068 case DW_MACRO_import_sup
:
6069 SAFE_BYTE_GET_AND_INC (offset
, curr
, offset_size
, end
);
6070 printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"),
6071 (unsigned long) offset
);
6074 case DW_MACRO_define_strx
:
6075 case DW_MACRO_undef_strx
:
6076 READ_ULEB (lineno
, curr
, end
);
6077 READ_ULEB (offset
, curr
, end
);
6078 string
= (const unsigned char *)
6079 fetch_indexed_string (offset
, NULL
, offset_size
, FALSE
);
6080 if (op
== DW_MACRO_define_strx
)
6081 printf (" DW_MACRO_define_strx ");
6083 printf (" DW_MACRO_undef_strx ");
6085 printf (_("(with offset %s) "), dwarf_vmatoa ("x", offset
));
6086 printf (_("lineno : %d macro : %s\n"),
6091 if (op
>= DW_MACRO_lo_user
&& op
<= DW_MACRO_hi_user
)
6093 printf (_(" <Target Specific macro op: %#x - UNHANDLED"), op
);
6097 if (extended_ops
== NULL
|| extended_ops
[op
] == NULL
)
6099 error (_(" Unknown macro opcode %02x seen\n"), op
);
6104 /* Skip over unhandled opcodes. */
6106 unsigned char *desc
= extended_ops
[op
];
6107 READ_ULEB (nargs
, desc
, end
);
6110 printf (_(" DW_MACRO_%02x\n"), op
);
6113 printf (_(" DW_MACRO_%02x -"), op
);
6114 for (n
= 0; n
< nargs
; n
++)
6118 /* DW_FORM_implicit_const is not expected here. */
6119 SAFE_BYTE_GET_AND_INC (val
, desc
, 1, end
);
6121 = read_and_display_attr_value (0, val
, 0,
6122 start
, curr
, end
, 0, 0, offset_size
,
6123 version
, NULL
, 0, NULL
,
6141 display_debug_abbrev (struct dwarf_section
*section
,
6142 void *file ATTRIBUTE_UNUSED
)
6144 abbrev_entry
*entry
;
6145 unsigned char *start
= section
->start
;
6146 const unsigned char *end
= start
+ section
->size
;
6148 introduce (section
, FALSE
);
6155 offset
= start
- section
->start
;
6156 list
= find_abbrev_list_by_abbrev_offset (0, offset
);
6159 list
= new_abbrev_list (0, offset
);
6160 start
= process_abbrev_set (start
, end
, list
);
6161 list
->start_of_next_abbrevs
= start
;
6164 start
= list
->start_of_next_abbrevs
;
6166 if (list
->first_abbrev
== NULL
)
6169 printf (_(" Number TAG (0x%lx)\n"), (long) offset
);
6171 for (entry
= list
->first_abbrev
; entry
; entry
= entry
->next
)
6175 printf (" %ld %s [%s]\n",
6177 get_TAG_name (entry
->tag
),
6178 entry
->children
? _("has children") : _("no children"));
6180 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6182 printf (" %-18s %s",
6183 get_AT_name (attr
->attribute
),
6184 get_FORM_name (attr
->form
));
6185 if (attr
->form
== DW_FORM_implicit_const
)
6186 printf (": %" BFD_VMA_FMT
"d", attr
->implicit_const
);
6198 /* Return true when ADDR is the maximum address, when addresses are
6199 POINTER_SIZE bytes long. */
6202 is_max_address (dwarf_vma addr
, unsigned int pointer_size
)
6204 dwarf_vma mask
= ~(~(dwarf_vma
) 1 << (pointer_size
* 8 - 1));
6205 return ((addr
& mask
) == mask
);
6208 /* Display a view pair list starting at *VSTART_PTR and ending at
6209 VLISTEND within SECTION. */
6212 display_view_pair_list (struct dwarf_section
*section
,
6213 unsigned char **vstart_ptr
,
6214 unsigned int debug_info_entry
,
6215 unsigned char *vlistend
)
6217 unsigned char *vstart
= *vstart_ptr
;
6218 unsigned char *section_end
= section
->start
+ section
->size
;
6219 unsigned int pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6221 if (vlistend
< section_end
)
6222 section_end
= vlistend
;
6226 while (vstart
< section_end
)
6228 dwarf_vma off
= vstart
- section
->start
;
6229 dwarf_vma vbegin
, vend
;
6231 READ_ULEB (vbegin
, vstart
, section_end
);
6232 if (vstart
== section_end
)
6235 READ_ULEB (vend
, vstart
, section_end
);
6236 printf (" %8.8lx ", (unsigned long) off
);
6238 print_dwarf_view (vbegin
, pointer_size
, 1);
6239 print_dwarf_view (vend
, pointer_size
, 1);
6240 printf (_("location view pair\n"));
6244 *vstart_ptr
= vstart
;
6247 /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */
6250 display_loc_list (struct dwarf_section
*section
,
6251 unsigned char **start_ptr
,
6252 unsigned int debug_info_entry
,
6254 dwarf_vma base_address
,
6255 unsigned char **vstart_ptr
,
6258 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6259 unsigned char *section_end
= section
->start
+ section
->size
;
6260 unsigned long cu_offset
;
6261 unsigned int pointer_size
;
6262 unsigned int offset_size
;
6267 unsigned short length
;
6268 int need_frame_base
;
6270 if (debug_info_entry
>= num_debug_info_entries
)
6272 warn (_("No debug information available for loc lists of entry: %u\n"),
6277 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6278 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6279 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6280 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6282 if (pointer_size
< 2 || pointer_size
> 8)
6284 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6285 pointer_size
, debug_info_entry
);
6291 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6292 dwarf_vma vbegin
= vm1
, vend
= vm1
;
6294 if (start
+ 2 * pointer_size
> section_end
)
6296 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6297 (unsigned long) offset
);
6301 printf (" %8.8lx ", (unsigned long) off
);
6303 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6304 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6306 if (begin
== 0 && end
== 0)
6308 /* PR 18374: In a object file we can have a location list that
6309 starts with a begin and end of 0 because there are relocations
6310 that need to be applied to the addresses. Actually applying
6311 the relocations now does not help as they will probably resolve
6312 to 0, since the object file has not been fully linked. Real
6313 end of list markers will not have any relocations against them. */
6314 if (! reloc_at (section
, off
)
6315 && ! reloc_at (section
, off
+ pointer_size
))
6317 printf (_("<End of list>\n"));
6322 /* Check base address specifiers. */
6323 if (is_max_address (begin
, pointer_size
)
6324 && !is_max_address (end
, pointer_size
))
6327 print_dwarf_vma (begin
, pointer_size
);
6328 print_dwarf_vma (end
, pointer_size
);
6329 printf (_("(base address)\n"));
6335 off
= offset
+ (vstart
- *start_ptr
);
6337 READ_ULEB (vbegin
, vstart
, section_end
);
6338 print_dwarf_view (vbegin
, pointer_size
, 1);
6340 READ_ULEB (vend
, vstart
, section_end
);
6341 print_dwarf_view (vend
, pointer_size
, 1);
6343 printf (_("views at %8.8lx for:\n %*s "),
6344 (unsigned long) off
, 8, "");
6347 if (start
+ 2 > section_end
)
6349 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6350 (unsigned long) offset
);
6354 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6356 if (start
+ length
> section_end
)
6358 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6359 (unsigned long) offset
);
6363 print_dwarf_vma (begin
+ base_address
, pointer_size
);
6364 print_dwarf_vma (end
+ base_address
, pointer_size
);
6367 need_frame_base
= decode_location_expression (start
,
6372 cu_offset
, section
);
6375 if (need_frame_base
&& !has_frame_base
)
6376 printf (_(" [without DW_AT_frame_base]"));
6378 if (begin
== end
&& vbegin
== vend
)
6379 fputs (_(" (start == end)"), stdout
);
6380 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6381 fputs (_(" (start > end)"), stdout
);
6389 *vstart_ptr
= vstart
;
6392 /* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */
6395 display_loclists_list (struct dwarf_section
*section
,
6396 unsigned char **start_ptr
,
6397 unsigned int debug_info_entry
,
6399 dwarf_vma base_address
,
6400 unsigned char **vstart_ptr
,
6403 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6404 unsigned char *section_end
= section
->start
+ section
->size
;
6405 unsigned long cu_offset
;
6406 unsigned int pointer_size
;
6407 unsigned int offset_size
;
6410 /* Initialize it due to a false compiler warning. */
6411 dwarf_vma begin
= -1, vbegin
= -1;
6412 dwarf_vma end
= -1, vend
= -1;
6414 int need_frame_base
;
6416 if (debug_info_entry
>= num_debug_info_entries
)
6418 warn (_("No debug information available for "
6419 "loclists lists of entry: %u\n"),
6424 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6425 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6426 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6427 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6429 if (pointer_size
< 2 || pointer_size
> 8)
6431 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6432 pointer_size
, debug_info_entry
);
6438 dwarf_vma off
= offset
+ (start
- *start_ptr
);
6439 enum dwarf_location_list_entry_type llet
;
6441 if (start
+ 1 > section_end
)
6443 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6444 (unsigned long) offset
);
6448 printf (" %8.8lx ", (unsigned long) off
);
6450 SAFE_BYTE_GET_AND_INC (llet
, start
, 1, section_end
);
6452 if (vstart
&& (llet
== DW_LLE_offset_pair
6453 || llet
== DW_LLE_start_end
6454 || llet
== DW_LLE_start_length
))
6456 off
= offset
+ (vstart
- *start_ptr
);
6458 READ_ULEB (vbegin
, vstart
, section_end
);
6459 print_dwarf_view (vbegin
, pointer_size
, 1);
6461 READ_ULEB (vend
, vstart
, section_end
);
6462 print_dwarf_view (vend
, pointer_size
, 1);
6464 printf (_("views at %8.8lx for:\n %*s "),
6465 (unsigned long) off
, 8, "");
6470 case DW_LLE_end_of_list
:
6471 printf (_("<End of list>\n"));
6473 case DW_LLE_offset_pair
:
6474 READ_ULEB (begin
, start
, section_end
);
6475 begin
+= base_address
;
6476 READ_ULEB (end
, start
, section_end
);
6477 end
+= base_address
;
6479 case DW_LLE_start_end
:
6480 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6481 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, section_end
);
6483 case DW_LLE_start_length
:
6484 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, section_end
);
6485 READ_ULEB (end
, start
, section_end
);
6488 case DW_LLE_base_address
:
6489 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
,
6491 print_dwarf_vma (base_address
, pointer_size
);
6492 printf (_("(base address)\n"));
6494 #ifdef DW_LLE_view_pair
6495 case DW_LLE_view_pair
:
6497 printf (_("View pair entry in loclist with locviews attribute\n"));
6498 READ_ULEB (vbegin
, start
, section_end
);
6499 print_dwarf_view (vbegin
, pointer_size
, 1);
6501 READ_ULEB (vend
, start
, section_end
);
6502 print_dwarf_view (vend
, pointer_size
, 1);
6504 printf (_("views for:\n"));
6508 error (_("Invalid location list entry type %d\n"), llet
);
6511 if (llet
== DW_LLE_end_of_list
)
6513 if (llet
!= DW_LLE_offset_pair
6514 && llet
!= DW_LLE_start_end
6515 && llet
!= DW_LLE_start_length
)
6518 if (start
+ 2 > section_end
)
6520 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6521 (unsigned long) offset
);
6525 READ_ULEB (length
, start
, section_end
);
6527 print_dwarf_vma (begin
, pointer_size
);
6528 print_dwarf_vma (end
, pointer_size
);
6531 need_frame_base
= decode_location_expression (start
,
6536 cu_offset
, section
);
6539 if (need_frame_base
&& !has_frame_base
)
6540 printf (_(" [without DW_AT_frame_base]"));
6542 if (begin
== end
&& vbegin
== vend
)
6543 fputs (_(" (start == end)"), stdout
);
6544 else if (begin
> end
|| (begin
== end
&& vbegin
> vend
))
6545 fputs (_(" (start > end)"), stdout
);
6553 if (vbegin
!= vm1
|| vend
!= vm1
)
6554 printf (_("Trailing view pair not used in a range"));
6557 *vstart_ptr
= vstart
;
6560 /* Print a .debug_addr table index in decimal, surrounded by square brackets,
6561 right-adjusted in a field of length LEN, and followed by a space. */
6564 print_addr_index (unsigned int idx
, unsigned int len
)
6566 static char buf
[15];
6567 snprintf (buf
, sizeof (buf
), "[%d]", idx
);
6568 printf ("%*s ", len
, buf
);
6571 /* Display a location list from a .dwo section. It uses address indexes rather
6572 than embedded addresses. This code closely follows display_loc_list, but the
6573 two are sufficiently different that combining things is very ugly. */
6576 display_loc_list_dwo (struct dwarf_section
*section
,
6577 unsigned char **start_ptr
,
6578 unsigned int debug_info_entry
,
6580 unsigned char **vstart_ptr
,
6583 unsigned char *start
= *start_ptr
, *vstart
= *vstart_ptr
;
6584 unsigned char *section_end
= section
->start
+ section
->size
;
6585 unsigned long cu_offset
;
6586 unsigned int pointer_size
;
6587 unsigned int offset_size
;
6590 unsigned short length
;
6591 int need_frame_base
;
6594 if (debug_info_entry
>= num_debug_info_entries
)
6596 warn (_("No debug information for loc lists of entry: %u\n"),
6601 cu_offset
= debug_information
[debug_info_entry
].cu_offset
;
6602 pointer_size
= debug_information
[debug_info_entry
].pointer_size
;
6603 offset_size
= debug_information
[debug_info_entry
].offset_size
;
6604 dwarf_version
= debug_information
[debug_info_entry
].dwarf_version
;
6606 if (pointer_size
< 2 || pointer_size
> 8)
6608 warn (_("Invalid pointer size (%d) in debug info for entry %d\n"),
6609 pointer_size
, debug_info_entry
);
6615 printf (" %8.8lx ", (unsigned long) (offset
+ (start
- *start_ptr
)));
6617 if (start
>= section_end
)
6619 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6620 (unsigned long) offset
);
6624 SAFE_BYTE_GET_AND_INC (entry_type
, start
, 1, section_end
);
6637 dwarf_vma off
= offset
+ (vstart
- *start_ptr
);
6639 READ_ULEB (view
, vstart
, section_end
);
6640 print_dwarf_view (view
, 8, 1);
6642 READ_ULEB (view
, vstart
, section_end
);
6643 print_dwarf_view (view
, 8, 1);
6645 printf (_("views at %8.8lx for:\n %*s "),
6646 (unsigned long) off
, 8, "");
6654 case 0: /* A terminating entry. */
6656 *vstart_ptr
= vstart
;
6657 printf (_("<End of list>\n"));
6659 case 1: /* A base-address entry. */
6660 READ_ULEB (idx
, start
, section_end
);
6661 print_addr_index (idx
, 8);
6662 printf ("%*s", 9 + (vstart
? 2 * 6 : 0), "");
6663 printf (_("(base address selection entry)\n"));
6665 case 2: /* A start/end entry. */
6666 READ_ULEB (idx
, start
, section_end
);
6667 print_addr_index (idx
, 8);
6668 READ_ULEB (idx
, start
, section_end
);
6669 print_addr_index (idx
, 8);
6671 case 3: /* A start/length entry. */
6672 READ_ULEB (idx
, start
, section_end
);
6673 print_addr_index (idx
, 8);
6674 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6675 printf ("%08x ", idx
);
6677 case 4: /* An offset pair entry. */
6678 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6679 printf ("%08x ", idx
);
6680 SAFE_BYTE_GET_AND_INC (idx
, start
, 4, section_end
);
6681 printf ("%08x ", idx
);
6684 warn (_("Unknown location list entry type 0x%x.\n"), entry_type
);
6686 *vstart_ptr
= vstart
;
6690 if (start
+ 2 > section_end
)
6692 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6693 (unsigned long) offset
);
6697 SAFE_BYTE_GET_AND_INC (length
, start
, 2, section_end
);
6698 if (start
+ length
> section_end
)
6700 warn (_("Location list starting at offset 0x%lx is not terminated.\n"),
6701 (unsigned long) offset
);
6706 need_frame_base
= decode_location_expression (start
,
6711 cu_offset
, section
);
6714 if (need_frame_base
&& !has_frame_base
)
6715 printf (_(" [without DW_AT_frame_base]"));
6723 *vstart_ptr
= vstart
;
6726 /* Sort array of indexes in ascending order of loc_offsets[idx] and
6729 static dwarf_vma
*loc_offsets
, *loc_views
;
6732 loc_offsets_compar (const void *ap
, const void *bp
)
6734 dwarf_vma a
= loc_offsets
[*(const unsigned int *) ap
];
6735 dwarf_vma b
= loc_offsets
[*(const unsigned int *) bp
];
6737 int ret
= (a
> b
) - (b
> a
);
6741 a
= loc_views
[*(const unsigned int *) ap
];
6742 b
= loc_views
[*(const unsigned int *) bp
];
6744 ret
= (a
> b
) - (b
> a
);
6750 display_debug_loc (struct dwarf_section
*section
, void *file
)
6752 unsigned char *start
= section
->start
, *vstart
= NULL
;
6753 unsigned long bytes
;
6754 unsigned char *section_begin
= start
;
6755 unsigned int num_loc_list
= 0;
6756 unsigned long last_offset
= 0;
6757 unsigned long last_view
= 0;
6758 unsigned int first
= 0;
6761 int seen_first_offset
= 0;
6762 int locs_sorted
= 1;
6763 unsigned char *next
= start
, *vnext
= vstart
;
6764 unsigned int *array
= NULL
;
6765 const char *suffix
= strrchr (section
->name
, '.');
6766 bfd_boolean is_dwo
= FALSE
;
6767 int is_loclists
= strstr (section
->name
, "debug_loclists") != NULL
;
6768 dwarf_vma expected_start
= 0;
6770 if (suffix
&& strcmp (suffix
, ".dwo") == 0)
6773 bytes
= section
->size
;
6777 printf (_("\nThe %s section is empty.\n"), section
->name
);
6783 unsigned char *hdrptr
= section_begin
;
6784 dwarf_vma ll_length
;
6785 unsigned short ll_version
;
6786 unsigned char *end
= section_begin
+ section
->size
;
6787 unsigned char address_size
, segment_selector_size
;
6788 uint32_t offset_entry_count
;
6790 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 4, end
);
6791 if (ll_length
== 0xffffffff)
6792 SAFE_BYTE_GET_AND_INC (ll_length
, hdrptr
, 8, end
);
6794 SAFE_BYTE_GET_AND_INC (ll_version
, hdrptr
, 2, end
);
6795 if (ll_version
!= 5)
6797 warn (_("The %s section contains corrupt or "
6798 "unsupported version number: %d.\n"),
6799 section
->name
, ll_version
);
6803 SAFE_BYTE_GET_AND_INC (address_size
, hdrptr
, 1, end
);
6805 SAFE_BYTE_GET_AND_INC (segment_selector_size
, hdrptr
, 1, end
);
6806 if (segment_selector_size
!= 0)
6808 warn (_("The %s section contains "
6809 "unsupported segment selector size: %d.\n"),
6810 section
->name
, segment_selector_size
);
6814 SAFE_BYTE_GET_AND_INC (offset_entry_count
, hdrptr
, 4, end
);
6815 if (offset_entry_count
!= 0)
6817 warn (_("The %s section contains "
6818 "unsupported offset entry count: %d.\n"),
6819 section
->name
, offset_entry_count
);
6823 expected_start
= hdrptr
- section_begin
;
6826 if (load_debug_info (file
) == 0)
6828 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
6833 /* Check the order of location list in .debug_info section. If
6834 offsets of location lists are in the ascending order, we can
6835 use `debug_information' directly. */
6836 for (i
= 0; i
< num_debug_info_entries
; i
++)
6840 num
= debug_information
[i
].num_loc_offsets
;
6841 if (num
> num_loc_list
)
6844 /* Check if we can use `debug_information' directly. */
6845 if (locs_sorted
&& num
!= 0)
6847 if (!seen_first_offset
)
6849 /* This is the first location list. */
6850 last_offset
= debug_information
[i
].loc_offsets
[0];
6851 last_view
= debug_information
[i
].loc_views
[0];
6853 seen_first_offset
= 1;
6859 for (; j
< num
; j
++)
6862 debug_information
[i
].loc_offsets
[j
]
6863 || (last_offset
== debug_information
[i
].loc_offsets
[j
]
6864 && last_view
> debug_information
[i
].loc_views
[j
]))
6869 last_offset
= debug_information
[i
].loc_offsets
[j
];
6870 last_view
= debug_information
[i
].loc_views
[j
];
6875 if (!seen_first_offset
)
6876 error (_("No location lists in .debug_info section!\n"));
6878 if (debug_information
[first
].num_loc_offsets
> 0
6879 && debug_information
[first
].loc_offsets
[0] != expected_start
6880 && debug_information
[first
].loc_views
[0] != expected_start
)
6881 warn (_("Location lists in %s section start at 0x%s\n"),
6883 dwarf_vmatoa ("x", debug_information
[first
].loc_offsets
[0]));
6886 array
= (unsigned int *) xcmalloc (num_loc_list
, sizeof (unsigned int));
6888 introduce (section
, FALSE
);
6890 if (reloc_at (section
, 0))
6891 printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
6893 printf (_(" Offset Begin End Expression\n"));
6895 seen_first_offset
= 0;
6896 for (i
= first
; i
< num_debug_info_entries
; i
++)
6898 dwarf_vma offset
, voffset
;
6899 dwarf_vma base_address
;
6905 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6907 loc_offsets
= debug_information
[i
].loc_offsets
;
6908 loc_views
= debug_information
[i
].loc_views
;
6909 qsort (array
, debug_information
[i
].num_loc_offsets
,
6910 sizeof (*array
), loc_offsets_compar
);
6913 int adjacent_view_loclists
= 1;
6914 for (k
= 0; k
< debug_information
[i
].num_loc_offsets
; k
++)
6916 j
= locs_sorted
? k
: array
[k
];
6918 && (debug_information
[i
].loc_offsets
[locs_sorted
6919 ? k
- 1 : array
[k
- 1]]
6920 == debug_information
[i
].loc_offsets
[j
])
6921 && (debug_information
[i
].loc_views
[locs_sorted
6922 ? k
- 1 : array
[k
- 1]]
6923 == debug_information
[i
].loc_views
[j
]))
6925 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
6926 offset
= debug_information
[i
].loc_offsets
[j
];
6927 next
= section_begin
+ offset
;
6928 voffset
= debug_information
[i
].loc_views
[j
];
6930 vnext
= section_begin
+ voffset
;
6933 base_address
= debug_information
[i
].base_address
;
6935 if (vnext
&& vnext
< next
)
6938 display_view_pair_list (section
, &vstart
, i
, next
);
6943 if (!seen_first_offset
|| !adjacent_view_loclists
)
6944 seen_first_offset
= 1;
6948 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
6949 (unsigned long) (start
- section_begin
),
6950 (unsigned long) offset
);
6951 else if (start
> next
)
6952 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
6953 (unsigned long) (start
- section_begin
),
6954 (unsigned long) offset
);
6959 if (offset
>= bytes
)
6961 warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"),
6962 (unsigned long) offset
);
6966 if (vnext
&& voffset
>= bytes
)
6968 warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"),
6969 (unsigned long) voffset
);
6976 display_loc_list_dwo (section
, &start
, i
, offset
,
6977 &vstart
, has_frame_base
);
6979 display_loc_list (section
, &start
, i
, offset
, base_address
,
6980 &vstart
, has_frame_base
);
6985 warn (_("DWO is not yet supported.\n"));
6987 display_loclists_list (section
, &start
, i
, offset
, base_address
,
6988 &vstart
, has_frame_base
);
6991 /* FIXME: this arrangement is quite simplistic. Nothing
6992 requires locview lists to be adjacent to corresponding
6993 loclists, and a single loclist could be augmented by
6994 different locview lists, and vice-versa, unlikely as it
6995 is that it would make sense to do so. Hopefully we'll
6996 have view pair support built into loclists before we ever
6997 need to address all these possibilities. */
6998 if (adjacent_view_loclists
&& vnext
6999 && vnext
!= start
&& vstart
!= next
)
7001 adjacent_view_loclists
= 0;
7002 warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n"));
7005 if (vnext
&& vnext
== start
)
7006 display_view_pair_list (section
, &start
, i
, vstart
);
7010 if (start
< section
->start
+ section
->size
)
7011 warn (ngettext ("There is %ld unused byte at the end of section %s\n",
7012 "There are %ld unused bytes at the end of section %s\n",
7013 (long) (section
->start
+ section
->size
- start
)),
7014 (long) (section
->start
+ section
->size
- start
), section
->name
);
7021 display_debug_str (struct dwarf_section
*section
,
7022 void *file ATTRIBUTE_UNUSED
)
7024 unsigned char *start
= section
->start
;
7025 unsigned long bytes
= section
->size
;
7026 dwarf_vma addr
= section
->address
;
7030 printf (_("\nThe %s section is empty.\n"), section
->name
);
7034 introduce (section
, FALSE
);
7042 lbytes
= (bytes
> 16 ? 16 : bytes
);
7044 printf (" 0x%8.8lx ", (unsigned long) addr
);
7046 for (j
= 0; j
< 16; j
++)
7049 printf ("%2.2x", start
[j
]);
7057 for (j
= 0; j
< lbytes
; j
++)
7060 if (k
>= ' ' && k
< 0x80)
7079 display_debug_info (struct dwarf_section
*section
, void *file
)
7081 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, FALSE
);
7085 display_debug_types (struct dwarf_section
*section
, void *file
)
7087 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
7091 display_trace_info (struct dwarf_section
*section
, void *file
)
7093 return process_debug_info (section
, file
, section
->abbrev_sec
, FALSE
, TRUE
);
7097 display_debug_aranges (struct dwarf_section
*section
,
7098 void *file ATTRIBUTE_UNUSED
)
7100 unsigned char *start
= section
->start
;
7101 unsigned char *end
= start
+ section
->size
;
7103 introduce (section
, FALSE
);
7105 /* It does not matter if this load fails,
7106 we test for that later on. */
7107 load_debug_info (file
);
7111 unsigned char *hdrptr
;
7112 DWARF2_Internal_ARange arange
;
7113 unsigned char *addr_ranges
;
7116 unsigned long sec_off
;
7117 unsigned char address_size
;
7119 unsigned int offset_size
;
7120 unsigned int initial_length_size
;
7124 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 4, end
);
7125 if (arange
.ar_length
== 0xffffffff)
7127 SAFE_BYTE_GET_AND_INC (arange
.ar_length
, hdrptr
, 8, end
);
7129 initial_length_size
= 12;
7134 initial_length_size
= 4;
7137 sec_off
= hdrptr
- section
->start
;
7138 if (sec_off
+ arange
.ar_length
< sec_off
7139 || sec_off
+ arange
.ar_length
> section
->size
)
7141 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
7143 sec_off
- initial_length_size
,
7144 dwarf_vmatoa ("x", arange
.ar_length
));
7148 SAFE_BYTE_GET_AND_INC (arange
.ar_version
, hdrptr
, 2, end
);
7149 SAFE_BYTE_GET_AND_INC (arange
.ar_info_offset
, hdrptr
, offset_size
, end
);
7151 if (num_debug_info_entries
!= DEBUG_INFO_UNAVAILABLE
7152 && num_debug_info_entries
> 0
7153 && find_debug_info_for_offset (arange
.ar_info_offset
) == NULL
)
7154 warn (_(".debug_info offset of 0x%lx in %s section does not point to a CU header.\n"),
7155 (unsigned long) arange
.ar_info_offset
, section
->name
);
7157 SAFE_BYTE_GET_AND_INC (arange
.ar_pointer_size
, hdrptr
, 1, end
);
7158 SAFE_BYTE_GET_AND_INC (arange
.ar_segment_size
, hdrptr
, 1, end
);
7160 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
7162 /* PR 19872: A version number of 0 probably means that there is
7163 padding at the end of the .debug_aranges section. Gold puts
7164 it there when performing an incremental link, for example.
7165 So do not generate a warning in this case. */
7166 if (arange
.ar_version
)
7167 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
7171 printf (_(" Length: %ld\n"),
7172 (long) arange
.ar_length
);
7173 printf (_(" Version: %d\n"), arange
.ar_version
);
7174 printf (_(" Offset into .debug_info: 0x%lx\n"),
7175 (unsigned long) arange
.ar_info_offset
);
7176 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7177 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7179 address_size
= arange
.ar_pointer_size
+ arange
.ar_segment_size
;
7181 /* PR 17512: file: 001-108546-0.001:0.1. */
7182 if (address_size
== 0 || address_size
> 8)
7184 error (_("Invalid address size in %s section!\n"),
7189 /* The DWARF spec does not require that the address size be a power
7190 of two, but we do. This will have to change if we ever encounter
7191 an uneven architecture. */
7192 if ((address_size
& (address_size
- 1)) != 0)
7194 warn (_("Pointer size + Segment size is not a power of two.\n"));
7198 if (address_size
> 4)
7199 printf (_("\n Address Length\n"));
7201 printf (_("\n Address Length\n"));
7203 addr_ranges
= hdrptr
;
7205 /* Must pad to an alignment boundary that is twice the address size. */
7206 excess
= (hdrptr
- start
) % (2 * address_size
);
7208 addr_ranges
+= (2 * address_size
) - excess
;
7210 start
+= arange
.ar_length
+ initial_length_size
;
7212 while (addr_ranges
+ 2 * address_size
<= start
)
7214 SAFE_BYTE_GET_AND_INC (address
, addr_ranges
, address_size
, end
);
7215 SAFE_BYTE_GET_AND_INC (length
, addr_ranges
, address_size
, end
);
7218 print_dwarf_vma (address
, address_size
);
7219 print_dwarf_vma (length
, address_size
);
7229 /* Comparison function for qsort. */
7231 comp_addr_base (const void * v0
, const void * v1
)
7233 debug_info
*info0
= *(debug_info
**) v0
;
7234 debug_info
*info1
= *(debug_info
**) v1
;
7235 return info0
->addr_base
- info1
->addr_base
;
7238 /* Display the debug_addr section. */
7240 display_debug_addr (struct dwarf_section
*section
,
7243 debug_info
**debug_addr_info
;
7244 unsigned char *entry
;
7249 if (section
->size
== 0)
7251 printf (_("\nThe %s section is empty.\n"), section
->name
);
7255 if (load_debug_info (file
) == 0)
7257 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7262 introduce (section
, FALSE
);
7264 /* PR 17531: file: cf38d01b.
7265 We use xcalloc because a corrupt file may not have initialised all of the
7266 fields in the debug_info structure, which means that the sort below might
7267 try to move uninitialised data. */
7268 debug_addr_info
= (debug_info
**) xcalloc ((num_debug_info_entries
+ 1),
7269 sizeof (debug_info
*));
7272 for (i
= 0; i
< num_debug_info_entries
; i
++)
7273 if (debug_information
[i
].addr_base
!= DEBUG_INFO_UNAVAILABLE
)
7275 /* PR 17531: file: cf38d01b. */
7276 if (debug_information
[i
].addr_base
>= section
->size
)
7277 warn (_("Corrupt address base (%lx) found in debug section %u\n"),
7278 (unsigned long) debug_information
[i
].addr_base
, i
);
7280 debug_addr_info
[count
++] = debug_information
+ i
;
7283 /* Add a sentinel to make iteration convenient. */
7284 debug_addr_info
[count
] = (debug_info
*) xmalloc (sizeof (debug_info
));
7285 debug_addr_info
[count
]->addr_base
= section
->size
;
7286 qsort (debug_addr_info
, count
, sizeof (debug_info
*), comp_addr_base
);
7288 for (i
= 0; i
< count
; i
++)
7291 unsigned int address_size
= debug_addr_info
[i
]->pointer_size
;
7293 printf (_(" For compilation unit at offset 0x%s:\n"),
7294 dwarf_vmatoa ("x", debug_addr_info
[i
]->cu_offset
));
7296 printf (_("\tIndex\tAddress\n"));
7297 entry
= section
->start
+ debug_addr_info
[i
]->addr_base
;
7298 end
= section
->start
+ debug_addr_info
[i
+ 1]->addr_base
;
7302 dwarf_vma base
= byte_get (entry
, address_size
);
7303 printf (_("\t%d:\t"), idx
);
7304 print_dwarf_vma (base
, address_size
);
7306 entry
+= address_size
;
7312 free (debug_addr_info
);
7316 /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */
7319 display_debug_str_offsets (struct dwarf_section
*section
,
7320 void *file ATTRIBUTE_UNUSED
)
7324 if (section
->size
== 0)
7326 printf (_("\nThe %s section is empty.\n"), section
->name
);
7330 unsigned char *start
= section
->start
;
7331 unsigned char *end
= start
+ section
->size
;
7332 unsigned char *curr
= start
;
7334 const char * suffix
= strrchr (section
->name
, '.');
7335 bfd_boolean dwo
= (suffix
&& strcmp (suffix
, ".dwo") == 0) ? TRUE
: FALSE
;
7338 load_debug_section_with_follow (str_dwo
, file
);
7340 load_debug_section_with_follow (str
, file
);
7342 introduce (section
, FALSE
);
7347 dwarf_vma entry_length
;
7349 SAFE_BYTE_GET_AND_INC (length
, curr
, 4, end
);
7350 /* FIXME: We assume that this means 64-bit DWARF is being used. */
7351 if (length
== 0xffffffff)
7353 SAFE_BYTE_GET (length
, curr
, 8, end
);
7361 /* This is probably an old style .debug_str_offset section which
7362 just contains offsets and no header (and the first offset is 0). */
7363 length
= section
->size
;
7364 curr
= section
->start
;
7366 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7367 printf (_(" Index Offset [String]\n"));
7372 SAFE_BYTE_GET_AND_INC (version
, curr
, 2, end
);
7374 warn (_("Unexpected version number in str_offset header: %#x\n"), version
);
7377 SAFE_BYTE_GET_AND_INC (padding
, curr
, 2, end
);
7379 warn (_("Unexpected value in str_offset header's padding field: %#x\n"), padding
);
7381 printf (_(" Length: %#lx\n"), (unsigned long) length
);
7382 printf (_(" Version: %#lx\n"), (unsigned long) version
);
7383 printf (_(" Index Offset [String]\n"));
7386 for (idx
= 0; length
>= entry_length
&& curr
< end
; idx
++)
7389 const unsigned char * string
;
7391 SAFE_BYTE_GET_AND_INC (offset
, curr
, entry_length
, end
);
7393 string
= (const unsigned char *)
7394 fetch_indexed_string (idx
, NULL
, entry_length
, dwo
);
7396 string
= fetch_indirect_string (offset
);
7398 printf (" %8lu %8s %s\n", idx
, dwarf_vmatoa ("x", offset
),
7406 /* Each debug_information[x].range_lists[y] gets this representation for
7407 sorting purposes. */
7411 /* The debug_information[x].range_lists[y] value. */
7412 dwarf_vma ranges_offset
;
7414 /* Original debug_information to find parameters of the data. */
7415 debug_info
*debug_info_p
;
7418 /* Sort struct range_entry in ascending order of its RANGES_OFFSET. */
7421 range_entry_compar (const void *ap
, const void *bp
)
7423 const struct range_entry
*a_re
= (const struct range_entry
*) ap
;
7424 const struct range_entry
*b_re
= (const struct range_entry
*) bp
;
7425 const dwarf_vma a
= a_re
->ranges_offset
;
7426 const dwarf_vma b
= b_re
->ranges_offset
;
7428 return (a
> b
) - (b
> a
);
7432 display_debug_ranges_list (unsigned char *start
, unsigned char *finish
,
7433 unsigned int pointer_size
, unsigned long offset
,
7434 unsigned long base_address
)
7436 while (start
< finish
)
7441 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7442 if (start
>= finish
)
7444 SAFE_SIGNED_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7446 printf (" %8.8lx ", offset
);
7448 if (begin
== 0 && end
== 0)
7450 printf (_("<End of list>\n"));
7454 /* Check base address specifiers. */
7455 if (is_max_address (begin
, pointer_size
)
7456 && !is_max_address (end
, pointer_size
))
7459 print_dwarf_vma (begin
, pointer_size
);
7460 print_dwarf_vma (end
, pointer_size
);
7461 printf ("(base address)\n");
7465 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7466 print_dwarf_vma (end
+ base_address
, pointer_size
);
7469 fputs (_("(start == end)"), stdout
);
7470 else if (begin
> end
)
7471 fputs (_("(start > end)"), stdout
);
7478 display_debug_rnglists_list (unsigned char *start
, unsigned char *finish
,
7479 unsigned int pointer_size
, unsigned long offset
,
7480 unsigned long base_address
)
7482 unsigned char *next
= start
;
7486 unsigned long off
= offset
+ (start
- next
);
7487 enum dwarf_range_list_entry rlet
;
7488 /* Initialize it due to a false compiler warning. */
7489 dwarf_vma begin
= -1, length
, end
= -1;
7491 if (start
+ 1 > finish
)
7493 warn (_("Range list starting at offset 0x%lx is not terminated.\n"),
7498 printf (" %8.8lx ", off
);
7500 SAFE_BYTE_GET_AND_INC (rlet
, start
, 1, finish
);
7504 case DW_RLE_end_of_list
:
7505 printf (_("<End of list>\n"));
7507 case DW_RLE_base_address
:
7508 SAFE_BYTE_GET_AND_INC (base_address
, start
, pointer_size
, finish
);
7509 print_dwarf_vma (base_address
, pointer_size
);
7510 printf (_("(base address)\n"));
7512 case DW_RLE_start_length
:
7513 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7514 READ_ULEB (length
, start
, finish
);
7515 end
= begin
+ length
;
7517 case DW_RLE_offset_pair
:
7518 READ_ULEB (begin
, start
, finish
);
7519 READ_ULEB (end
, start
, finish
);
7521 case DW_RLE_start_end
:
7522 SAFE_BYTE_GET_AND_INC (begin
, start
, pointer_size
, finish
);
7523 SAFE_BYTE_GET_AND_INC (end
, start
, pointer_size
, finish
);
7526 error (_("Invalid range list entry type %d\n"), rlet
);
7527 rlet
= DW_RLE_end_of_list
;
7530 if (rlet
== DW_RLE_end_of_list
)
7532 if (rlet
== DW_RLE_base_address
)
7535 /* Only a DW_RLE_offset_pair needs the base address added. */
7536 if (rlet
== DW_RLE_offset_pair
)
7538 begin
+= base_address
;
7539 end
+= base_address
;
7542 print_dwarf_vma (begin
, pointer_size
);
7543 print_dwarf_vma (end
, pointer_size
);
7546 fputs (_("(start == end)"), stdout
);
7547 else if (begin
> end
)
7548 fputs (_("(start > end)"), stdout
);
7555 display_debug_ranges (struct dwarf_section
*section
,
7556 void *file ATTRIBUTE_UNUSED
)
7558 unsigned char *start
= section
->start
;
7559 unsigned char *last_start
= start
;
7560 unsigned long bytes
= section
->size
;
7561 unsigned char *section_begin
= start
;
7562 unsigned char *finish
= start
+ bytes
;
7563 unsigned int num_range_list
, i
;
7564 struct range_entry
*range_entries
, *range_entry_fill
;
7565 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7566 /* Initialize it due to a false compiler warning. */
7567 unsigned char address_size
= 0;
7568 dwarf_vma last_offset
= 0;
7572 printf (_("\nThe %s section is empty.\n"), section
->name
);
7578 dwarf_vma initial_length
;
7579 unsigned int initial_length_size
;
7580 unsigned char segment_selector_size
;
7581 unsigned int offset_size
, offset_entry_count
;
7582 unsigned short version
;
7584 /* Get and check the length of the block. */
7585 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7587 if (initial_length
== 0xffffffff)
7589 /* This section is 64-bit DWARF 3. */
7590 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7592 initial_length_size
= 12;
7597 initial_length_size
= 4;
7600 if (initial_length
+ initial_length_size
> section
->size
)
7602 /* If the length field has a relocation against it, then we should
7603 not complain if it is inaccurate (and probably negative).
7604 It is copied from .debug_line handling code. */
7605 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7607 initial_length
= (finish
- start
) - initial_length_size
;
7611 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7612 (long) initial_length
);
7617 /* Get and check the version number. */
7618 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7622 warn (_("Only DWARF version 5 debug_rnglists info "
7623 "is currently supported.\n"));
7627 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7629 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7630 if (segment_selector_size
!= 0)
7632 warn (_("The %s section contains "
7633 "unsupported segment selector size: %d.\n"),
7634 section
->name
, segment_selector_size
);
7638 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7639 if (offset_entry_count
!= 0)
7641 warn (_("The %s section contains "
7642 "unsupported offset entry count: %u.\n"),
7643 section
->name
, offset_entry_count
);
7648 if (load_debug_info (file
) == 0)
7650 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7656 for (i
= 0; i
< num_debug_info_entries
; i
++)
7657 num_range_list
+= debug_information
[i
].num_range_lists
;
7659 if (num_range_list
== 0)
7661 /* This can happen when the file was compiled with -gsplit-debug
7662 which removes references to range lists from the primary .o file. */
7663 printf (_("No range lists in .debug_info section.\n"));
7667 range_entries
= (struct range_entry
*)
7668 xmalloc (sizeof (*range_entries
) * num_range_list
);
7669 range_entry_fill
= range_entries
;
7671 for (i
= 0; i
< num_debug_info_entries
; i
++)
7673 debug_info
*debug_info_p
= &debug_information
[i
];
7676 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7678 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7679 range_entry_fill
->debug_info_p
= debug_info_p
;
7684 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7685 range_entry_compar
);
7687 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7688 warn (_("Range lists in %s section start at 0x%lx\n"),
7689 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7691 introduce (section
, FALSE
);
7693 printf (_(" Offset Begin End\n"));
7695 for (i
= 0; i
< num_range_list
; i
++)
7697 struct range_entry
*range_entry
= &range_entries
[i
];
7698 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7699 unsigned int pointer_size
;
7701 unsigned char *next
;
7702 dwarf_vma base_address
;
7704 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7705 offset
= range_entry
->ranges_offset
;
7706 next
= section_begin
+ offset
;
7707 base_address
= debug_info_p
->base_address
;
7709 /* PR 17512: file: 001-101485-0.001:0.1. */
7710 if (pointer_size
< 2 || pointer_size
> 8)
7712 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7713 pointer_size
, (unsigned long) offset
);
7717 if (next
< section_begin
|| next
>= finish
)
7719 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7720 (unsigned long) offset
, i
);
7724 /* If multiple DWARF entities reference the same range then we will
7725 have multiple entries in the `range_entries' list for the same
7726 offset. Thanks to the sort above these will all be consecutive in
7727 the `range_entries' list, so we can easily ignore duplicates
7729 if (i
> 0 && last_offset
== offset
)
7731 last_offset
= offset
;
7733 if (dwarf_check
!= 0 && i
> 0)
7736 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7737 (unsigned long) (start
- section_begin
),
7738 (unsigned long) (next
- section_begin
), section
->name
);
7739 else if (start
> next
)
7741 if (next
== last_start
)
7743 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7744 (unsigned long) (start
- section_begin
),
7745 (unsigned long) (next
- section_begin
), section
->name
);
7752 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7753 (start
, finish
, pointer_size
, offset
, base_address
);
7757 free (range_entries
);
7762 typedef struct Frame_Chunk
7764 struct Frame_Chunk
*next
;
7765 unsigned char *chunk_start
;
7767 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7768 short int *col_type
;
7771 unsigned int code_factor
;
7775 unsigned int cfa_reg
;
7776 dwarf_vma cfa_offset
;
7778 unsigned char fde_encoding
;
7779 unsigned char cfa_exp
;
7780 unsigned char ptr_size
;
7781 unsigned char segment_size
;
7785 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7786 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7787 static const char *const *dwarf_regnames
;
7788 static unsigned int dwarf_regnames_count
;
7791 /* A marker for a col_type that means this column was never referenced
7792 in the frame info. */
7793 #define DW_CFA_unreferenced (-1)
7795 /* Return 0 if no more space is needed, 1 if more space is needed,
7796 -1 for invalid reg. */
7799 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7801 unsigned int prev
= fc
->ncols
;
7803 if (reg
< (unsigned int) fc
->ncols
)
7806 if (dwarf_regnames_count
> 0
7807 && reg
> dwarf_regnames_count
)
7810 fc
->ncols
= reg
+ 1;
7811 /* PR 17512: file: 10450-2643-0.004.
7812 If reg == -1 then this can happen... */
7816 /* PR 17512: file: 2844a11d. */
7817 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7819 error (_("Unfeasibly large register number: %u\n"), reg
);
7821 /* FIXME: 1024 is an arbitrary limit. Increase it if
7822 we ever encounter a valid binary that exceeds it. */
7826 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7827 sizeof (short int));
7828 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7829 /* PR 17512: file:002-10025-0.005. */
7830 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7832 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7838 while (prev
< fc
->ncols
)
7840 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7841 fc
->col_offset
[prev
] = 0;
7847 static const char *const dwarf_regnames_i386
[] =
7849 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7850 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7851 "eip", "eflags", NULL
, /* 8 - 10 */
7852 "st0", "st1", "st2", "st3", /* 11 - 14 */
7853 "st4", "st5", "st6", "st7", /* 15 - 18 */
7854 NULL
, NULL
, /* 19 - 20 */
7855 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7856 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7857 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7858 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7859 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7860 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7861 "tr", "ldtr", /* 48 - 49 */
7862 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7863 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7864 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7865 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7866 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7867 NULL
, NULL
, NULL
, /* 90 - 92 */
7868 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7871 static const char *const dwarf_regnames_iamcu
[] =
7873 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7874 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7875 "eip", "eflags", NULL
, /* 8 - 10 */
7876 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7877 NULL
, NULL
, /* 19 - 20 */
7878 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7879 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7880 NULL
, NULL
, NULL
, /* 37 - 39 */
7881 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7882 "tr", "ldtr", /* 48 - 49 */
7883 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7884 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7885 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7886 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7887 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7888 NULL
, NULL
, NULL
, /* 90 - 92 */
7889 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7893 init_dwarf_regnames_i386 (void)
7895 dwarf_regnames
= dwarf_regnames_i386
;
7896 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7897 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7901 init_dwarf_regnames_iamcu (void)
7903 dwarf_regnames
= dwarf_regnames_iamcu
;
7904 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7905 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7908 static const char *const dwarf_regnames_x86_64
[] =
7910 "rax", "rdx", "rcx", "rbx",
7911 "rsi", "rdi", "rbp", "rsp",
7912 "r8", "r9", "r10", "r11",
7913 "r12", "r13", "r14", "r15",
7915 "xmm0", "xmm1", "xmm2", "xmm3",
7916 "xmm4", "xmm5", "xmm6", "xmm7",
7917 "xmm8", "xmm9", "xmm10", "xmm11",
7918 "xmm12", "xmm13", "xmm14", "xmm15",
7919 "st0", "st1", "st2", "st3",
7920 "st4", "st5", "st6", "st7",
7921 "mm0", "mm1", "mm2", "mm3",
7922 "mm4", "mm5", "mm6", "mm7",
7924 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7925 "fs.base", "gs.base", NULL
, NULL
,
7927 "mxcsr", "fcw", "fsw",
7928 "xmm16", "xmm17", "xmm18", "xmm19",
7929 "xmm20", "xmm21", "xmm22", "xmm23",
7930 "xmm24", "xmm25", "xmm26", "xmm27",
7931 "xmm28", "xmm29", "xmm30", "xmm31",
7932 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7933 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7934 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7935 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7936 NULL
, NULL
, NULL
, /* 115 - 117 */
7937 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7941 init_dwarf_regnames_x86_64 (void)
7943 dwarf_regnames
= dwarf_regnames_x86_64
;
7944 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7945 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7948 static const char *const dwarf_regnames_aarch64
[] =
7950 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7951 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7952 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7953 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7954 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7955 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7956 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7957 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7958 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7959 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7960 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7961 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7962 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7963 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7964 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7965 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7969 init_dwarf_regnames_aarch64 (void)
7971 dwarf_regnames
= dwarf_regnames_aarch64
;
7972 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7973 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7976 static const char *const dwarf_regnames_s390
[] =
7978 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7979 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7980 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7981 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7982 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7983 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7984 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7985 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7986 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7989 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7990 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7994 init_dwarf_regnames_s390 (void)
7996 dwarf_regnames
= dwarf_regnames_s390
;
7997 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7998 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
8001 static const char *const dwarf_regnames_riscv
[] =
8003 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
8004 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
8005 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
8006 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8007 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8008 "fs0", "fs1", /* 40 - 41 */
8009 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8010 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8011 "fs10", "fs11", /* 58 - 59 */
8012 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8015 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8016 the large number of CSRs. */
8019 regname_internal_riscv (unsigned int regno
)
8021 const char *name
= NULL
;
8023 /* Lookup in the table first, this covers GPR and FPR. */
8024 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8025 name
= dwarf_regnames_riscv
[regno
];
8026 else if (regno
>= 4096 && regno
<= 8191)
8028 /* This might be a CSR, these live in a sparse number space from 4096
8029 to 8191 These numbers are defined in the RISC-V ELF ABI
8033 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8034 case VALUE + 4096: name = #NAME; break;
8035 #include "opcode/riscv-opc.h"
8040 static char csr_name
[10];
8041 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8052 init_dwarf_regnames_riscv (void)
8054 dwarf_regnames
= NULL
;
8055 dwarf_regnames_count
= 8192;
8056 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8060 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8062 dwarf_regnames_lookup_func
= NULL
;
8067 init_dwarf_regnames_i386 ();
8071 init_dwarf_regnames_iamcu ();
8077 init_dwarf_regnames_x86_64 ();
8081 init_dwarf_regnames_aarch64 ();
8085 init_dwarf_regnames_s390 ();
8089 init_dwarf_regnames_riscv ();
8097 /* Initialize the DWARF register name lookup state based on the
8098 architecture and specific machine type of a BFD. */
8101 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8104 dwarf_regnames_lookup_func
= NULL
;
8111 case bfd_mach_x86_64
:
8112 case bfd_mach_x86_64_intel_syntax
:
8113 case bfd_mach_x64_32
:
8114 case bfd_mach_x64_32_intel_syntax
:
8115 init_dwarf_regnames_x86_64 ();
8119 init_dwarf_regnames_i386 ();
8124 case bfd_arch_iamcu
:
8125 init_dwarf_regnames_iamcu ();
8128 case bfd_arch_aarch64
:
8129 init_dwarf_regnames_aarch64();
8133 init_dwarf_regnames_s390 ();
8136 case bfd_arch_riscv
:
8137 init_dwarf_regnames_riscv ();
8146 regname_internal_by_table_only (unsigned int regno
)
8148 if (dwarf_regnames
!= NULL
8149 && regno
< dwarf_regnames_count
8150 && dwarf_regnames
[regno
] != NULL
)
8151 return dwarf_regnames
[regno
];
8157 regname (unsigned int regno
, int name_only_p
)
8159 static char reg
[64];
8161 const char *name
= NULL
;
8163 if (dwarf_regnames_lookup_func
!= NULL
)
8164 name
= dwarf_regnames_lookup_func (regno
);
8170 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8173 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8178 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8183 if (*max_regs
!= fc
->ncols
)
8184 *max_regs
= fc
->ncols
;
8186 if (*need_col_headers
)
8188 static const char *sloc
= " LOC";
8190 *need_col_headers
= 0;
8192 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
8194 for (r
= 0; r
< *max_regs
; r
++)
8195 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8200 printf ("%-5s ", regname (r
, 1));
8206 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
8208 strcpy (tmp
, "exp");
8210 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8211 printf ("%-8s ", tmp
);
8213 for (r
= 0; r
< fc
->ncols
; r
++)
8215 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8217 switch (fc
->col_type
[r
])
8219 case DW_CFA_undefined
:
8222 case DW_CFA_same_value
:
8226 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8228 case DW_CFA_val_offset
:
8229 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8231 case DW_CFA_register
:
8232 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8234 case DW_CFA_expression
:
8235 strcpy (tmp
, "exp");
8237 case DW_CFA_val_expression
:
8238 strcpy (tmp
, "vexp");
8241 strcpy (tmp
, "n/a");
8244 printf ("%-5s ", tmp
);
8250 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8252 static unsigned char *
8253 read_cie (unsigned char *start
, unsigned char *end
,
8254 Frame_Chunk
**p_cie
, int *p_version
,
8255 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
8259 unsigned char *augmentation_data
= NULL
;
8260 bfd_size_type augmentation_data_len
= 0;
8263 /* PR 17512: file: 001-228113-0.004. */
8267 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8268 memset (fc
, 0, sizeof (Frame_Chunk
));
8270 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8271 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8275 fc
->augmentation
= (char *) start
;
8276 /* PR 17512: file: 001-228113-0.004.
8277 Skip past augmentation name, but avoid running off the end of the data. */
8279 if (* start
++ == '\0')
8283 warn (_("No terminator for augmentation name\n"));
8287 if (strcmp (fc
->augmentation
, "eh") == 0)
8288 start
+= eh_addr_size
;
8292 GET (fc
->ptr_size
, 1);
8293 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8295 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8299 GET (fc
->segment_size
, 1);
8300 /* PR 17512: file: e99d2804. */
8301 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8303 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8307 eh_addr_size
= fc
->ptr_size
;
8311 fc
->ptr_size
= eh_addr_size
;
8312 fc
->segment_size
= 0;
8315 READ_ULEB (fc
->code_factor
, start
, end
);
8316 READ_SLEB (fc
->data_factor
, start
, end
);
8324 READ_ULEB (fc
->ra
, start
, end
);
8327 if (fc
->augmentation
[0] == 'z')
8329 READ_ULEB (augmentation_data_len
, start
, end
);
8330 augmentation_data
= start
;
8331 /* PR 17512: file: 11042-2589-0.004. */
8332 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8334 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
8335 dwarf_vmatoa ("x", augmentation_data_len
),
8336 (unsigned long) (end
- start
));
8339 start
+= augmentation_data_len
;
8342 if (augmentation_data_len
)
8346 unsigned char *qend
;
8348 p
= (unsigned char *) fc
->augmentation
+ 1;
8349 q
= augmentation_data
;
8350 qend
= q
+ augmentation_data_len
;
8352 while (p
< end
&& q
< qend
)
8357 q
+= 1 + size_of_encoded_value (*q
);
8359 fc
->fde_encoding
= *q
++;
8368 /* Note - it is OK if this loop terminates with q < qend.
8369 Padding may have been inserted to align the end of the CIE. */
8374 *p_version
= version
;
8377 *p_aug_len
= augmentation_data_len
;
8378 *p_aug
= augmentation_data
;
8383 free (fc
->col_offset
);
8384 free (fc
->col_type
);
8389 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8390 If do_wide is not enabled, then formats the output to fit into 80 columns.
8391 PRINTED contains the number of characters already written to the current
8395 display_data (bfd_size_type printed
,
8396 const unsigned char * data
,
8397 const bfd_size_type len
)
8399 if (do_wide
|| len
< ((80 - printed
) / 3))
8400 for (printed
= 0; printed
< len
; ++printed
)
8401 printf (" %02x", data
[printed
]);
8404 for (printed
= 0; printed
< len
; ++printed
)
8406 if (printed
% (80 / 3) == 0)
8408 printf (" %02x", data
[printed
]);
8413 /* Prints out the contents on the augmentation data array.
8414 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8417 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
8421 i
= printf (_(" Augmentation data: "));
8422 display_data (i
, data
, len
);
8426 display_debug_frames (struct dwarf_section
*section
,
8427 void *file ATTRIBUTE_UNUSED
)
8429 unsigned char *start
= section
->start
;
8430 unsigned char *end
= start
+ section
->size
;
8431 unsigned char *section_start
= start
;
8432 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8433 Frame_Chunk
*remembered_state
= NULL
;
8435 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8436 unsigned int max_regs
= 0;
8437 const char *bad_reg
= _("bad register: ");
8438 unsigned int saved_eh_addr_size
= eh_addr_size
;
8440 introduce (section
, FALSE
);
8444 unsigned char *saved_start
;
8445 unsigned char *block_end
;
8450 int need_col_headers
= 1;
8451 unsigned char *augmentation_data
= NULL
;
8452 bfd_size_type augmentation_data_len
= 0;
8453 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8454 unsigned int offset_size
;
8455 unsigned int initial_length_size
;
8456 bfd_boolean all_nops
;
8457 static Frame_Chunk fde_fc
;
8459 saved_start
= start
;
8461 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8465 printf ("\n%08lx ZERO terminator\n\n",
8466 (unsigned long)(saved_start
- section_start
));
8467 /* Skip any zero terminators that directly follow.
8468 A corrupt section size could have loaded a whole
8469 slew of zero filled memory bytes. eg
8470 PR 17512: file: 070-19381-0.004. */
8471 while (start
< end
&& * start
== 0)
8476 if (length
== 0xffffffff)
8478 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8480 initial_length_size
= 12;
8485 initial_length_size
= 4;
8488 block_end
= saved_start
+ length
+ initial_length_size
;
8489 if (block_end
> end
|| block_end
< start
)
8491 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8492 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8493 (unsigned long) (saved_start
- section_start
));
8497 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
8499 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8500 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8505 start
= read_cie (start
, end
, &cie
, &version
,
8506 &augmentation_data_len
, &augmentation_data
);
8507 /* PR 17512: file: 027-135133-0.005. */
8514 fc
->chunk_start
= saved_start
;
8515 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8518 if (frame_need_space (fc
, mreg
) < 0)
8520 if (fc
->fde_encoding
)
8521 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8523 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8524 print_dwarf_vma (length
, fc
->ptr_size
);
8525 print_dwarf_vma (cie_id
, offset_size
);
8527 if (do_debug_frames_interp
)
8529 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8530 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8535 printf (" Version: %d\n", version
);
8536 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8539 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8540 printf (" Segment Size: %u\n", fc
->segment_size
);
8542 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8543 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8544 printf (" Return address column: %d\n", fc
->ra
);
8546 if (augmentation_data_len
)
8547 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8554 unsigned char *look_for
;
8555 unsigned long segment_selector
;
8559 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8560 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
8563 look_for
= section_start
+ cie_id
;
8565 if (look_for
<= saved_start
)
8567 for (cie
= chunks
; cie
; cie
= cie
->next
)
8568 if (cie
->chunk_start
== look_for
)
8573 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8574 if (cie
->chunk_start
== look_for
)
8578 unsigned int off_size
;
8579 unsigned char *cie_scan
;
8581 cie_scan
= look_for
;
8583 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8584 if (length
== 0xffffffff)
8586 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8593 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
8596 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8597 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8602 read_cie (cie_scan
, end
, &cie
, &version
,
8603 &augmentation_data_len
, &augmentation_data
);
8604 /* PR 17512: file: 3450-2098-0.004. */
8607 warn (_("Failed to read CIE information\n"));
8610 cie
->next
= forward_refs
;
8612 cie
->chunk_start
= look_for
;
8613 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8616 if (frame_need_space (cie
, mreg
) < 0)
8618 warn (_("Invalid max register\n"));
8621 if (cie
->fde_encoding
)
8623 = size_of_encoded_value (cie
->fde_encoding
);
8630 memset (fc
, 0, sizeof (Frame_Chunk
));
8634 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8635 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8636 (unsigned long) (saved_start
- section_start
));
8638 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8639 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8640 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8642 warn (_("Invalid max register\n"));
8646 fc
->augmentation
= "";
8647 fc
->fde_encoding
= 0;
8648 fc
->ptr_size
= eh_addr_size
;
8649 fc
->segment_size
= 0;
8653 fc
->ncols
= cie
->ncols
;
8654 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8655 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8656 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8657 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8658 fc
->augmentation
= cie
->augmentation
;
8659 fc
->ptr_size
= cie
->ptr_size
;
8660 eh_addr_size
= cie
->ptr_size
;
8661 fc
->segment_size
= cie
->segment_size
;
8662 fc
->code_factor
= cie
->code_factor
;
8663 fc
->data_factor
= cie
->data_factor
;
8664 fc
->cfa_reg
= cie
->cfa_reg
;
8665 fc
->cfa_offset
= cie
->cfa_offset
;
8667 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8669 warn (_("Invalid max register\n"));
8672 fc
->fde_encoding
= cie
->fde_encoding
;
8675 if (fc
->fde_encoding
)
8676 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8678 segment_selector
= 0;
8679 if (fc
->segment_size
)
8681 if (fc
->segment_size
> sizeof (segment_selector
))
8683 /* PR 17512: file: 9e196b3e. */
8684 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8685 fc
->segment_size
= 4;
8687 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8690 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8692 /* FIXME: It appears that sometimes the final pc_range value is
8693 encoded in less than encoded_ptr_size bytes. See the x86_64
8694 run of the "objcopy on compressed debug sections" test for an
8696 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8698 if (cie
->augmentation
[0] == 'z')
8700 READ_ULEB (augmentation_data_len
, start
, end
);
8701 augmentation_data
= start
;
8702 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8703 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8705 warn (_("Augmentation data too long: 0x%s, "
8706 "expected at most %#lx\n"),
8707 dwarf_vmatoa ("x", augmentation_data_len
),
8708 (unsigned long) (end
- start
));
8710 augmentation_data
= NULL
;
8711 augmentation_data_len
= 0;
8713 start
+= augmentation_data_len
;
8716 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8717 (unsigned long)(saved_start
- section_start
),
8718 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8719 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8720 (unsigned long)(cie
->chunk_start
- section_start
));
8722 if (fc
->segment_size
)
8723 printf ("%04lx:", segment_selector
);
8726 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8727 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8729 if (! do_debug_frames_interp
&& augmentation_data_len
)
8731 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8736 /* At this point, fc is the current chunk, cie (if any) is set, and
8737 we're about to interpret instructions for the chunk. */
8738 /* ??? At present we need to do this always, since this sizes the
8739 fc->col_type and fc->col_offset arrays, which we write into always.
8740 We should probably split the interpreted and non-interpreted bits
8741 into two different routines, since there's so much that doesn't
8742 really overlap between them. */
8743 if (1 || do_debug_frames_interp
)
8745 /* Start by making a pass over the chunk, allocating storage
8746 and taking note of what registers are used. */
8747 unsigned char *tmp
= start
;
8749 while (start
< block_end
)
8751 unsigned int reg
, op
, opa
;
8753 unsigned char * new_start
;
8760 /* Warning: if you add any more cases to this switch, be
8761 sure to add them to the corresponding switch below. */
8764 case DW_CFA_advance_loc
:
8767 SKIP_ULEB (start
, end
);
8768 if (frame_need_space (fc
, opa
) >= 0)
8769 fc
->col_type
[opa
] = DW_CFA_undefined
;
8771 case DW_CFA_restore
:
8772 if (frame_need_space (fc
, opa
) >= 0)
8773 fc
->col_type
[opa
] = DW_CFA_undefined
;
8775 case DW_CFA_set_loc
:
8776 start
+= encoded_ptr_size
;
8778 case DW_CFA_advance_loc1
:
8781 case DW_CFA_advance_loc2
:
8784 case DW_CFA_advance_loc4
:
8787 case DW_CFA_offset_extended
:
8788 case DW_CFA_val_offset
:
8789 READ_ULEB (reg
, start
, end
);
8790 SKIP_ULEB (start
, end
);
8791 if (frame_need_space (fc
, reg
) >= 0)
8792 fc
->col_type
[reg
] = DW_CFA_undefined
;
8794 case DW_CFA_restore_extended
:
8795 READ_ULEB (reg
, start
, end
);
8796 if (frame_need_space (fc
, reg
) >= 0)
8797 fc
->col_type
[reg
] = DW_CFA_undefined
;
8799 case DW_CFA_undefined
:
8800 READ_ULEB (reg
, start
, end
);
8801 if (frame_need_space (fc
, reg
) >= 0)
8802 fc
->col_type
[reg
] = DW_CFA_undefined
;
8804 case DW_CFA_same_value
:
8805 READ_ULEB (reg
, start
, end
);
8806 if (frame_need_space (fc
, reg
) >= 0)
8807 fc
->col_type
[reg
] = DW_CFA_undefined
;
8809 case DW_CFA_register
:
8810 READ_ULEB (reg
, start
, end
);
8811 SKIP_ULEB (start
, end
);
8812 if (frame_need_space (fc
, reg
) >= 0)
8813 fc
->col_type
[reg
] = DW_CFA_undefined
;
8815 case DW_CFA_def_cfa
:
8816 SKIP_ULEB (start
, end
);
8817 SKIP_ULEB (start
, end
);
8819 case DW_CFA_def_cfa_register
:
8820 SKIP_ULEB (start
, end
);
8822 case DW_CFA_def_cfa_offset
:
8823 SKIP_ULEB (start
, end
);
8825 case DW_CFA_def_cfa_expression
:
8826 READ_ULEB (temp
, start
, end
);
8827 new_start
= start
+ temp
;
8828 if (new_start
< start
)
8830 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8836 case DW_CFA_expression
:
8837 case DW_CFA_val_expression
:
8838 READ_ULEB (reg
, start
, end
);
8839 READ_ULEB (temp
, start
, end
);
8840 new_start
= start
+ temp
;
8841 if (new_start
< start
)
8843 /* PR 17512: file:306-192417-0.005. */
8844 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8849 if (frame_need_space (fc
, reg
) >= 0)
8850 fc
->col_type
[reg
] = DW_CFA_undefined
;
8852 case DW_CFA_offset_extended_sf
:
8853 case DW_CFA_val_offset_sf
:
8854 READ_ULEB (reg
, start
, end
);
8855 SKIP_SLEB (start
, end
);
8856 if (frame_need_space (fc
, reg
) >= 0)
8857 fc
->col_type
[reg
] = DW_CFA_undefined
;
8859 case DW_CFA_def_cfa_sf
:
8860 SKIP_ULEB (start
, end
);
8861 SKIP_SLEB (start
, end
);
8863 case DW_CFA_def_cfa_offset_sf
:
8864 SKIP_SLEB (start
, end
);
8866 case DW_CFA_MIPS_advance_loc8
:
8869 case DW_CFA_GNU_args_size
:
8870 SKIP_ULEB (start
, end
);
8872 case DW_CFA_GNU_negative_offset_extended
:
8873 READ_ULEB (reg
, start
, end
);
8874 SKIP_ULEB (start
, end
);
8875 if (frame_need_space (fc
, reg
) >= 0)
8876 fc
->col_type
[reg
] = DW_CFA_undefined
;
8887 /* Now we know what registers are used, make a second pass over
8888 the chunk, this time actually printing out the info. */
8890 while (start
< block_end
)
8892 unsigned char * tmp
;
8894 unsigned long ul
, roffs
;
8895 /* Note: It is tempting to use an unsigned long for 'reg' but there
8896 are various functions, notably frame_space_needed() that assume that
8897 reg is an unsigned int. */
8902 const char *reg_prefix
= "";
8909 /* Make a note if something other than DW_CFA_nop happens. */
8910 if (op
!= DW_CFA_nop
)
8913 /* Warning: if you add any more cases to this switch, be
8914 sure to add them to the corresponding switch above. */
8917 case DW_CFA_advance_loc
:
8918 if (do_debug_frames_interp
)
8919 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8921 printf (" DW_CFA_advance_loc: %d to %s\n",
8922 opa
* fc
->code_factor
,
8923 dwarf_vmatoa_1 (NULL
,
8924 fc
->pc_begin
+ opa
* fc
->code_factor
,
8926 fc
->pc_begin
+= opa
* fc
->code_factor
;
8930 READ_ULEB (roffs
, start
, end
);
8931 if (opa
>= (unsigned int) fc
->ncols
)
8932 reg_prefix
= bad_reg
;
8933 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8934 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8935 reg_prefix
, regname (opa
, 0),
8936 roffs
* fc
->data_factor
);
8937 if (*reg_prefix
== '\0')
8939 fc
->col_type
[opa
] = DW_CFA_offset
;
8940 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8944 case DW_CFA_restore
:
8945 if (opa
>= (unsigned int) fc
->ncols
)
8946 reg_prefix
= bad_reg
;
8947 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8948 printf (" DW_CFA_restore: %s%s\n",
8949 reg_prefix
, regname (opa
, 0));
8950 if (*reg_prefix
!= '\0')
8953 if (opa
>= (unsigned int) cie
->ncols
8954 || (do_debug_frames_interp
8955 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8957 fc
->col_type
[opa
] = DW_CFA_undefined
;
8958 fc
->col_offset
[opa
] = 0;
8962 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8963 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8967 case DW_CFA_set_loc
:
8968 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8969 if (do_debug_frames_interp
)
8970 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8972 printf (" DW_CFA_set_loc: %s\n",
8973 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8977 case DW_CFA_advance_loc1
:
8978 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8979 if (do_debug_frames_interp
)
8980 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8982 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8983 (unsigned long) (ofs
* fc
->code_factor
),
8984 dwarf_vmatoa_1 (NULL
,
8985 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8987 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8990 case DW_CFA_advance_loc2
:
8991 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8992 if (do_debug_frames_interp
)
8993 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8995 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8996 (unsigned long) (ofs
* fc
->code_factor
),
8997 dwarf_vmatoa_1 (NULL
,
8998 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9000 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9003 case DW_CFA_advance_loc4
:
9004 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
9005 if (do_debug_frames_interp
)
9006 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9008 printf (" DW_CFA_advance_loc4: %ld to %s\n",
9009 (unsigned long) (ofs
* fc
->code_factor
),
9010 dwarf_vmatoa_1 (NULL
,
9011 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9013 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9016 case DW_CFA_offset_extended
:
9017 READ_ULEB (reg
, start
, end
);
9018 READ_ULEB (roffs
, start
, end
);
9019 if (reg
>= (unsigned int) fc
->ncols
)
9020 reg_prefix
= bad_reg
;
9021 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9022 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9023 reg_prefix
, regname (reg
, 0),
9024 roffs
* fc
->data_factor
);
9025 if (*reg_prefix
== '\0')
9027 fc
->col_type
[reg
] = DW_CFA_offset
;
9028 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9032 case DW_CFA_val_offset
:
9033 READ_ULEB (reg
, start
, end
);
9034 READ_ULEB (roffs
, start
, end
);
9035 if (reg
>= (unsigned int) fc
->ncols
)
9036 reg_prefix
= bad_reg
;
9037 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9038 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9039 reg_prefix
, regname (reg
, 0),
9040 roffs
* fc
->data_factor
);
9041 if (*reg_prefix
== '\0')
9043 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9044 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9048 case DW_CFA_restore_extended
:
9049 READ_ULEB (reg
, start
, end
);
9050 if (reg
>= (unsigned int) fc
->ncols
)
9051 reg_prefix
= bad_reg
;
9052 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9053 printf (" DW_CFA_restore_extended: %s%s\n",
9054 reg_prefix
, regname (reg
, 0));
9055 if (*reg_prefix
!= '\0')
9058 if (reg
>= (unsigned int) cie
->ncols
)
9060 fc
->col_type
[reg
] = DW_CFA_undefined
;
9061 fc
->col_offset
[reg
] = 0;
9065 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9066 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9070 case DW_CFA_undefined
:
9071 READ_ULEB (reg
, start
, end
);
9072 if (reg
>= (unsigned int) fc
->ncols
)
9073 reg_prefix
= bad_reg
;
9074 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9075 printf (" DW_CFA_undefined: %s%s\n",
9076 reg_prefix
, regname (reg
, 0));
9077 if (*reg_prefix
== '\0')
9079 fc
->col_type
[reg
] = DW_CFA_undefined
;
9080 fc
->col_offset
[reg
] = 0;
9084 case DW_CFA_same_value
:
9085 READ_ULEB (reg
, start
, end
);
9086 if (reg
>= (unsigned int) fc
->ncols
)
9087 reg_prefix
= bad_reg
;
9088 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9089 printf (" DW_CFA_same_value: %s%s\n",
9090 reg_prefix
, regname (reg
, 0));
9091 if (*reg_prefix
== '\0')
9093 fc
->col_type
[reg
] = DW_CFA_same_value
;
9094 fc
->col_offset
[reg
] = 0;
9098 case DW_CFA_register
:
9099 READ_ULEB (reg
, start
, end
);
9100 READ_ULEB (roffs
, start
, end
);
9101 if (reg
>= (unsigned int) fc
->ncols
)
9102 reg_prefix
= bad_reg
;
9103 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9105 printf (" DW_CFA_register: %s%s in ",
9106 reg_prefix
, regname (reg
, 0));
9107 puts (regname (roffs
, 0));
9109 if (*reg_prefix
== '\0')
9111 fc
->col_type
[reg
] = DW_CFA_register
;
9112 fc
->col_offset
[reg
] = roffs
;
9116 case DW_CFA_remember_state
:
9117 if (! do_debug_frames_interp
)
9118 printf (" DW_CFA_remember_state\n");
9119 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9120 rs
->cfa_offset
= fc
->cfa_offset
;
9121 rs
->cfa_reg
= fc
->cfa_reg
;
9123 rs
->cfa_exp
= fc
->cfa_exp
;
9124 rs
->ncols
= fc
->ncols
;
9125 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9126 sizeof (* rs
->col_type
));
9127 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9128 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9129 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9130 rs
->next
= remembered_state
;
9131 remembered_state
= rs
;
9134 case DW_CFA_restore_state
:
9135 if (! do_debug_frames_interp
)
9136 printf (" DW_CFA_restore_state\n");
9137 rs
= remembered_state
;
9140 remembered_state
= rs
->next
;
9141 fc
->cfa_offset
= rs
->cfa_offset
;
9142 fc
->cfa_reg
= rs
->cfa_reg
;
9144 fc
->cfa_exp
= rs
->cfa_exp
;
9145 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9147 warn (_("Invalid column number in saved frame state\n"));
9151 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9152 memcpy (fc
->col_offset
, rs
->col_offset
,
9153 rs
->ncols
* sizeof (* rs
->col_offset
));
9154 free (rs
->col_type
);
9155 free (rs
->col_offset
);
9158 else if (do_debug_frames_interp
)
9159 printf ("Mismatched DW_CFA_restore_state\n");
9162 case DW_CFA_def_cfa
:
9163 READ_ULEB (fc
->cfa_reg
, start
, end
);
9164 READ_ULEB (fc
->cfa_offset
, start
, end
);
9166 if (! do_debug_frames_interp
)
9167 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9168 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9171 case DW_CFA_def_cfa_register
:
9172 READ_ULEB (fc
->cfa_reg
, start
, end
);
9174 if (! do_debug_frames_interp
)
9175 printf (" DW_CFA_def_cfa_register: %s\n",
9176 regname (fc
->cfa_reg
, 0));
9179 case DW_CFA_def_cfa_offset
:
9180 READ_ULEB (fc
->cfa_offset
, start
, end
);
9181 if (! do_debug_frames_interp
)
9182 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9186 if (! do_debug_frames_interp
)
9187 printf (" DW_CFA_nop\n");
9190 case DW_CFA_def_cfa_expression
:
9191 READ_ULEB (ul
, start
, end
);
9192 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
9194 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9197 if (! do_debug_frames_interp
)
9199 printf (" DW_CFA_def_cfa_expression (");
9200 decode_location_expression (start
, eh_addr_size
, 0, -1,
9208 case DW_CFA_expression
:
9209 READ_ULEB (reg
, start
, end
);
9210 READ_ULEB (ul
, start
, end
);
9211 if (reg
>= (unsigned int) fc
->ncols
)
9212 reg_prefix
= bad_reg
;
9213 /* PR 17512: file: 069-133014-0.006. */
9214 /* PR 17512: file: 98c02eb4. */
9216 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
9218 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9221 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9223 printf (" DW_CFA_expression: %s%s (",
9224 reg_prefix
, regname (reg
, 0));
9225 decode_location_expression (start
, eh_addr_size
, 0, -1,
9229 if (*reg_prefix
== '\0')
9230 fc
->col_type
[reg
] = DW_CFA_expression
;
9234 case DW_CFA_val_expression
:
9235 READ_ULEB (reg
, start
, end
);
9236 READ_ULEB (ul
, start
, end
);
9237 if (reg
>= (unsigned int) fc
->ncols
)
9238 reg_prefix
= bad_reg
;
9240 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
9242 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9245 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9247 printf (" DW_CFA_val_expression: %s%s (",
9248 reg_prefix
, regname (reg
, 0));
9249 decode_location_expression (start
, eh_addr_size
, 0, -1,
9253 if (*reg_prefix
== '\0')
9254 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9258 case DW_CFA_offset_extended_sf
:
9259 READ_ULEB (reg
, start
, end
);
9260 READ_SLEB (l
, start
, end
);
9261 if (frame_need_space (fc
, reg
) < 0)
9262 reg_prefix
= bad_reg
;
9263 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9264 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
9265 reg_prefix
, regname (reg
, 0),
9266 (long)(l
* fc
->data_factor
));
9267 if (*reg_prefix
== '\0')
9269 fc
->col_type
[reg
] = DW_CFA_offset
;
9270 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9274 case DW_CFA_val_offset_sf
:
9275 READ_ULEB (reg
, start
, end
);
9276 READ_SLEB (l
, start
, end
);
9277 if (frame_need_space (fc
, reg
) < 0)
9278 reg_prefix
= bad_reg
;
9279 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9280 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
9281 reg_prefix
, regname (reg
, 0),
9282 (long)(l
* fc
->data_factor
));
9283 if (*reg_prefix
== '\0')
9285 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9286 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9290 case DW_CFA_def_cfa_sf
:
9291 READ_ULEB (fc
->cfa_reg
, start
, end
);
9292 READ_ULEB (fc
->cfa_offset
, start
, end
);
9293 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
9295 if (! do_debug_frames_interp
)
9296 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
9297 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9300 case DW_CFA_def_cfa_offset_sf
:
9301 READ_ULEB (fc
->cfa_offset
, start
, end
);
9302 fc
->cfa_offset
*= fc
->data_factor
;
9303 if (! do_debug_frames_interp
)
9304 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
9307 case DW_CFA_MIPS_advance_loc8
:
9308 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9309 if (do_debug_frames_interp
)
9310 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9312 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
9313 (unsigned long) (ofs
* fc
->code_factor
),
9314 dwarf_vmatoa_1 (NULL
,
9315 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9317 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9320 case DW_CFA_GNU_window_save
:
9321 if (! do_debug_frames_interp
)
9322 printf (" DW_CFA_GNU_window_save\n");
9325 case DW_CFA_GNU_args_size
:
9326 READ_ULEB (ul
, start
, end
);
9327 if (! do_debug_frames_interp
)
9328 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9331 case DW_CFA_GNU_negative_offset_extended
:
9332 READ_ULEB (reg
, start
, end
);
9333 READ_SLEB (l
, start
, end
);
9335 if (frame_need_space (fc
, reg
) < 0)
9336 reg_prefix
= bad_reg
;
9337 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9338 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
9339 reg_prefix
, regname (reg
, 0),
9340 (long)(l
* fc
->data_factor
));
9341 if (*reg_prefix
== '\0')
9343 fc
->col_type
[reg
] = DW_CFA_offset
;
9344 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9349 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9350 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9352 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9357 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9358 if (do_debug_frames_interp
&& ! all_nops
)
9359 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9361 if (fde_fc
.col_type
!= NULL
)
9363 free (fde_fc
.col_type
);
9364 fde_fc
.col_type
= NULL
;
9366 if (fde_fc
.col_offset
!= NULL
)
9368 free (fde_fc
.col_offset
);
9369 fde_fc
.col_offset
= NULL
;
9373 eh_addr_size
= saved_eh_addr_size
;
9378 while (remembered_state
!= NULL
)
9380 rs
= remembered_state
;
9381 remembered_state
= rs
->next
;
9382 free (rs
->col_type
);
9383 free (rs
->col_offset
);
9384 rs
->next
= NULL
; /* Paranoia. */
9388 while (chunks
!= NULL
)
9392 free (rs
->col_type
);
9393 free (rs
->col_offset
);
9394 rs
->next
= NULL
; /* Paranoia. */
9398 while (forward_refs
!= NULL
)
9401 forward_refs
= rs
->next
;
9402 free (rs
->col_type
);
9403 free (rs
->col_offset
);
9404 rs
->next
= NULL
; /* Paranoia. */
9414 display_debug_names (struct dwarf_section
*section
, void *file
)
9416 unsigned char *hdrptr
= section
->start
;
9417 dwarf_vma unit_length
;
9418 unsigned char *unit_start
;
9419 const unsigned char *const section_end
= section
->start
+ section
->size
;
9420 unsigned char *unit_end
;
9422 introduce (section
, FALSE
);
9424 load_debug_section_with_follow (str
, file
);
9426 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9428 unsigned int offset_size
;
9429 uint16_t dwarf_version
, padding
;
9430 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9431 uint32_t bucket_count
, name_count
, abbrev_table_size
;
9432 uint32_t augmentation_string_size
;
9434 unsigned long sec_off
;
9435 bfd_boolean augmentation_printable
;
9436 const char *augmentation_string
;
9438 unit_start
= hdrptr
;
9440 /* Get and check the length of the block. */
9441 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9443 if (unit_length
== 0xffffffff)
9445 /* This section is 64-bit DWARF. */
9446 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9451 unit_end
= hdrptr
+ unit_length
;
9453 sec_off
= hdrptr
- section
->start
;
9454 if (sec_off
+ unit_length
< sec_off
9455 || sec_off
+ unit_length
> section
->size
)
9457 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9459 (unsigned long) (unit_start
- section
->start
),
9460 dwarf_vmatoa ("x", unit_length
));
9464 /* Get and check the version number. */
9465 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9466 printf (_("Version %ld\n"), (long) dwarf_version
);
9468 /* Prior versions did not exist, and future versions may not be
9469 backwards compatible. */
9470 if (dwarf_version
!= 5)
9472 warn (_("Only DWARF version 5 .debug_names "
9473 "is currently supported.\n"));
9477 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9479 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9482 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9483 if (comp_unit_count
== 0)
9484 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9486 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9487 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9488 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9489 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9490 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9492 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9493 if (augmentation_string_size
% 4 != 0)
9495 warn (_("Augmentation string length %u must be rounded up "
9496 "to a multiple of 4 in .debug_names.\n"),
9497 augmentation_string_size
);
9498 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9501 printf (_("Augmentation string:"));
9503 augmentation_printable
= TRUE
;
9504 augmentation_string
= (const char *) hdrptr
;
9506 for (i
= 0; i
< augmentation_string_size
; i
++)
9510 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9511 printf (" %02x", uc
);
9513 if (uc
!= 0 && !ISPRINT (uc
))
9514 augmentation_printable
= FALSE
;
9517 if (augmentation_printable
)
9521 i
< augmentation_string_size
&& augmentation_string
[i
];
9523 putchar (augmentation_string
[i
]);
9528 printf (_("CU table:\n"));
9529 for (i
= 0; i
< comp_unit_count
; i
++)
9533 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9534 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9538 printf (_("TU table:\n"));
9539 for (i
= 0; i
< local_type_unit_count
; i
++)
9543 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9544 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9548 printf (_("Foreign TU table:\n"));
9549 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9553 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9554 printf (_("[%3u] "), i
);
9555 print_dwarf_vma (signature
, 8);
9560 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9561 hdrptr
+= bucket_count
* sizeof (uint32_t);
9562 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9563 hdrptr
+= name_count
* sizeof (uint32_t);
9564 unsigned char *const name_table_string_offsets
= hdrptr
;
9565 hdrptr
+= name_count
* offset_size
;
9566 unsigned char *const name_table_entry_offsets
= hdrptr
;
9567 hdrptr
+= name_count
* offset_size
;
9568 unsigned char *const abbrev_table
= hdrptr
;
9569 hdrptr
+= abbrev_table_size
;
9570 const unsigned char *const abbrev_table_end
= hdrptr
;
9571 unsigned char *const entry_pool
= hdrptr
;
9572 if (hdrptr
> unit_end
)
9574 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9575 "for unit 0x%lx in the debug_names\n"),
9576 (long) (hdrptr
- section
->start
),
9577 (long) (unit_end
- section
->start
),
9578 (long) (unit_start
- section
->start
));
9582 size_t buckets_filled
= 0;
9584 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9586 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9591 printf (ngettext ("Used %zu of %lu bucket.\n",
9592 "Used %zu of %lu buckets.\n",
9594 buckets_filled
, (unsigned long) bucket_count
);
9596 uint32_t hash_prev
= 0;
9597 size_t hash_clash_count
= 0;
9598 size_t longest_clash
= 0;
9599 size_t this_length
= 0;
9601 for (hashi
= 0; hashi
< name_count
; hashi
++)
9603 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9607 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9611 longest_clash
= MAX (longest_clash
, this_length
);
9616 hash_prev
= hash_this
;
9618 printf (_("Out of %lu items there are %zu bucket clashes"
9619 " (longest of %zu entries).\n"),
9620 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9621 assert (name_count
== buckets_filled
+ hash_clash_count
);
9623 struct abbrev_lookup_entry
9625 dwarf_vma abbrev_tag
;
9626 unsigned char *abbrev_lookup_ptr
;
9628 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9629 size_t abbrev_lookup_used
= 0;
9630 size_t abbrev_lookup_allocated
= 0;
9632 unsigned char *abbrevptr
= abbrev_table
;
9635 dwarf_vma abbrev_tag
;
9637 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9638 if (abbrev_tag
== 0)
9640 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9642 abbrev_lookup_allocated
= MAX (0x100,
9643 abbrev_lookup_allocated
* 2);
9644 abbrev_lookup
= xrealloc (abbrev_lookup
,
9645 (abbrev_lookup_allocated
9646 * sizeof (*abbrev_lookup
)));
9648 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9649 struct abbrev_lookup_entry
*entry
;
9650 for (entry
= abbrev_lookup
;
9651 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9653 if (entry
->abbrev_tag
== abbrev_tag
)
9655 warn (_("Duplicate abbreviation tag %lu "
9656 "in unit 0x%lx in the debug_names\n"),
9657 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9660 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9661 entry
->abbrev_tag
= abbrev_tag
;
9662 entry
->abbrev_lookup_ptr
= abbrevptr
;
9664 /* Skip DWARF tag. */
9665 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9668 dwarf_vma xindex
, form
;
9670 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9671 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9672 if (xindex
== 0 && form
== 0)
9677 printf (_("\nSymbol table:\n"));
9679 for (namei
= 0; namei
< name_count
; ++namei
)
9681 uint64_t string_offset
, entry_offset
;
9683 SAFE_BYTE_GET (string_offset
,
9684 name_table_string_offsets
+ namei
* offset_size
,
9685 offset_size
, unit_end
);
9686 SAFE_BYTE_GET (entry_offset
,
9687 name_table_entry_offsets
+ namei
* offset_size
,
9688 offset_size
, unit_end
);
9690 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9691 fetch_indirect_string (string_offset
));
9693 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9695 /* We need to scan first whether there is a single or multiple
9696 entries. TAGNO is -2 for the first entry, it is -1 for the
9697 initial tag read of the second entry, then it becomes 0 for the
9698 first entry for real printing etc. */
9700 /* Initialize it due to a false compiler warning. */
9701 dwarf_vma second_abbrev_tag
= -1;
9704 dwarf_vma abbrev_tag
;
9705 dwarf_vma dwarf_tag
;
9706 const struct abbrev_lookup_entry
*entry
;
9708 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9711 second_abbrev_tag
= abbrev_tag
;
9713 entryptr
= entry_pool
+ entry_offset
;
9716 if (abbrev_tag
== 0)
9720 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9721 (unsigned long) abbrev_tag
);
9723 for (entry
= abbrev_lookup
;
9724 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9726 if (entry
->abbrev_tag
== abbrev_tag
)
9728 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9730 warn (_("Undefined abbreviation tag %lu "
9731 "in unit 0x%lx in the debug_names\n"),
9733 (long) (unit_start
- section
->start
));
9736 abbrevptr
= entry
->abbrev_lookup_ptr
;
9737 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9739 printf (" %s", get_TAG_name (dwarf_tag
));
9742 dwarf_vma xindex
, form
;
9744 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9745 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9746 if (xindex
== 0 && form
== 0)
9750 printf (" %s", get_IDX_name (xindex
));
9751 entryptr
= read_and_display_attr_value (0, form
, 0,
9752 unit_start
, entryptr
, unit_end
,
9754 dwarf_version
, NULL
,
9761 printf (_(" <no entries>"));
9765 free (abbrev_lookup
);
9772 display_debug_links (struct dwarf_section
* section
,
9773 void * file ATTRIBUTE_UNUSED
)
9775 const unsigned char * filename
;
9776 unsigned int filelen
;
9778 introduce (section
, FALSE
);
9780 /* The .gnu_debuglink section is formatted as:
9781 (c-string) Filename.
9782 (padding) If needed to reach a 4 byte boundary.
9783 (uint32_t) CRC32 value.
9785 The .gun_debugaltlink section is formatted as:
9786 (c-string) Filename.
9787 (binary) Build-ID. */
9789 filename
= section
->start
;
9790 filelen
= strnlen ((const char *) filename
, section
->size
);
9791 if (filelen
== section
->size
)
9793 warn (_("The debuglink filename is corrupt/missing\n"));
9797 printf (_(" Separate debug info file: %s\n"), filename
);
9799 if (const_strneq (section
->name
, ".gnu_debuglink"))
9802 unsigned int crc_offset
;
9804 crc_offset
= filelen
+ 1;
9805 crc_offset
= (crc_offset
+ 3) & ~3;
9806 if (crc_offset
+ 4 > section
->size
)
9808 warn (_("CRC offset missing/truncated\n"));
9812 crc32
= byte_get (filename
+ crc_offset
, 4);
9814 printf (_(" CRC value: %#x\n"), crc32
);
9816 if (crc_offset
+ 4 < section
->size
)
9818 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9819 (long)(section
->size
- (crc_offset
+ 4)));
9823 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9825 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9826 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9827 bfd_size_type printed
;
9829 /* FIXME: Should we support smaller build-id notes ? */
9830 if (build_id_len
< 0x14)
9832 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9836 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9837 display_data (printed
, build_id
, build_id_len
);
9846 display_gdb_index (struct dwarf_section
*section
,
9847 void *file ATTRIBUTE_UNUSED
)
9849 unsigned char *start
= section
->start
;
9851 uint32_t cu_list_offset
, tu_list_offset
;
9852 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9853 unsigned int cu_list_elements
, tu_list_elements
;
9854 unsigned int address_table_size
, symbol_table_slots
;
9855 unsigned char *cu_list
, *tu_list
;
9856 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9859 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9861 introduce (section
, FALSE
);
9863 if (section
->size
< 6 * sizeof (uint32_t))
9865 warn (_("Truncated header in the %s section.\n"), section
->name
);
9869 version
= byte_get_little_endian (start
, 4);
9870 printf (_("Version %ld\n"), (long) version
);
9872 /* Prior versions are obsolete, and future versions may not be
9873 backwards compatible. */
9874 if (version
< 3 || version
> 8)
9876 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9880 warn (_("The address table data in version 3 may be wrong.\n"));
9882 warn (_("Version 4 does not support case insensitive lookups.\n"));
9884 warn (_("Version 5 does not include inlined functions.\n"));
9886 warn (_("Version 6 does not include symbol attributes.\n"));
9887 /* Version 7 indices generated by Gold have bad type unit references,
9888 PR binutils/15021. But we don't know if the index was generated by
9889 Gold or not, so to avoid worrying users with gdb-generated indices
9890 we say nothing for version 7 here. */
9892 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9893 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9894 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9895 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9896 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9898 if (cu_list_offset
> section
->size
9899 || tu_list_offset
> section
->size
9900 || address_table_offset
> section
->size
9901 || symbol_table_offset
> section
->size
9902 || constant_pool_offset
> section
->size
)
9904 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9908 /* PR 17531: file: 418d0a8a. */
9909 if (tu_list_offset
< cu_list_offset
)
9911 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9912 tu_list_offset
, cu_list_offset
);
9916 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9918 if (address_table_offset
< tu_list_offset
)
9920 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9921 address_table_offset
, tu_list_offset
);
9925 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9927 /* PR 17531: file: 18a47d3d. */
9928 if (symbol_table_offset
< address_table_offset
)
9930 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9931 symbol_table_offset
, address_table_offset
);
9935 address_table_size
= symbol_table_offset
- address_table_offset
;
9937 if (constant_pool_offset
< symbol_table_offset
)
9939 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9940 constant_pool_offset
, symbol_table_offset
);
9944 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9946 cu_list
= start
+ cu_list_offset
;
9947 tu_list
= start
+ tu_list_offset
;
9948 address_table
= start
+ address_table_offset
;
9949 symbol_table
= start
+ symbol_table_offset
;
9950 constant_pool
= start
+ constant_pool_offset
;
9952 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9954 warn (_("Address table extends beyond end of section.\n"));
9958 printf (_("\nCU table:\n"));
9959 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9961 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9962 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9964 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9965 (unsigned long) cu_offset
,
9966 (unsigned long) (cu_offset
+ cu_length
- 1));
9969 printf (_("\nTU table:\n"));
9970 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9972 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9973 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9974 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9976 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9977 (unsigned long) tu_offset
,
9978 (unsigned long) type_offset
);
9979 print_dwarf_vma (signature
, 8);
9983 printf (_("\nAddress table:\n"));
9984 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9987 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9988 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9989 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9991 print_dwarf_vma (low
, 8);
9992 print_dwarf_vma (high
, 8);
9993 printf (_("%lu\n"), (unsigned long) cu_index
);
9996 printf (_("\nSymbol table:\n"));
9997 for (i
= 0; i
< symbol_table_slots
; ++i
)
9999 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
10000 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
10001 uint32_t num_cus
, cu
;
10003 if (name_offset
!= 0
10004 || cu_vector_offset
!= 0)
10007 unsigned char * adr
;
10009 adr
= constant_pool
+ name_offset
;
10010 /* PR 17531: file: 5b7b07ad. */
10011 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
10013 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10014 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10018 printf ("[%3u] %.*s:", i
,
10019 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10020 constant_pool
+ name_offset
);
10022 adr
= constant_pool
+ cu_vector_offset
;
10023 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
10025 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10026 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10027 cu_vector_offset
, i
);
10031 num_cus
= byte_get_little_endian (adr
, 4);
10033 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
10034 if (num_cus
* 4 < num_cus
10035 || adr
>= section
->start
+ section
->size
10036 || adr
< constant_pool
)
10038 printf ("<invalid number of CUs: %d>\n", num_cus
);
10039 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10047 for (j
= 0; j
< num_cus
; ++j
)
10050 gdb_index_symbol_kind kind
;
10052 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10053 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10054 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10055 cu
= GDB_INDEX_CU_VALUE (cu
);
10056 /* Convert to TU number if it's for a type unit. */
10057 if (cu
>= cu_list_elements
/ 2)
10058 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10059 (unsigned long) (cu
- cu_list_elements
/ 2));
10061 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10063 printf (" [%s, %s]",
10064 is_static
? _("static") : _("global"),
10065 get_gdb_index_symbol_kind_name (kind
));
10077 /* Pre-allocate enough space for the CU/TU sets needed. */
10080 prealloc_cu_tu_list (unsigned int nshndx
)
10082 if (shndx_pool
== NULL
)
10084 shndx_pool_size
= nshndx
;
10085 shndx_pool_used
= 0;
10086 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10087 sizeof (unsigned int));
10091 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10092 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10093 sizeof (unsigned int));
10098 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10100 if (shndx_pool_used
>= shndx_pool_size
)
10102 error (_("Internal error: out of space in the shndx pool.\n"));
10105 shndx_pool
[shndx_pool_used
++] = shndx
;
10109 end_cu_tu_entry (void)
10111 if (shndx_pool_used
>= shndx_pool_size
)
10113 error (_("Internal error: out of space in the shndx pool.\n"));
10116 shndx_pool
[shndx_pool_used
++] = 0;
10119 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10121 static const char *
10122 get_DW_SECT_short_name (unsigned int dw_sect
)
10124 static char buf
[16];
10130 case DW_SECT_TYPES
:
10132 case DW_SECT_ABBREV
:
10138 case DW_SECT_STR_OFFSETS
:
10140 case DW_SECT_MACINFO
:
10142 case DW_SECT_MACRO
:
10148 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10152 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10153 These sections are extensions for Fission.
10154 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10157 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10159 unsigned char *phdr
= section
->start
;
10160 unsigned char *limit
= phdr
+ section
->size
;
10161 unsigned char *phash
;
10162 unsigned char *pindex
;
10163 unsigned char *ppool
;
10164 unsigned int version
;
10165 unsigned int ncols
= 0;
10166 unsigned int nused
;
10167 unsigned int nslots
;
10170 dwarf_vma signature_high
;
10171 dwarf_vma signature_low
;
10174 /* PR 17512: file: 002-168123-0.004. */
10177 warn (_("Section %s is empty\n"), section
->name
);
10180 /* PR 17512: file: 002-376-0.004. */
10181 if (section
->size
< 24)
10183 warn (_("Section %s is too small to contain a CU/TU header\n"),
10188 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
10190 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
10191 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
10192 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
10195 pindex
= phash
+ (size_t) nslots
* 8;
10196 ppool
= pindex
+ (size_t) nslots
* 4;
10200 introduce (section
, FALSE
);
10202 printf (_(" Version: %u\n"), version
);
10204 printf (_(" Number of columns: %u\n"), ncols
);
10205 printf (_(" Number of used entries: %u\n"), nused
);
10206 printf (_(" Number of slots: %u\n\n"), nslots
);
10209 /* PR 17531: file: 45d69832. */
10210 if ((size_t) nslots
* 8 / 8 != nslots
10211 || phash
< phdr
|| phash
> limit
10212 || pindex
< phash
|| pindex
> limit
10213 || ppool
< pindex
|| ppool
> limit
)
10215 warn (ngettext ("Section %s is too small for %u slot\n",
10216 "Section %s is too small for %u slots\n",
10218 section
->name
, nslots
);
10225 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10226 for (i
= 0; i
< nslots
; i
++)
10228 unsigned char *shndx_list
;
10229 unsigned int shndx
;
10231 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
10232 if (signature_high
!= 0 || signature_low
!= 0)
10234 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10235 shndx_list
= ppool
+ j
* 4;
10236 /* PR 17531: file: 705e010d. */
10237 if (shndx_list
< ppool
)
10239 warn (_("Section index pool located before start of section\n"));
10244 printf (_(" [%3d] Signature: 0x%s Sections: "),
10245 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10246 buf
, sizeof (buf
)));
10249 if (shndx_list
>= limit
)
10251 warn (_("Section %s too small for shndx pool\n"),
10255 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10259 printf (" %d", shndx
);
10261 add_shndx_to_cu_tu_entry (shndx
);
10267 end_cu_tu_entry ();
10273 else if (version
== 2)
10276 unsigned int dw_sect
;
10277 unsigned char *ph
= phash
;
10278 unsigned char *pi
= pindex
;
10279 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10280 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10281 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
10282 bfd_boolean is_tu_index
;
10283 struct cu_tu_set
*this_set
= NULL
;
10285 unsigned char *prow
;
10287 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10289 /* PR 17531: file: 0dd159bf.
10290 Check for integer overflow (can occur when size_t is 32-bit)
10291 with overlarge ncols or nused values. */
10293 && ((size_t) ncols
* 4 / 4 != ncols
10294 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
10295 || poffsets
< ppool
|| poffsets
> limit
10296 || psizes
< poffsets
|| psizes
> limit
10297 || pend
< psizes
|| pend
> limit
))
10299 warn (_("Section %s too small for offset and size tables\n"),
10306 printf (_(" Offset table\n"));
10307 printf (" slot %-16s ",
10308 is_tu_index
? _("signature") : _("dwo_id"));
10315 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10316 this_set
= tu_sets
;
10321 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10322 this_set
= cu_sets
;
10328 for (j
= 0; j
< ncols
; j
++)
10330 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10331 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10336 for (i
= 0; i
< nslots
; i
++)
10338 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
10340 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10343 /* PR 17531: file: a05f6ab3. */
10346 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10353 size_t num_copy
= sizeof (uint64_t);
10355 /* PR 23064: Beware of buffer overflow. */
10356 if (ph
+ num_copy
< limit
)
10357 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10360 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
10365 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10366 /* PR 17531: file: b8ce60a8. */
10367 if (prow
< poffsets
|| prow
> limit
)
10369 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
10375 printf (_(" [%3d] 0x%s"),
10376 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10377 buf
, sizeof (buf
)));
10378 for (j
= 0; j
< ncols
; j
++)
10380 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
10382 printf (" %8d", val
);
10385 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10387 /* PR 17531: file: 10796eb3. */
10388 if (dw_sect
>= DW_SECT_MAX
)
10389 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10391 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10407 printf (_(" Size table\n"));
10408 printf (" slot %-16s ",
10409 is_tu_index
? _("signature") : _("dwo_id"));
10412 for (j
= 0; j
< ncols
; j
++)
10414 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
10416 printf (" %8s", get_DW_SECT_short_name (val
));
10422 for (i
= 0; i
< nslots
; i
++)
10424 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
10426 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10429 prow
= psizes
+ (row
- 1) * ncols
* 4;
10432 printf (_(" [%3d] 0x%s"),
10433 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10434 buf
, sizeof (buf
)));
10436 for (j
= 0; j
< ncols
; j
++)
10438 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
10440 printf (" %8d", val
);
10443 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10444 if (dw_sect
>= DW_SECT_MAX
)
10445 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10447 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10459 else if (do_display
)
10460 printf (_(" Unsupported version (%d)\n"), version
);
10468 /* Load the CU and TU indexes if present. This will build a list of
10469 section sets that we can use to associate a .debug_info.dwo section
10470 with its associated .debug_abbrev.dwo section in a .dwp file. */
10473 load_cu_tu_indexes (void *file
)
10475 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10477 /* If we have already loaded (or tried to load) the CU and TU indexes
10478 then do not bother to repeat the task. */
10479 if (cu_tu_indexes_read
== -1)
10481 cu_tu_indexes_read
= TRUE
;
10483 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10484 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10485 cu_tu_indexes_read
= FALSE
;
10487 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10488 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10489 cu_tu_indexes_read
= FALSE
;
10492 return (bfd_boolean
) cu_tu_indexes_read
;
10495 /* Find the set of sections that includes section SHNDX. */
10498 find_cu_tu_set (void *file
, unsigned int shndx
)
10502 if (! load_cu_tu_indexes (file
))
10505 /* Find SHNDX in the shndx pool. */
10506 for (i
= 0; i
< shndx_pool_used
; i
++)
10507 if (shndx_pool
[i
] == shndx
)
10510 if (i
>= shndx_pool_used
)
10513 /* Now backup to find the first entry in the set. */
10514 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10517 return shndx_pool
+ i
;
10520 /* Display a .debug_cu_index or .debug_tu_index section. */
10523 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10525 return process_cu_tu_index (section
, 1);
10529 display_debug_not_supported (struct dwarf_section
*section
,
10530 void *file ATTRIBUTE_UNUSED
)
10532 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10538 /* Like malloc, but takes two parameters like calloc.
10539 Verifies that the first parameter is not too large.
10540 Note: does *not* initialise the allocated memory to zero. */
10543 cmalloc (size_t nmemb
, size_t size
)
10545 /* Check for overflow. */
10546 if (nmemb
>= ~(size_t) 0 / size
)
10549 return xmalloc (nmemb
* size
);
10552 /* Like xmalloc, but takes two parameters like calloc.
10553 Verifies that the first parameter is not too large.
10554 Note: does *not* initialise the allocated memory to zero. */
10557 xcmalloc (size_t nmemb
, size_t size
)
10559 /* Check for overflow. */
10560 if (nmemb
>= ~(size_t) 0 / size
)
10563 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10568 return xmalloc (nmemb
* size
);
10571 /* Like xrealloc, but takes three parameters.
10572 Verifies that the second parameter is not too large.
10573 Note: does *not* initialise any new memory to zero. */
10576 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10578 /* Check for overflow. */
10579 if (nmemb
>= ~(size_t) 0 / size
)
10581 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10586 return xrealloc (ptr
, nmemb
* size
);
10589 /* Like xcalloc, but verifies that the first parameter is not too large. */
10592 xcalloc2 (size_t nmemb
, size_t size
)
10594 /* Check for overflow. */
10595 if (nmemb
>= ~(size_t) 0 / size
)
10597 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10602 return xcalloc (nmemb
, size
);
10605 static unsigned long
10606 calc_gnu_debuglink_crc32 (unsigned long crc
,
10607 const unsigned char * buf
,
10610 static const unsigned long crc32_table
[256] =
10612 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10613 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10614 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10615 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10616 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10617 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10618 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10619 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10620 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10621 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10622 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10623 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10624 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10625 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10626 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10627 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10628 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10629 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10630 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10631 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10632 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10633 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10634 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10635 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10636 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10637 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10638 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10639 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10640 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10641 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10642 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10643 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10644 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10645 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10646 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10647 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10648 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10649 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10650 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10651 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10652 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10653 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10654 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10655 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10656 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10657 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10658 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10659 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10660 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10661 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10662 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10665 const unsigned char *end
;
10667 crc
= ~crc
& 0xffffffff;
10668 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10669 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10670 return ~crc
& 0xffffffff;
10673 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10674 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10677 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10679 static unsigned char buffer
[8 * 1024];
10681 bfd_size_type count
;
10682 unsigned long crc
= 0;
10685 sep_data
= open_debug_file (pathname
);
10686 if (sep_data
== NULL
)
10689 /* Yes - we are opening the file twice... */
10690 f
= fopen (pathname
, "rb");
10693 /* Paranoia: This should never happen. */
10694 close_debug_file (sep_data
);
10695 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10699 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10700 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10704 if (crc
!= * (unsigned long *) crc_pointer
)
10706 close_debug_file (sep_data
);
10707 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10715 static const char *
10716 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10719 unsigned int crc_offset
;
10720 unsigned long * crc32
= (unsigned long *) data
;
10722 /* The name is first.
10723 The CRC value is stored after the filename, aligned up to 4 bytes. */
10724 name
= (const char *) section
->start
;
10726 crc_offset
= strnlen (name
, section
->size
) + 1;
10727 crc_offset
= (crc_offset
+ 3) & ~3;
10728 if (crc_offset
+ 4 > section
->size
)
10731 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10736 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10738 void * sep_data
= open_debug_file (filename
);
10740 if (sep_data
== NULL
)
10743 /* FIXME: We should now extract the build-id in the separate file
10749 typedef struct build_id_data
10752 const unsigned char * data
;
10755 static const char *
10756 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10759 bfd_size_type namelen
;
10760 bfd_size_type id_len
;
10761 Build_id_data
* build_id_data
;
10763 /* The name is first.
10764 The build-id follows immediately, with no padding, up to the section's end. */
10766 name
= (const char *) section
->start
;
10767 namelen
= strnlen (name
, section
->size
) + 1;
10768 if (namelen
>= section
->size
)
10771 id_len
= section
->size
- namelen
;
10775 build_id_data
= (Build_id_data
*) data
;
10776 build_id_data
->len
= id_len
;
10777 build_id_data
->data
= section
->start
+ namelen
;
10783 add_separate_debug_file (const char * filename
, void * handle
)
10785 separate_info
* i
= xmalloc (sizeof * i
);
10787 i
->filename
= filename
;
10788 i
->handle
= handle
;
10789 i
->next
= first_separate_info
;
10790 first_separate_info
= i
;
10793 #if HAVE_LIBDEBUGINFOD
10794 /* Query debuginfod servers for the target debuglink or debugaltlink
10795 file. If successful, store the path of the file in filename and
10796 return TRUE, otherwise return FALSE. */
10799 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10803 size_t build_id_len
;
10804 unsigned char * build_id
;
10806 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10808 /* Get the build-id of file. */
10809 build_id
= get_build_id (file
);
10812 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10814 /* Get the build-id of the debugaltlink file. */
10815 unsigned int filelen
;
10817 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10818 if (filelen
== section
->size
)
10819 /* Corrupt debugaltlink. */
10822 build_id
= section
->start
+ filelen
+ 1;
10823 build_id_len
= section
->size
- (filelen
+ 1);
10825 if (build_id_len
== 0)
10834 debuginfod_client
* client
;
10836 client
= debuginfod_begin ();
10837 if (client
== NULL
)
10840 /* Query debuginfod servers for the target file. If found its path
10841 will be stored in filename. */
10842 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10843 debuginfod_end (client
);
10845 /* Only free build_id if we allocated space for a hex string
10846 in get_build_id (). */
10847 if (build_id_len
== 0)
10852 /* File successfully retrieved. Close fd since we want to
10853 use open_debug_file () on filename instead. */
10864 load_separate_debug_info (const char * main_filename
,
10865 struct dwarf_section
* xlink
,
10866 parse_func_type parse_func
,
10867 check_func_type check_func
,
10869 void * file ATTRIBUTE_UNUSED
)
10871 const char * separate_filename
;
10872 char * debug_filename
;
10874 size_t canon_dirlen
;
10877 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10879 warn (_("Corrupt debuglink section: %s\n"),
10880 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10884 /* Attempt to locate the separate file.
10885 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10887 canon_dir
= lrealpath (main_filename
);
10889 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10890 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10892 canon_dir
[canon_dirlen
] = '\0';
10895 #define DEBUGDIR "/lib/debug"
10897 #ifndef EXTRA_DEBUG_ROOT1
10898 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10900 #ifndef EXTRA_DEBUG_ROOT2
10901 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10904 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10906 + strlen (".debug/")
10907 #ifdef EXTRA_DEBUG_ROOT1
10908 + strlen (EXTRA_DEBUG_ROOT1
)
10910 #ifdef EXTRA_DEBUG_ROOT2
10911 + strlen (EXTRA_DEBUG_ROOT2
)
10913 + strlen (separate_filename
)
10915 if (debug_filename
== NULL
)
10917 warn (_("Out of memory"));
10922 /* First try in the current directory. */
10923 sprintf (debug_filename
, "%s", separate_filename
);
10924 if (check_func (debug_filename
, func_data
))
10927 /* Then try in a subdirectory called .debug. */
10928 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10929 if (check_func (debug_filename
, func_data
))
10932 /* Then try in the same directory as the original file. */
10933 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10934 if (check_func (debug_filename
, func_data
))
10937 /* And the .debug subdirectory of that directory. */
10938 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10939 if (check_func (debug_filename
, func_data
))
10942 #ifdef EXTRA_DEBUG_ROOT1
10943 /* Try the first extra debug file root. */
10944 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10945 if (check_func (debug_filename
, func_data
))
10948 /* Try the first extra debug file root. */
10949 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10950 if (check_func (debug_filename
, func_data
))
10954 #ifdef EXTRA_DEBUG_ROOT2
10955 /* Try the second extra debug file root. */
10956 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10957 if (check_func (debug_filename
, func_data
))
10961 /* Then try in the global debug_filename directory. */
10962 strcpy (debug_filename
, DEBUGDIR
);
10963 dirlen
= strlen (DEBUGDIR
) - 1;
10964 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10965 strcat (debug_filename
, "/");
10966 strcat (debug_filename
, (const char *) separate_filename
);
10968 if (check_func (debug_filename
, func_data
))
10971 #if HAVE_LIBDEBUGINFOD
10973 char * tmp_filename
;
10975 if (debuginfod_fetch_separate_debug_info (xlink
,
10979 /* File successfully downloaded from server, replace
10980 debug_filename with the file's path. */
10981 free (debug_filename
);
10982 debug_filename
= tmp_filename
;
10988 /* Failed to find the file. */
10989 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10990 warn (_("tried: %s\n"), debug_filename
);
10992 #ifdef EXTRA_DEBUG_ROOT2
10993 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10994 warn (_("tried: %s\n"), debug_filename
);
10997 #ifdef EXTRA_DEBUG_ROOT1
10998 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10999 warn (_("tried: %s\n"), debug_filename
);
11001 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
11002 warn (_("tried: %s\n"), debug_filename
);
11005 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
11006 warn (_("tried: %s\n"), debug_filename
);
11008 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11009 warn (_("tried: %s\n"), debug_filename
);
11011 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11012 warn (_("tried: %s\n"), debug_filename
);
11014 sprintf (debug_filename
, "%s", separate_filename
);
11015 warn (_("tried: %s\n"), debug_filename
);
11017 #if HAVE_LIBDEBUGINFOD
11019 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11023 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11028 free (debug_filename
);
11034 void * debug_handle
;
11036 /* Now open the file.... */
11037 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11039 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11040 free (debug_filename
);
11044 /* FIXME: We do not check to see if there are any other separate debug info
11045 files that would also match. */
11047 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
11048 add_separate_debug_file (debug_filename
, debug_handle
);
11050 /* Do not free debug_filename - it might be referenced inside
11051 the structure returned by open_debug_file(). */
11052 return debug_handle
;
11055 /* Attempt to load a separate dwarf object file. */
11058 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11060 char * separate_filename
;
11061 void * separate_handle
;
11063 /* FIXME: Skip adding / if dwo_dir ends in /. */
11064 separate_filename
= concat (dir
, "/", name
, NULL
);
11065 if (separate_filename
== NULL
)
11067 warn (_("Out of memory allocating dwo filename\n"));
11071 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11073 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11074 free (separate_filename
);
11078 /* FIXME: We should check the dwo_id. */
11080 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11081 add_separate_debug_file (separate_filename
, separate_handle
);
11082 /* Note - separate_filename will be freed in free_debug_memory(). */
11083 return separate_handle
;
11086 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11087 Recursively check the loaded files for more of these sections.
11088 FIXME: Should also check for DWO_* entries in the newlu loaded files. */
11091 check_for_and_load_links (void * file
, const char * filename
)
11093 void * handle
= NULL
;
11095 if (load_debug_section (gnu_debugaltlink
, file
))
11097 Build_id_data build_id_data
;
11099 handle
= load_separate_debug_info (filename
,
11100 & debug_displays
[gnu_debugaltlink
].section
,
11101 parse_gnu_debugaltlink
,
11102 check_gnu_debugaltlink
,
11107 assert (handle
== first_separate_info
->handle
);
11108 check_for_and_load_links (first_separate_info
->handle
,
11109 first_separate_info
->filename
);
11113 if (load_debug_section (gnu_debuglink
, file
))
11115 unsigned long crc32
;
11117 handle
= load_separate_debug_info (filename
,
11118 & debug_displays
[gnu_debuglink
].section
,
11119 parse_gnu_debuglink
,
11120 check_gnu_debuglink
,
11125 assert (handle
== first_separate_info
->handle
);
11126 check_for_and_load_links (first_separate_info
->handle
,
11127 first_separate_info
->filename
);
11132 /* Load the separate debug info file(s) attached to FILE, if any exist.
11133 Returns TRUE if any were found, FALSE otherwise.
11134 If TRUE is returned then the linked list starting at first_separate_info
11135 will be populated with open file handles. */
11138 load_separate_debug_files (void * file
, const char * filename
)
11140 /* Skip this operation if we are not interested in debug links. */
11141 if (! do_follow_links
&& ! do_debug_links
)
11144 /* See if there are any dwo links. */
11145 if (load_debug_section (str
, file
)
11146 && load_debug_section (abbrev
, file
)
11147 && load_debug_section (info
, file
))
11151 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
11153 bfd_boolean introduced
= FALSE
;
11155 const char * dir
= NULL
;
11156 const char * id
= NULL
;
11158 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11160 switch (dwinfo
->type
)
11163 if (do_debug_links
)
11167 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11168 debug_displays
[info
].section
.uncompressed_name
);
11172 printf (_(" Name: %s\n"), dwinfo
->value
);
11173 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11175 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11177 printf (_(" ID: <unknown>\n"));
11181 if (do_follow_links
)
11182 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
11186 dir
= dwinfo
->value
;
11190 id
= dwinfo
->value
;
11194 error (_("Unexpected DWO INFO type"));
11201 if (! do_follow_links
)
11202 /* The other debug links will be displayed by display_debug_links()
11203 so we do not need to do any further processing here. */
11206 /* FIXME: We do not check for the presence of both link sections in the same file. */
11207 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11208 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11210 check_for_and_load_links (file
, filename
);
11211 if (first_separate_info
!= NULL
)
11214 do_follow_links
= 0;
11219 free_debug_memory (void)
11223 free_all_abbrevs ();
11225 free (cu_abbrev_map
);
11226 cu_abbrev_map
= NULL
;
11227 next_free_abbrev_map_entry
= 0;
11229 for (i
= 0; i
< max
; i
++)
11230 free_debug_section ((enum dwarf_section_display_enum
) i
);
11232 if (debug_information
!= NULL
)
11234 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
11236 if (debug_information
[i
].max_loc_offsets
)
11238 free (debug_information
[i
].loc_offsets
);
11239 free (debug_information
[i
].have_frame_base
);
11241 if (debug_information
[i
].max_range_lists
)
11242 free (debug_information
[i
].range_lists
);
11244 free (debug_information
);
11245 debug_information
= NULL
;
11246 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
11250 separate_info
* next
;
11252 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
11254 close_debug_file (d
->handle
);
11255 free ((void *) d
->filename
);
11259 first_separate_info
= NULL
;
11265 dwarf_select_sections_by_names (const char *names
)
11269 const char * option
;
11273 debug_dump_long_opts
;
11275 static const debug_dump_long_opts opts_table
[] =
11277 /* Please keep this table alpha- sorted. */
11278 { "Ranges", & do_debug_ranges
, 1 },
11279 { "abbrev", & do_debug_abbrevs
, 1 },
11280 { "addr", & do_debug_addr
, 1 },
11281 { "aranges", & do_debug_aranges
, 1 },
11282 { "cu_index", & do_debug_cu_index
, 1 },
11283 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
11284 { "follow-links", & do_follow_links
, 1 },
11285 { "frames", & do_debug_frames
, 1 },
11286 { "frames-interp", & do_debug_frames_interp
, 1 },
11287 /* The special .gdb_index section. */
11288 { "gdb_index", & do_gdb_index
, 1 },
11289 { "info", & do_debug_info
, 1 },
11290 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
11291 { "links", & do_debug_links
, 1 },
11292 { "loc", & do_debug_loc
, 1 },
11293 { "macro", & do_debug_macinfo
, 1 },
11294 { "pubnames", & do_debug_pubnames
, 1 },
11295 { "pubtypes", & do_debug_pubtypes
, 1 },
11296 /* This entry is for compatibility
11297 with earlier versions of readelf. */
11298 { "ranges", & do_debug_aranges
, 1 },
11299 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
11300 { "str", & do_debug_str
, 1 },
11301 { "str-offsets", & do_debug_str_offsets
, 1 },
11302 /* These trace_* sections are used by Itanium VMS. */
11303 { "trace_abbrev", & do_trace_abbrevs
, 1 },
11304 { "trace_aranges", & do_trace_aranges
, 1 },
11305 { "trace_info", & do_trace_info
, 1 },
11314 const debug_dump_long_opts
* entry
;
11316 for (entry
= opts_table
; entry
->option
; entry
++)
11318 size_t len
= strlen (entry
->option
);
11320 if (strncmp (p
, entry
->option
, len
) == 0
11321 && (p
[len
] == ',' || p
[len
] == '\0'))
11323 * entry
->variable
|= entry
->val
;
11325 /* The --debug-dump=frames-interp option also
11326 enables the --debug-dump=frames option. */
11327 if (do_debug_frames_interp
)
11328 do_debug_frames
= 1;
11335 if (entry
->option
== NULL
)
11337 warn (_("Unrecognized debug option '%s'\n"), p
);
11338 p
= strchr (p
, ',');
11349 dwarf_select_sections_by_letters (const char *letters
)
11351 unsigned int lindex
= 0;
11353 while (letters
[lindex
])
11354 switch (letters
[lindex
++])
11356 case 'A': do_debug_addr
= 1; break;
11357 case 'a': do_debug_abbrevs
= 1; break;
11358 case 'c': do_debug_cu_index
= 1; break;
11359 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
11360 case 'f': do_debug_frames
= 1; break;
11361 case 'g': do_gdb_index
= 1; break;
11362 case 'i': do_debug_info
= 1; break;
11363 case 'K': do_follow_links
= 1; break;
11364 case 'k': do_debug_links
= 1; break;
11365 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
11366 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
11367 case 'm': do_debug_macinfo
= 1; break;
11368 case 'O': do_debug_str_offsets
= 1; break;
11369 case 'o': do_debug_loc
= 1; break;
11370 case 'p': do_debug_pubnames
= 1; break;
11371 case 'R': do_debug_ranges
= 1; break;
11372 case 'r': do_debug_aranges
= 1; break;
11373 case 's': do_debug_str
= 1; break;
11374 case 'T': do_trace_aranges
= 1; break;
11375 case 't': do_debug_pubtypes
= 1; break;
11376 case 'U': do_trace_info
= 1; break;
11377 case 'u': do_trace_abbrevs
= 1; break;
11380 warn (_("Unrecognized debug option '%s'\n"), letters
);
11386 dwarf_select_sections_all (void)
11389 do_debug_abbrevs
= 1;
11390 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
11391 do_debug_pubnames
= 1;
11392 do_debug_pubtypes
= 1;
11393 do_debug_aranges
= 1;
11394 do_debug_ranges
= 1;
11395 do_debug_frames
= 1;
11396 do_debug_macinfo
= 1;
11401 do_trace_abbrevs
= 1;
11402 do_trace_aranges
= 1;
11404 do_debug_cu_index
= 1;
11405 do_follow_links
= 1;
11406 do_debug_links
= 1;
11407 do_debug_str_offsets
= 1;
11410 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
11411 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
11413 /* N.B. The order here must match the order in section_display_enum. */
11415 struct dwarf_section_display debug_displays
[] =
11417 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
11418 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
11419 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
11420 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
11421 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
11422 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
11423 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
11424 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
11425 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
11426 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
11427 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11428 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11429 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
11430 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
11431 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
11432 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
11433 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
11434 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
11435 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
11436 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
11437 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
11438 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
11439 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
11440 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
11441 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
11442 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
11443 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
11444 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
11445 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
11446 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
11447 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
11448 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
11449 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
11450 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
11451 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
11452 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
11453 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
11454 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
11455 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
11456 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
11457 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
11458 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
11459 /* Separate debug info files can containt their own .debug_str section,
11460 and this might be in *addition* to a .debug_str section already present
11461 in the main file. Hence we need to have two entries for .debug_str. */
11462 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11465 /* A static assertion. */
11466 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];