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 print_dwarf_vma (begin
+ base_address
, pointer_size
);
7536 print_dwarf_vma (end
+ base_address
, pointer_size
);
7539 fputs (_("(start == end)"), stdout
);
7540 else if (begin
> end
)
7541 fputs (_("(start > end)"), stdout
);
7548 display_debug_ranges (struct dwarf_section
*section
,
7549 void *file ATTRIBUTE_UNUSED
)
7551 unsigned char *start
= section
->start
;
7552 unsigned char *last_start
= start
;
7553 unsigned long bytes
= section
->size
;
7554 unsigned char *section_begin
= start
;
7555 unsigned char *finish
= start
+ bytes
;
7556 unsigned int num_range_list
, i
;
7557 struct range_entry
*range_entries
, *range_entry_fill
;
7558 int is_rnglists
= strstr (section
->name
, "debug_rnglists") != NULL
;
7559 /* Initialize it due to a false compiler warning. */
7560 unsigned char address_size
= 0;
7561 dwarf_vma last_offset
= 0;
7565 printf (_("\nThe %s section is empty.\n"), section
->name
);
7571 dwarf_vma initial_length
;
7572 unsigned int initial_length_size
;
7573 unsigned char segment_selector_size
;
7574 unsigned int offset_size
, offset_entry_count
;
7575 unsigned short version
;
7577 /* Get and check the length of the block. */
7578 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 4, finish
);
7580 if (initial_length
== 0xffffffff)
7582 /* This section is 64-bit DWARF 3. */
7583 SAFE_BYTE_GET_AND_INC (initial_length
, start
, 8, finish
);
7585 initial_length_size
= 12;
7590 initial_length_size
= 4;
7593 if (initial_length
+ initial_length_size
> section
->size
)
7595 /* If the length field has a relocation against it, then we should
7596 not complain if it is inaccurate (and probably negative).
7597 It is copied from .debug_line handling code. */
7598 if (reloc_at (section
, (start
- section
->start
) - offset_size
))
7600 initial_length
= (finish
- start
) - initial_length_size
;
7604 warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"),
7605 (long) initial_length
);
7610 /* Get and check the version number. */
7611 SAFE_BYTE_GET_AND_INC (version
, start
, 2, finish
);
7615 warn (_("Only DWARF version 5 debug_rnglists info "
7616 "is currently supported.\n"));
7620 SAFE_BYTE_GET_AND_INC (address_size
, start
, 1, finish
);
7622 SAFE_BYTE_GET_AND_INC (segment_selector_size
, start
, 1, finish
);
7623 if (segment_selector_size
!= 0)
7625 warn (_("The %s section contains "
7626 "unsupported segment selector size: %d.\n"),
7627 section
->name
, segment_selector_size
);
7631 SAFE_BYTE_GET_AND_INC (offset_entry_count
, start
, 4, finish
);
7632 if (offset_entry_count
!= 0)
7634 warn (_("The %s section contains "
7635 "unsupported offset entry count: %u.\n"),
7636 section
->name
, offset_entry_count
);
7641 if (load_debug_info (file
) == 0)
7643 warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"),
7649 for (i
= 0; i
< num_debug_info_entries
; i
++)
7650 num_range_list
+= debug_information
[i
].num_range_lists
;
7652 if (num_range_list
== 0)
7654 /* This can happen when the file was compiled with -gsplit-debug
7655 which removes references to range lists from the primary .o file. */
7656 printf (_("No range lists in .debug_info section.\n"));
7660 range_entries
= (struct range_entry
*)
7661 xmalloc (sizeof (*range_entries
) * num_range_list
);
7662 range_entry_fill
= range_entries
;
7664 for (i
= 0; i
< num_debug_info_entries
; i
++)
7666 debug_info
*debug_info_p
= &debug_information
[i
];
7669 for (j
= 0; j
< debug_info_p
->num_range_lists
; j
++)
7671 range_entry_fill
->ranges_offset
= debug_info_p
->range_lists
[j
];
7672 range_entry_fill
->debug_info_p
= debug_info_p
;
7677 qsort (range_entries
, num_range_list
, sizeof (*range_entries
),
7678 range_entry_compar
);
7680 if (dwarf_check
!= 0 && range_entries
[0].ranges_offset
!= 0)
7681 warn (_("Range lists in %s section start at 0x%lx\n"),
7682 section
->name
, (unsigned long) range_entries
[0].ranges_offset
);
7684 introduce (section
, FALSE
);
7686 printf (_(" Offset Begin End\n"));
7688 for (i
= 0; i
< num_range_list
; i
++)
7690 struct range_entry
*range_entry
= &range_entries
[i
];
7691 debug_info
*debug_info_p
= range_entry
->debug_info_p
;
7692 unsigned int pointer_size
;
7694 unsigned char *next
;
7695 dwarf_vma base_address
;
7697 pointer_size
= (is_rnglists
? address_size
: debug_info_p
->pointer_size
);
7698 offset
= range_entry
->ranges_offset
;
7699 next
= section_begin
+ offset
;
7700 base_address
= debug_info_p
->base_address
;
7702 /* PR 17512: file: 001-101485-0.001:0.1. */
7703 if (pointer_size
< 2 || pointer_size
> 8)
7705 warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"),
7706 pointer_size
, (unsigned long) offset
);
7710 if (next
< section_begin
|| next
>= finish
)
7712 warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"),
7713 (unsigned long) offset
, i
);
7717 /* If multiple DWARF entities reference the same range then we will
7718 have multiple entries in the `range_entries' list for the same
7719 offset. Thanks to the sort above these will all be consecutive in
7720 the `range_entries' list, so we can easily ignore duplicates
7722 if (i
> 0 && last_offset
== offset
)
7724 last_offset
= offset
;
7726 if (dwarf_check
!= 0 && i
> 0)
7729 warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"),
7730 (unsigned long) (start
- section_begin
),
7731 (unsigned long) (next
- section_begin
), section
->name
);
7732 else if (start
> next
)
7734 if (next
== last_start
)
7736 warn (_("There is an overlap [0x%lx - 0x%lx] in %s section.\n"),
7737 (unsigned long) (start
- section_begin
),
7738 (unsigned long) (next
- section_begin
), section
->name
);
7745 (is_rnglists
? display_debug_rnglists_list
: display_debug_ranges_list
)
7746 (start
, finish
, pointer_size
, offset
, base_address
);
7750 free (range_entries
);
7755 typedef struct Frame_Chunk
7757 struct Frame_Chunk
*next
;
7758 unsigned char *chunk_start
;
7760 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7761 short int *col_type
;
7764 unsigned int code_factor
;
7768 unsigned int cfa_reg
;
7769 dwarf_vma cfa_offset
;
7771 unsigned char fde_encoding
;
7772 unsigned char cfa_exp
;
7773 unsigned char ptr_size
;
7774 unsigned char segment_size
;
7778 typedef const char *(*dwarf_regname_lookup_ftype
) (unsigned int);
7779 static dwarf_regname_lookup_ftype dwarf_regnames_lookup_func
;
7780 static const char *const *dwarf_regnames
;
7781 static unsigned int dwarf_regnames_count
;
7784 /* A marker for a col_type that means this column was never referenced
7785 in the frame info. */
7786 #define DW_CFA_unreferenced (-1)
7788 /* Return 0 if no more space is needed, 1 if more space is needed,
7789 -1 for invalid reg. */
7792 frame_need_space (Frame_Chunk
*fc
, unsigned int reg
)
7794 unsigned int prev
= fc
->ncols
;
7796 if (reg
< (unsigned int) fc
->ncols
)
7799 if (dwarf_regnames_count
> 0
7800 && reg
> dwarf_regnames_count
)
7803 fc
->ncols
= reg
+ 1;
7804 /* PR 17512: file: 10450-2643-0.004.
7805 If reg == -1 then this can happen... */
7809 /* PR 17512: file: 2844a11d. */
7810 if (fc
->ncols
> 1024 && dwarf_regnames_count
== 0)
7812 error (_("Unfeasibly large register number: %u\n"), reg
);
7814 /* FIXME: 1024 is an arbitrary limit. Increase it if
7815 we ever encounter a valid binary that exceeds it. */
7819 fc
->col_type
= (short int *) xcrealloc (fc
->col_type
, fc
->ncols
,
7820 sizeof (short int));
7821 fc
->col_offset
= (int *) xcrealloc (fc
->col_offset
, fc
->ncols
, sizeof (int));
7822 /* PR 17512: file:002-10025-0.005. */
7823 if (fc
->col_type
== NULL
|| fc
->col_offset
== NULL
)
7825 error (_("Out of memory allocating %u columns in dwarf frame arrays\n"),
7831 while (prev
< fc
->ncols
)
7833 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7834 fc
->col_offset
[prev
] = 0;
7840 static const char *const dwarf_regnames_i386
[] =
7842 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7843 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7844 "eip", "eflags", NULL
, /* 8 - 10 */
7845 "st0", "st1", "st2", "st3", /* 11 - 14 */
7846 "st4", "st5", "st6", "st7", /* 15 - 18 */
7847 NULL
, NULL
, /* 19 - 20 */
7848 "xmm0", "xmm1", "xmm2", "xmm3", /* 21 - 24 */
7849 "xmm4", "xmm5", "xmm6", "xmm7", /* 25 - 28 */
7850 "mm0", "mm1", "mm2", "mm3", /* 29 - 32 */
7851 "mm4", "mm5", "mm6", "mm7", /* 33 - 36 */
7852 "fcw", "fsw", "mxcsr", /* 37 - 39 */
7853 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7854 "tr", "ldtr", /* 48 - 49 */
7855 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7856 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7857 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7858 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7859 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7860 NULL
, NULL
, NULL
, /* 90 - 92 */
7861 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */
7864 static const char *const dwarf_regnames_iamcu
[] =
7866 "eax", "ecx", "edx", "ebx", /* 0 - 3 */
7867 "esp", "ebp", "esi", "edi", /* 4 - 7 */
7868 "eip", "eflags", NULL
, /* 8 - 10 */
7869 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 11 - 18 */
7870 NULL
, NULL
, /* 19 - 20 */
7871 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 21 - 28 */
7872 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 29 - 36 */
7873 NULL
, NULL
, NULL
, /* 37 - 39 */
7874 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
, /* 40 - 47 */
7875 "tr", "ldtr", /* 48 - 49 */
7876 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 50 - 57 */
7877 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 58 - 65 */
7878 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 66 - 73 */
7879 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 74 - 81 */
7880 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 82 - 89 */
7881 NULL
, NULL
, NULL
, /* 90 - 92 */
7882 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
/* 93 - 100 */
7886 init_dwarf_regnames_i386 (void)
7888 dwarf_regnames
= dwarf_regnames_i386
;
7889 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_i386
);
7890 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7894 init_dwarf_regnames_iamcu (void)
7896 dwarf_regnames
= dwarf_regnames_iamcu
;
7897 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_iamcu
);
7898 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7901 static const char *const dwarf_regnames_x86_64
[] =
7903 "rax", "rdx", "rcx", "rbx",
7904 "rsi", "rdi", "rbp", "rsp",
7905 "r8", "r9", "r10", "r11",
7906 "r12", "r13", "r14", "r15",
7908 "xmm0", "xmm1", "xmm2", "xmm3",
7909 "xmm4", "xmm5", "xmm6", "xmm7",
7910 "xmm8", "xmm9", "xmm10", "xmm11",
7911 "xmm12", "xmm13", "xmm14", "xmm15",
7912 "st0", "st1", "st2", "st3",
7913 "st4", "st5", "st6", "st7",
7914 "mm0", "mm1", "mm2", "mm3",
7915 "mm4", "mm5", "mm6", "mm7",
7917 "es", "cs", "ss", "ds", "fs", "gs", NULL
, NULL
,
7918 "fs.base", "gs.base", NULL
, NULL
,
7920 "mxcsr", "fcw", "fsw",
7921 "xmm16", "xmm17", "xmm18", "xmm19",
7922 "xmm20", "xmm21", "xmm22", "xmm23",
7923 "xmm24", "xmm25", "xmm26", "xmm27",
7924 "xmm28", "xmm29", "xmm30", "xmm31",
7925 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 83 - 90 */
7926 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 91 - 98 */
7927 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 99 - 106 */
7928 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, /* 107 - 114 */
7929 NULL
, NULL
, NULL
, /* 115 - 117 */
7930 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
7934 init_dwarf_regnames_x86_64 (void)
7936 dwarf_regnames
= dwarf_regnames_x86_64
;
7937 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_x86_64
);
7938 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7941 static const char *const dwarf_regnames_aarch64
[] =
7943 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
7944 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
7945 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
7946 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp",
7947 NULL
, "elr", NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7948 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, "vg", "ffr",
7949 "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7",
7950 "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15",
7951 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
7952 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
7953 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
7954 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
7955 "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7",
7956 "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15",
7957 "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23",
7958 "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31",
7962 init_dwarf_regnames_aarch64 (void)
7964 dwarf_regnames
= dwarf_regnames_aarch64
;
7965 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_aarch64
);
7966 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7969 static const char *const dwarf_regnames_s390
[] =
7971 /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */
7972 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7973 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
7974 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7975 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15",
7976 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
7977 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
7978 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
7979 "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
7982 "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23",
7983 "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31",
7987 init_dwarf_regnames_s390 (void)
7989 dwarf_regnames
= dwarf_regnames_s390
;
7990 dwarf_regnames_count
= ARRAY_SIZE (dwarf_regnames_s390
);
7991 dwarf_regnames_lookup_func
= regname_internal_by_table_only
;
7994 static const char *const dwarf_regnames_riscv
[] =
7996 "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */
7997 "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */
7998 "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */
7999 "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */
8000 "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */
8001 "fs0", "fs1", /* 40 - 41 */
8002 "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */
8003 "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */
8004 "fs10", "fs11", /* 58 - 59 */
8005 "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */
8008 /* A RISC-V replacement for REGNAME_INTERNAL_BY_TABLE_ONLY which handles
8009 the large number of CSRs. */
8012 regname_internal_riscv (unsigned int regno
)
8014 const char *name
= NULL
;
8016 /* Lookup in the table first, this covers GPR and FPR. */
8017 if (regno
< ARRAY_SIZE (dwarf_regnames_riscv
))
8018 name
= dwarf_regnames_riscv
[regno
];
8019 else if (regno
>= 4096 && regno
<= 8191)
8021 /* This might be a CSR, these live in a sparse number space from 4096
8022 to 8191 These numbers are defined in the RISC-V ELF ABI
8026 #define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
8027 case VALUE + 4096: name = #NAME; break;
8028 #include "opcode/riscv-opc.h"
8033 static char csr_name
[10];
8034 snprintf (csr_name
, sizeof (csr_name
), "csr%d", (regno
- 4096));
8045 init_dwarf_regnames_riscv (void)
8047 dwarf_regnames
= NULL
;
8048 dwarf_regnames_count
= 8192;
8049 dwarf_regnames_lookup_func
= regname_internal_riscv
;
8053 init_dwarf_regnames_by_elf_machine_code (unsigned int e_machine
)
8055 dwarf_regnames_lookup_func
= NULL
;
8060 init_dwarf_regnames_i386 ();
8064 init_dwarf_regnames_iamcu ();
8070 init_dwarf_regnames_x86_64 ();
8074 init_dwarf_regnames_aarch64 ();
8078 init_dwarf_regnames_s390 ();
8082 init_dwarf_regnames_riscv ();
8090 /* Initialize the DWARF register name lookup state based on the
8091 architecture and specific machine type of a BFD. */
8094 init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch
,
8097 dwarf_regnames_lookup_func
= NULL
;
8104 case bfd_mach_x86_64
:
8105 case bfd_mach_x86_64_intel_syntax
:
8106 case bfd_mach_x64_32
:
8107 case bfd_mach_x64_32_intel_syntax
:
8108 init_dwarf_regnames_x86_64 ();
8112 init_dwarf_regnames_i386 ();
8117 case bfd_arch_iamcu
:
8118 init_dwarf_regnames_iamcu ();
8121 case bfd_arch_aarch64
:
8122 init_dwarf_regnames_aarch64();
8126 init_dwarf_regnames_s390 ();
8129 case bfd_arch_riscv
:
8130 init_dwarf_regnames_riscv ();
8139 regname_internal_by_table_only (unsigned int regno
)
8141 if (dwarf_regnames
!= NULL
8142 && regno
< dwarf_regnames_count
8143 && dwarf_regnames
[regno
] != NULL
)
8144 return dwarf_regnames
[regno
];
8150 regname (unsigned int regno
, int name_only_p
)
8152 static char reg
[64];
8154 const char *name
= NULL
;
8156 if (dwarf_regnames_lookup_func
!= NULL
)
8157 name
= dwarf_regnames_lookup_func (regno
);
8163 snprintf (reg
, sizeof (reg
), "r%d (%s)", regno
, name
);
8166 snprintf (reg
, sizeof (reg
), "r%d", regno
);
8171 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, unsigned int *max_regs
)
8176 if (*max_regs
!= fc
->ncols
)
8177 *max_regs
= fc
->ncols
;
8179 if (*need_col_headers
)
8181 static const char *sloc
= " LOC";
8183 *need_col_headers
= 0;
8185 printf ("%-*s CFA ", eh_addr_size
* 2, sloc
);
8187 for (r
= 0; r
< *max_regs
; r
++)
8188 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8193 printf ("%-5s ", regname (r
, 1));
8199 print_dwarf_vma (fc
->pc_begin
, eh_addr_size
);
8201 strcpy (tmp
, "exp");
8203 sprintf (tmp
, "%s%+d", regname (fc
->cfa_reg
, 1), (int) fc
->cfa_offset
);
8204 printf ("%-8s ", tmp
);
8206 for (r
= 0; r
< fc
->ncols
; r
++)
8208 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8210 switch (fc
->col_type
[r
])
8212 case DW_CFA_undefined
:
8215 case DW_CFA_same_value
:
8219 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8221 case DW_CFA_val_offset
:
8222 sprintf (tmp
, "v%+d", fc
->col_offset
[r
]);
8224 case DW_CFA_register
:
8225 sprintf (tmp
, "%s", regname (fc
->col_offset
[r
], 0));
8227 case DW_CFA_expression
:
8228 strcpy (tmp
, "exp");
8230 case DW_CFA_val_expression
:
8231 strcpy (tmp
, "vexp");
8234 strcpy (tmp
, "n/a");
8237 printf ("%-5s ", tmp
);
8243 #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end)
8245 static unsigned char *
8246 read_cie (unsigned char *start
, unsigned char *end
,
8247 Frame_Chunk
**p_cie
, int *p_version
,
8248 bfd_size_type
*p_aug_len
, unsigned char **p_aug
)
8252 unsigned char *augmentation_data
= NULL
;
8253 bfd_size_type augmentation_data_len
= 0;
8256 /* PR 17512: file: 001-228113-0.004. */
8260 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8261 memset (fc
, 0, sizeof (Frame_Chunk
));
8263 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8264 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8268 fc
->augmentation
= (char *) start
;
8269 /* PR 17512: file: 001-228113-0.004.
8270 Skip past augmentation name, but avoid running off the end of the data. */
8272 if (* start
++ == '\0')
8276 warn (_("No terminator for augmentation name\n"));
8280 if (strcmp (fc
->augmentation
, "eh") == 0)
8281 start
+= eh_addr_size
;
8285 GET (fc
->ptr_size
, 1);
8286 if (fc
->ptr_size
< 1 || fc
->ptr_size
> 8)
8288 warn (_("Invalid pointer size (%d) in CIE data\n"), fc
->ptr_size
);
8292 GET (fc
->segment_size
, 1);
8293 /* PR 17512: file: e99d2804. */
8294 if (fc
->segment_size
> 8 || fc
->segment_size
+ fc
->ptr_size
> 8)
8296 warn (_("Invalid segment size (%d) in CIE data\n"), fc
->segment_size
);
8300 eh_addr_size
= fc
->ptr_size
;
8304 fc
->ptr_size
= eh_addr_size
;
8305 fc
->segment_size
= 0;
8308 READ_ULEB (fc
->code_factor
, start
, end
);
8309 READ_SLEB (fc
->data_factor
, start
, end
);
8317 READ_ULEB (fc
->ra
, start
, end
);
8320 if (fc
->augmentation
[0] == 'z')
8322 READ_ULEB (augmentation_data_len
, start
, end
);
8323 augmentation_data
= start
;
8324 /* PR 17512: file: 11042-2589-0.004. */
8325 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8327 warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"),
8328 dwarf_vmatoa ("x", augmentation_data_len
),
8329 (unsigned long) (end
- start
));
8332 start
+= augmentation_data_len
;
8335 if (augmentation_data_len
)
8339 unsigned char *qend
;
8341 p
= (unsigned char *) fc
->augmentation
+ 1;
8342 q
= augmentation_data
;
8343 qend
= q
+ augmentation_data_len
;
8345 while (p
< end
&& q
< qend
)
8350 q
+= 1 + size_of_encoded_value (*q
);
8352 fc
->fde_encoding
= *q
++;
8361 /* Note - it is OK if this loop terminates with q < qend.
8362 Padding may have been inserted to align the end of the CIE. */
8367 *p_version
= version
;
8370 *p_aug_len
= augmentation_data_len
;
8371 *p_aug
= augmentation_data
;
8376 free (fc
->col_offset
);
8377 free (fc
->col_type
);
8382 /* Prints out the contents on the DATA array formatted as unsigned bytes.
8383 If do_wide is not enabled, then formats the output to fit into 80 columns.
8384 PRINTED contains the number of characters already written to the current
8388 display_data (bfd_size_type printed
,
8389 const unsigned char * data
,
8390 const bfd_size_type len
)
8392 if (do_wide
|| len
< ((80 - printed
) / 3))
8393 for (printed
= 0; printed
< len
; ++printed
)
8394 printf (" %02x", data
[printed
]);
8397 for (printed
= 0; printed
< len
; ++printed
)
8399 if (printed
% (80 / 3) == 0)
8401 printf (" %02x", data
[printed
]);
8406 /* Prints out the contents on the augmentation data array.
8407 If do_wide is not enabled, then formats the output to fit into 80 columns. */
8410 display_augmentation_data (const unsigned char * data
, const bfd_size_type len
)
8414 i
= printf (_(" Augmentation data: "));
8415 display_data (i
, data
, len
);
8419 display_debug_frames (struct dwarf_section
*section
,
8420 void *file ATTRIBUTE_UNUSED
)
8422 unsigned char *start
= section
->start
;
8423 unsigned char *end
= start
+ section
->size
;
8424 unsigned char *section_start
= start
;
8425 Frame_Chunk
*chunks
= NULL
, *forward_refs
= NULL
;
8426 Frame_Chunk
*remembered_state
= NULL
;
8428 bfd_boolean is_eh
= strcmp (section
->name
, ".eh_frame") == 0;
8429 unsigned int max_regs
= 0;
8430 const char *bad_reg
= _("bad register: ");
8431 unsigned int saved_eh_addr_size
= eh_addr_size
;
8433 introduce (section
, FALSE
);
8437 unsigned char *saved_start
;
8438 unsigned char *block_end
;
8443 int need_col_headers
= 1;
8444 unsigned char *augmentation_data
= NULL
;
8445 bfd_size_type augmentation_data_len
= 0;
8446 unsigned int encoded_ptr_size
= saved_eh_addr_size
;
8447 unsigned int offset_size
;
8448 unsigned int initial_length_size
;
8449 bfd_boolean all_nops
;
8450 static Frame_Chunk fde_fc
;
8452 saved_start
= start
;
8454 SAFE_BYTE_GET_AND_INC (length
, start
, 4, end
);
8458 printf ("\n%08lx ZERO terminator\n\n",
8459 (unsigned long)(saved_start
- section_start
));
8460 /* Skip any zero terminators that directly follow.
8461 A corrupt section size could have loaded a whole
8462 slew of zero filled memory bytes. eg
8463 PR 17512: file: 070-19381-0.004. */
8464 while (start
< end
&& * start
== 0)
8469 if (length
== 0xffffffff)
8471 SAFE_BYTE_GET_AND_INC (length
, start
, 8, end
);
8473 initial_length_size
= 12;
8478 initial_length_size
= 4;
8481 block_end
= saved_start
+ length
+ initial_length_size
;
8482 if (block_end
> end
|| block_end
< start
)
8484 warn ("Invalid length 0x%s in FDE at %#08lx\n",
8485 dwarf_vmatoa_1 (NULL
, length
, offset_size
),
8486 (unsigned long) (saved_start
- section_start
));
8490 SAFE_BYTE_GET_AND_INC (cie_id
, start
, offset_size
, end
);
8492 if (is_eh
? (cie_id
== 0) : ((offset_size
== 4 && cie_id
== DW_CIE_ID
)
8493 || (offset_size
== 8 && cie_id
== DW64_CIE_ID
)))
8498 start
= read_cie (start
, end
, &cie
, &version
,
8499 &augmentation_data_len
, &augmentation_data
);
8500 /* PR 17512: file: 027-135133-0.005. */
8507 fc
->chunk_start
= saved_start
;
8508 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8511 if (frame_need_space (fc
, mreg
) < 0)
8513 if (fc
->fde_encoding
)
8514 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8516 printf ("\n%08lx ", (unsigned long) (saved_start
- section_start
));
8517 print_dwarf_vma (length
, fc
->ptr_size
);
8518 print_dwarf_vma (cie_id
, offset_size
);
8520 if (do_debug_frames_interp
)
8522 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n", fc
->augmentation
,
8523 fc
->code_factor
, fc
->data_factor
, fc
->ra
);
8528 printf (" Version: %d\n", version
);
8529 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8532 printf (" Pointer Size: %u\n", fc
->ptr_size
);
8533 printf (" Segment Size: %u\n", fc
->segment_size
);
8535 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8536 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8537 printf (" Return address column: %d\n", fc
->ra
);
8539 if (augmentation_data_len
)
8540 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8547 unsigned char *look_for
;
8548 unsigned long segment_selector
;
8552 dwarf_vma sign
= (dwarf_vma
) 1 << (offset_size
* 8 - 1);
8553 look_for
= start
- 4 - ((cie_id
^ sign
) - sign
);
8556 look_for
= section_start
+ cie_id
;
8558 if (look_for
<= saved_start
)
8560 for (cie
= chunks
; cie
; cie
= cie
->next
)
8561 if (cie
->chunk_start
== look_for
)
8566 for (cie
= forward_refs
; cie
; cie
= cie
->next
)
8567 if (cie
->chunk_start
== look_for
)
8571 unsigned int off_size
;
8572 unsigned char *cie_scan
;
8574 cie_scan
= look_for
;
8576 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 4, end
);
8577 if (length
== 0xffffffff)
8579 SAFE_BYTE_GET_AND_INC (length
, cie_scan
, 8, end
);
8586 SAFE_BYTE_GET_AND_INC (c_id
, cie_scan
, off_size
, end
);
8589 : ((off_size
== 4 && c_id
== DW_CIE_ID
)
8590 || (off_size
== 8 && c_id
== DW64_CIE_ID
)))
8595 read_cie (cie_scan
, end
, &cie
, &version
,
8596 &augmentation_data_len
, &augmentation_data
);
8597 /* PR 17512: file: 3450-2098-0.004. */
8600 warn (_("Failed to read CIE information\n"));
8603 cie
->next
= forward_refs
;
8605 cie
->chunk_start
= look_for
;
8606 mreg
= max_regs
> 0 ? max_regs
- 1 : 0;
8609 if (frame_need_space (cie
, mreg
) < 0)
8611 warn (_("Invalid max register\n"));
8614 if (cie
->fde_encoding
)
8616 = size_of_encoded_value (cie
->fde_encoding
);
8623 memset (fc
, 0, sizeof (Frame_Chunk
));
8627 warn ("Invalid CIE pointer 0x%s in FDE at %#08lx\n",
8628 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8629 (unsigned long) (saved_start
- section_start
));
8631 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8632 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8633 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1 : 0) < 0)
8635 warn (_("Invalid max register\n"));
8639 fc
->augmentation
= "";
8640 fc
->fde_encoding
= 0;
8641 fc
->ptr_size
= eh_addr_size
;
8642 fc
->segment_size
= 0;
8646 fc
->ncols
= cie
->ncols
;
8647 fc
->col_type
= (short int *) xcmalloc (fc
->ncols
, sizeof (short int));
8648 fc
->col_offset
= (int *) xcmalloc (fc
->ncols
, sizeof (int));
8649 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8650 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8651 fc
->augmentation
= cie
->augmentation
;
8652 fc
->ptr_size
= cie
->ptr_size
;
8653 eh_addr_size
= cie
->ptr_size
;
8654 fc
->segment_size
= cie
->segment_size
;
8655 fc
->code_factor
= cie
->code_factor
;
8656 fc
->data_factor
= cie
->data_factor
;
8657 fc
->cfa_reg
= cie
->cfa_reg
;
8658 fc
->cfa_offset
= cie
->cfa_offset
;
8660 if (frame_need_space (fc
, max_regs
> 0 ? max_regs
- 1: 0) < 0)
8662 warn (_("Invalid max register\n"));
8665 fc
->fde_encoding
= cie
->fde_encoding
;
8668 if (fc
->fde_encoding
)
8669 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8671 segment_selector
= 0;
8672 if (fc
->segment_size
)
8674 if (fc
->segment_size
> sizeof (segment_selector
))
8676 /* PR 17512: file: 9e196b3e. */
8677 warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc
->segment_size
);
8678 fc
->segment_size
= 4;
8680 SAFE_BYTE_GET_AND_INC (segment_selector
, start
, fc
->segment_size
, end
);
8683 fc
->pc_begin
= get_encoded_value (&start
, fc
->fde_encoding
, section
, end
);
8685 /* FIXME: It appears that sometimes the final pc_range value is
8686 encoded in less than encoded_ptr_size bytes. See the x86_64
8687 run of the "objcopy on compressed debug sections" test for an
8689 SAFE_BYTE_GET_AND_INC (fc
->pc_range
, start
, encoded_ptr_size
, end
);
8691 if (cie
->augmentation
[0] == 'z')
8693 READ_ULEB (augmentation_data_len
, start
, end
);
8694 augmentation_data
= start
;
8695 /* PR 17512 file: 722-8446-0.004 and PR 22386. */
8696 if (augmentation_data_len
> (bfd_size_type
) (end
- start
))
8698 warn (_("Augmentation data too long: 0x%s, "
8699 "expected at most %#lx\n"),
8700 dwarf_vmatoa ("x", augmentation_data_len
),
8701 (unsigned long) (end
- start
));
8703 augmentation_data
= NULL
;
8704 augmentation_data_len
= 0;
8706 start
+= augmentation_data_len
;
8709 printf ("\n%08lx %s %s FDE cie=%08lx pc=",
8710 (unsigned long)(saved_start
- section_start
),
8711 dwarf_vmatoa_1 (NULL
, length
, fc
->ptr_size
),
8712 dwarf_vmatoa_1 (NULL
, cie_id
, offset_size
),
8713 (unsigned long)(cie
->chunk_start
- section_start
));
8715 if (fc
->segment_size
)
8716 printf ("%04lx:", segment_selector
);
8719 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
, fc
->ptr_size
),
8720 dwarf_vmatoa_1 (NULL
, fc
->pc_begin
+ fc
->pc_range
, fc
->ptr_size
));
8722 if (! do_debug_frames_interp
&& augmentation_data_len
)
8724 display_augmentation_data (augmentation_data
, augmentation_data_len
);
8729 /* At this point, fc is the current chunk, cie (if any) is set, and
8730 we're about to interpret instructions for the chunk. */
8731 /* ??? At present we need to do this always, since this sizes the
8732 fc->col_type and fc->col_offset arrays, which we write into always.
8733 We should probably split the interpreted and non-interpreted bits
8734 into two different routines, since there's so much that doesn't
8735 really overlap between them. */
8736 if (1 || do_debug_frames_interp
)
8738 /* Start by making a pass over the chunk, allocating storage
8739 and taking note of what registers are used. */
8740 unsigned char *tmp
= start
;
8742 while (start
< block_end
)
8744 unsigned int reg
, op
, opa
;
8746 unsigned char * new_start
;
8753 /* Warning: if you add any more cases to this switch, be
8754 sure to add them to the corresponding switch below. */
8757 case DW_CFA_advance_loc
:
8760 SKIP_ULEB (start
, end
);
8761 if (frame_need_space (fc
, opa
) >= 0)
8762 fc
->col_type
[opa
] = DW_CFA_undefined
;
8764 case DW_CFA_restore
:
8765 if (frame_need_space (fc
, opa
) >= 0)
8766 fc
->col_type
[opa
] = DW_CFA_undefined
;
8768 case DW_CFA_set_loc
:
8769 start
+= encoded_ptr_size
;
8771 case DW_CFA_advance_loc1
:
8774 case DW_CFA_advance_loc2
:
8777 case DW_CFA_advance_loc4
:
8780 case DW_CFA_offset_extended
:
8781 case DW_CFA_val_offset
:
8782 READ_ULEB (reg
, start
, end
);
8783 SKIP_ULEB (start
, end
);
8784 if (frame_need_space (fc
, reg
) >= 0)
8785 fc
->col_type
[reg
] = DW_CFA_undefined
;
8787 case DW_CFA_restore_extended
:
8788 READ_ULEB (reg
, start
, end
);
8789 if (frame_need_space (fc
, reg
) >= 0)
8790 fc
->col_type
[reg
] = DW_CFA_undefined
;
8792 case DW_CFA_undefined
:
8793 READ_ULEB (reg
, start
, end
);
8794 if (frame_need_space (fc
, reg
) >= 0)
8795 fc
->col_type
[reg
] = DW_CFA_undefined
;
8797 case DW_CFA_same_value
:
8798 READ_ULEB (reg
, start
, end
);
8799 if (frame_need_space (fc
, reg
) >= 0)
8800 fc
->col_type
[reg
] = DW_CFA_undefined
;
8802 case DW_CFA_register
:
8803 READ_ULEB (reg
, start
, end
);
8804 SKIP_ULEB (start
, end
);
8805 if (frame_need_space (fc
, reg
) >= 0)
8806 fc
->col_type
[reg
] = DW_CFA_undefined
;
8808 case DW_CFA_def_cfa
:
8809 SKIP_ULEB (start
, end
);
8810 SKIP_ULEB (start
, end
);
8812 case DW_CFA_def_cfa_register
:
8813 SKIP_ULEB (start
, end
);
8815 case DW_CFA_def_cfa_offset
:
8816 SKIP_ULEB (start
, end
);
8818 case DW_CFA_def_cfa_expression
:
8819 READ_ULEB (temp
, start
, end
);
8820 new_start
= start
+ temp
;
8821 if (new_start
< start
)
8823 warn (_("Corrupt CFA_def expression value: %lu\n"), temp
);
8829 case DW_CFA_expression
:
8830 case DW_CFA_val_expression
:
8831 READ_ULEB (reg
, start
, end
);
8832 READ_ULEB (temp
, start
, end
);
8833 new_start
= start
+ temp
;
8834 if (new_start
< start
)
8836 /* PR 17512: file:306-192417-0.005. */
8837 warn (_("Corrupt CFA expression value: %lu\n"), temp
);
8842 if (frame_need_space (fc
, reg
) >= 0)
8843 fc
->col_type
[reg
] = DW_CFA_undefined
;
8845 case DW_CFA_offset_extended_sf
:
8846 case DW_CFA_val_offset_sf
:
8847 READ_ULEB (reg
, start
, end
);
8848 SKIP_SLEB (start
, end
);
8849 if (frame_need_space (fc
, reg
) >= 0)
8850 fc
->col_type
[reg
] = DW_CFA_undefined
;
8852 case DW_CFA_def_cfa_sf
:
8853 SKIP_ULEB (start
, end
);
8854 SKIP_SLEB (start
, end
);
8856 case DW_CFA_def_cfa_offset_sf
:
8857 SKIP_SLEB (start
, end
);
8859 case DW_CFA_MIPS_advance_loc8
:
8862 case DW_CFA_GNU_args_size
:
8863 SKIP_ULEB (start
, end
);
8865 case DW_CFA_GNU_negative_offset_extended
:
8866 READ_ULEB (reg
, start
, end
);
8867 SKIP_ULEB (start
, end
);
8868 if (frame_need_space (fc
, reg
) >= 0)
8869 fc
->col_type
[reg
] = DW_CFA_undefined
;
8880 /* Now we know what registers are used, make a second pass over
8881 the chunk, this time actually printing out the info. */
8883 while (start
< block_end
)
8885 unsigned char * tmp
;
8887 unsigned long ul
, roffs
;
8888 /* Note: It is tempting to use an unsigned long for 'reg' but there
8889 are various functions, notably frame_space_needed() that assume that
8890 reg is an unsigned int. */
8895 const char *reg_prefix
= "";
8902 /* Make a note if something other than DW_CFA_nop happens. */
8903 if (op
!= DW_CFA_nop
)
8906 /* Warning: if you add any more cases to this switch, be
8907 sure to add them to the corresponding switch above. */
8910 case DW_CFA_advance_loc
:
8911 if (do_debug_frames_interp
)
8912 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8914 printf (" DW_CFA_advance_loc: %d to %s\n",
8915 opa
* fc
->code_factor
,
8916 dwarf_vmatoa_1 (NULL
,
8917 fc
->pc_begin
+ opa
* fc
->code_factor
,
8919 fc
->pc_begin
+= opa
* fc
->code_factor
;
8923 READ_ULEB (roffs
, start
, end
);
8924 if (opa
>= (unsigned int) fc
->ncols
)
8925 reg_prefix
= bad_reg
;
8926 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8927 printf (" DW_CFA_offset: %s%s at cfa%+ld\n",
8928 reg_prefix
, regname (opa
, 0),
8929 roffs
* fc
->data_factor
);
8930 if (*reg_prefix
== '\0')
8932 fc
->col_type
[opa
] = DW_CFA_offset
;
8933 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8937 case DW_CFA_restore
:
8938 if (opa
>= (unsigned int) fc
->ncols
)
8939 reg_prefix
= bad_reg
;
8940 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
8941 printf (" DW_CFA_restore: %s%s\n",
8942 reg_prefix
, regname (opa
, 0));
8943 if (*reg_prefix
!= '\0')
8946 if (opa
>= (unsigned int) cie
->ncols
8947 || (do_debug_frames_interp
8948 && cie
->col_type
[opa
] == DW_CFA_unreferenced
))
8950 fc
->col_type
[opa
] = DW_CFA_undefined
;
8951 fc
->col_offset
[opa
] = 0;
8955 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8956 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8960 case DW_CFA_set_loc
:
8961 vma
= get_encoded_value (&start
, fc
->fde_encoding
, section
, block_end
);
8962 if (do_debug_frames_interp
)
8963 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8965 printf (" DW_CFA_set_loc: %s\n",
8966 dwarf_vmatoa_1 (NULL
, vma
, fc
->ptr_size
));
8970 case DW_CFA_advance_loc1
:
8971 SAFE_BYTE_GET_AND_INC (ofs
, start
, 1, end
);
8972 if (do_debug_frames_interp
)
8973 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8975 printf (" DW_CFA_advance_loc1: %ld to %s\n",
8976 (unsigned long) (ofs
* fc
->code_factor
),
8977 dwarf_vmatoa_1 (NULL
,
8978 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8980 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8983 case DW_CFA_advance_loc2
:
8984 SAFE_BYTE_GET_AND_INC (ofs
, start
, 2, block_end
);
8985 if (do_debug_frames_interp
)
8986 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8988 printf (" DW_CFA_advance_loc2: %ld to %s\n",
8989 (unsigned long) (ofs
* fc
->code_factor
),
8990 dwarf_vmatoa_1 (NULL
,
8991 fc
->pc_begin
+ ofs
* fc
->code_factor
,
8993 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8996 case DW_CFA_advance_loc4
:
8997 SAFE_BYTE_GET_AND_INC (ofs
, start
, 4, block_end
);
8998 if (do_debug_frames_interp
)
8999 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9001 printf (" DW_CFA_advance_loc4: %ld to %s\n",
9002 (unsigned long) (ofs
* fc
->code_factor
),
9003 dwarf_vmatoa_1 (NULL
,
9004 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9006 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9009 case DW_CFA_offset_extended
:
9010 READ_ULEB (reg
, start
, end
);
9011 READ_ULEB (roffs
, start
, end
);
9012 if (reg
>= (unsigned int) fc
->ncols
)
9013 reg_prefix
= bad_reg
;
9014 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9015 printf (" DW_CFA_offset_extended: %s%s at cfa%+ld\n",
9016 reg_prefix
, regname (reg
, 0),
9017 roffs
* fc
->data_factor
);
9018 if (*reg_prefix
== '\0')
9020 fc
->col_type
[reg
] = DW_CFA_offset
;
9021 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9025 case DW_CFA_val_offset
:
9026 READ_ULEB (reg
, start
, end
);
9027 READ_ULEB (roffs
, start
, end
);
9028 if (reg
>= (unsigned int) fc
->ncols
)
9029 reg_prefix
= bad_reg
;
9030 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9031 printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n",
9032 reg_prefix
, regname (reg
, 0),
9033 roffs
* fc
->data_factor
);
9034 if (*reg_prefix
== '\0')
9036 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9037 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9041 case DW_CFA_restore_extended
:
9042 READ_ULEB (reg
, start
, end
);
9043 if (reg
>= (unsigned int) fc
->ncols
)
9044 reg_prefix
= bad_reg
;
9045 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9046 printf (" DW_CFA_restore_extended: %s%s\n",
9047 reg_prefix
, regname (reg
, 0));
9048 if (*reg_prefix
!= '\0')
9051 if (reg
>= (unsigned int) cie
->ncols
)
9053 fc
->col_type
[reg
] = DW_CFA_undefined
;
9054 fc
->col_offset
[reg
] = 0;
9058 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9059 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9063 case DW_CFA_undefined
:
9064 READ_ULEB (reg
, start
, end
);
9065 if (reg
>= (unsigned int) fc
->ncols
)
9066 reg_prefix
= bad_reg
;
9067 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9068 printf (" DW_CFA_undefined: %s%s\n",
9069 reg_prefix
, regname (reg
, 0));
9070 if (*reg_prefix
== '\0')
9072 fc
->col_type
[reg
] = DW_CFA_undefined
;
9073 fc
->col_offset
[reg
] = 0;
9077 case DW_CFA_same_value
:
9078 READ_ULEB (reg
, start
, end
);
9079 if (reg
>= (unsigned int) fc
->ncols
)
9080 reg_prefix
= bad_reg
;
9081 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9082 printf (" DW_CFA_same_value: %s%s\n",
9083 reg_prefix
, regname (reg
, 0));
9084 if (*reg_prefix
== '\0')
9086 fc
->col_type
[reg
] = DW_CFA_same_value
;
9087 fc
->col_offset
[reg
] = 0;
9091 case DW_CFA_register
:
9092 READ_ULEB (reg
, start
, end
);
9093 READ_ULEB (roffs
, start
, end
);
9094 if (reg
>= (unsigned int) fc
->ncols
)
9095 reg_prefix
= bad_reg
;
9096 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9098 printf (" DW_CFA_register: %s%s in ",
9099 reg_prefix
, regname (reg
, 0));
9100 puts (regname (roffs
, 0));
9102 if (*reg_prefix
== '\0')
9104 fc
->col_type
[reg
] = DW_CFA_register
;
9105 fc
->col_offset
[reg
] = roffs
;
9109 case DW_CFA_remember_state
:
9110 if (! do_debug_frames_interp
)
9111 printf (" DW_CFA_remember_state\n");
9112 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
9113 rs
->cfa_offset
= fc
->cfa_offset
;
9114 rs
->cfa_reg
= fc
->cfa_reg
;
9116 rs
->cfa_exp
= fc
->cfa_exp
;
9117 rs
->ncols
= fc
->ncols
;
9118 rs
->col_type
= (short int *) xcmalloc (rs
->ncols
,
9119 sizeof (* rs
->col_type
));
9120 rs
->col_offset
= (int *) xcmalloc (rs
->ncols
, sizeof (* rs
->col_offset
));
9121 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
* sizeof (* fc
->col_type
));
9122 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (* fc
->col_offset
));
9123 rs
->next
= remembered_state
;
9124 remembered_state
= rs
;
9127 case DW_CFA_restore_state
:
9128 if (! do_debug_frames_interp
)
9129 printf (" DW_CFA_restore_state\n");
9130 rs
= remembered_state
;
9133 remembered_state
= rs
->next
;
9134 fc
->cfa_offset
= rs
->cfa_offset
;
9135 fc
->cfa_reg
= rs
->cfa_reg
;
9137 fc
->cfa_exp
= rs
->cfa_exp
;
9138 if (frame_need_space (fc
, rs
->ncols
- 1) < 0)
9140 warn (_("Invalid column number in saved frame state\n"));
9144 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
* sizeof (* rs
->col_type
));
9145 memcpy (fc
->col_offset
, rs
->col_offset
,
9146 rs
->ncols
* sizeof (* rs
->col_offset
));
9147 free (rs
->col_type
);
9148 free (rs
->col_offset
);
9151 else if (do_debug_frames_interp
)
9152 printf ("Mismatched DW_CFA_restore_state\n");
9155 case DW_CFA_def_cfa
:
9156 READ_ULEB (fc
->cfa_reg
, start
, end
);
9157 READ_ULEB (fc
->cfa_offset
, start
, end
);
9159 if (! do_debug_frames_interp
)
9160 printf (" DW_CFA_def_cfa: %s ofs %d\n",
9161 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9164 case DW_CFA_def_cfa_register
:
9165 READ_ULEB (fc
->cfa_reg
, start
, end
);
9167 if (! do_debug_frames_interp
)
9168 printf (" DW_CFA_def_cfa_register: %s\n",
9169 regname (fc
->cfa_reg
, 0));
9172 case DW_CFA_def_cfa_offset
:
9173 READ_ULEB (fc
->cfa_offset
, start
, end
);
9174 if (! do_debug_frames_interp
)
9175 printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc
->cfa_offset
);
9179 if (! do_debug_frames_interp
)
9180 printf (" DW_CFA_nop\n");
9183 case DW_CFA_def_cfa_expression
:
9184 READ_ULEB (ul
, start
, end
);
9185 if (start
>= block_end
|| ul
> (unsigned long) (block_end
- start
))
9187 printf (_(" DW_CFA_def_cfa_expression: <corrupt len %lu>\n"), ul
);
9190 if (! do_debug_frames_interp
)
9192 printf (" DW_CFA_def_cfa_expression (");
9193 decode_location_expression (start
, eh_addr_size
, 0, -1,
9201 case DW_CFA_expression
:
9202 READ_ULEB (reg
, start
, end
);
9203 READ_ULEB (ul
, start
, end
);
9204 if (reg
>= (unsigned int) fc
->ncols
)
9205 reg_prefix
= bad_reg
;
9206 /* PR 17512: file: 069-133014-0.006. */
9207 /* PR 17512: file: 98c02eb4. */
9209 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
9211 printf (_(" DW_CFA_expression: <corrupt len %lu>\n"), ul
);
9214 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9216 printf (" DW_CFA_expression: %s%s (",
9217 reg_prefix
, regname (reg
, 0));
9218 decode_location_expression (start
, eh_addr_size
, 0, -1,
9222 if (*reg_prefix
== '\0')
9223 fc
->col_type
[reg
] = DW_CFA_expression
;
9227 case DW_CFA_val_expression
:
9228 READ_ULEB (reg
, start
, end
);
9229 READ_ULEB (ul
, start
, end
);
9230 if (reg
>= (unsigned int) fc
->ncols
)
9231 reg_prefix
= bad_reg
;
9233 if (start
>= block_end
|| tmp
> block_end
|| tmp
< start
)
9235 printf (" DW_CFA_val_expression: <corrupt len %lu>\n", ul
);
9238 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9240 printf (" DW_CFA_val_expression: %s%s (",
9241 reg_prefix
, regname (reg
, 0));
9242 decode_location_expression (start
, eh_addr_size
, 0, -1,
9246 if (*reg_prefix
== '\0')
9247 fc
->col_type
[reg
] = DW_CFA_val_expression
;
9251 case DW_CFA_offset_extended_sf
:
9252 READ_ULEB (reg
, start
, end
);
9253 READ_SLEB (l
, start
, end
);
9254 if (frame_need_space (fc
, reg
) < 0)
9255 reg_prefix
= bad_reg
;
9256 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9257 printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n",
9258 reg_prefix
, regname (reg
, 0),
9259 (long)(l
* fc
->data_factor
));
9260 if (*reg_prefix
== '\0')
9262 fc
->col_type
[reg
] = DW_CFA_offset
;
9263 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9267 case DW_CFA_val_offset_sf
:
9268 READ_ULEB (reg
, start
, end
);
9269 READ_SLEB (l
, start
, end
);
9270 if (frame_need_space (fc
, reg
) < 0)
9271 reg_prefix
= bad_reg
;
9272 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9273 printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n",
9274 reg_prefix
, regname (reg
, 0),
9275 (long)(l
* fc
->data_factor
));
9276 if (*reg_prefix
== '\0')
9278 fc
->col_type
[reg
] = DW_CFA_val_offset
;
9279 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9283 case DW_CFA_def_cfa_sf
:
9284 READ_ULEB (fc
->cfa_reg
, start
, end
);
9285 READ_ULEB (fc
->cfa_offset
, start
, end
);
9286 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
9288 if (! do_debug_frames_interp
)
9289 printf (" DW_CFA_def_cfa_sf: %s ofs %d\n",
9290 regname (fc
->cfa_reg
, 0), (int) fc
->cfa_offset
);
9293 case DW_CFA_def_cfa_offset_sf
:
9294 READ_ULEB (fc
->cfa_offset
, start
, end
);
9295 fc
->cfa_offset
*= fc
->data_factor
;
9296 if (! do_debug_frames_interp
)
9297 printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc
->cfa_offset
);
9300 case DW_CFA_MIPS_advance_loc8
:
9301 SAFE_BYTE_GET_AND_INC (ofs
, start
, 8, block_end
);
9302 if (do_debug_frames_interp
)
9303 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9305 printf (" DW_CFA_MIPS_advance_loc8: %ld to %s\n",
9306 (unsigned long) (ofs
* fc
->code_factor
),
9307 dwarf_vmatoa_1 (NULL
,
9308 fc
->pc_begin
+ ofs
* fc
->code_factor
,
9310 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9313 case DW_CFA_GNU_window_save
:
9314 if (! do_debug_frames_interp
)
9315 printf (" DW_CFA_GNU_window_save\n");
9318 case DW_CFA_GNU_args_size
:
9319 READ_ULEB (ul
, start
, end
);
9320 if (! do_debug_frames_interp
)
9321 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9324 case DW_CFA_GNU_negative_offset_extended
:
9325 READ_ULEB (reg
, start
, end
);
9326 READ_SLEB (l
, start
, end
);
9328 if (frame_need_space (fc
, reg
) < 0)
9329 reg_prefix
= bad_reg
;
9330 if (! do_debug_frames_interp
|| *reg_prefix
!= '\0')
9331 printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n",
9332 reg_prefix
, regname (reg
, 0),
9333 (long)(l
* fc
->data_factor
));
9334 if (*reg_prefix
== '\0')
9336 fc
->col_type
[reg
] = DW_CFA_offset
;
9337 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9342 if (op
>= DW_CFA_lo_user
&& op
<= DW_CFA_hi_user
)
9343 printf (_(" DW_CFA_??? (User defined call frame op: %#x)\n"), op
);
9345 warn (_("Unsupported or unknown Dwarf Call Frame Instruction number: %#x\n"), op
);
9350 /* Interpret the CFA - as long as it is not completely full of NOPs. */
9351 if (do_debug_frames_interp
&& ! all_nops
)
9352 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9354 if (fde_fc
.col_type
!= NULL
)
9356 free (fde_fc
.col_type
);
9357 fde_fc
.col_type
= NULL
;
9359 if (fde_fc
.col_offset
!= NULL
)
9361 free (fde_fc
.col_offset
);
9362 fde_fc
.col_offset
= NULL
;
9366 eh_addr_size
= saved_eh_addr_size
;
9371 while (remembered_state
!= NULL
)
9373 rs
= remembered_state
;
9374 remembered_state
= rs
->next
;
9375 free (rs
->col_type
);
9376 free (rs
->col_offset
);
9377 rs
->next
= NULL
; /* Paranoia. */
9381 while (chunks
!= NULL
)
9385 free (rs
->col_type
);
9386 free (rs
->col_offset
);
9387 rs
->next
= NULL
; /* Paranoia. */
9391 while (forward_refs
!= NULL
)
9394 forward_refs
= rs
->next
;
9395 free (rs
->col_type
);
9396 free (rs
->col_offset
);
9397 rs
->next
= NULL
; /* Paranoia. */
9407 display_debug_names (struct dwarf_section
*section
, void *file
)
9409 unsigned char *hdrptr
= section
->start
;
9410 dwarf_vma unit_length
;
9411 unsigned char *unit_start
;
9412 const unsigned char *const section_end
= section
->start
+ section
->size
;
9413 unsigned char *unit_end
;
9415 introduce (section
, FALSE
);
9417 load_debug_section_with_follow (str
, file
);
9419 for (; hdrptr
< section_end
; hdrptr
= unit_end
)
9421 unsigned int offset_size
;
9422 uint16_t dwarf_version
, padding
;
9423 uint32_t comp_unit_count
, local_type_unit_count
, foreign_type_unit_count
;
9424 uint32_t bucket_count
, name_count
, abbrev_table_size
;
9425 uint32_t augmentation_string_size
;
9427 unsigned long sec_off
;
9428 bfd_boolean augmentation_printable
;
9429 const char *augmentation_string
;
9431 unit_start
= hdrptr
;
9433 /* Get and check the length of the block. */
9434 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 4, section_end
);
9436 if (unit_length
== 0xffffffff)
9438 /* This section is 64-bit DWARF. */
9439 SAFE_BYTE_GET_AND_INC (unit_length
, hdrptr
, 8, section_end
);
9444 unit_end
= hdrptr
+ unit_length
;
9446 sec_off
= hdrptr
- section
->start
;
9447 if (sec_off
+ unit_length
< sec_off
9448 || sec_off
+ unit_length
> section
->size
)
9450 warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"),
9452 (unsigned long) (unit_start
- section
->start
),
9453 dwarf_vmatoa ("x", unit_length
));
9457 /* Get and check the version number. */
9458 SAFE_BYTE_GET_AND_INC (dwarf_version
, hdrptr
, 2, unit_end
);
9459 printf (_("Version %ld\n"), (long) dwarf_version
);
9461 /* Prior versions did not exist, and future versions may not be
9462 backwards compatible. */
9463 if (dwarf_version
!= 5)
9465 warn (_("Only DWARF version 5 .debug_names "
9466 "is currently supported.\n"));
9470 SAFE_BYTE_GET_AND_INC (padding
, hdrptr
, 2, unit_end
);
9472 warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"),
9475 SAFE_BYTE_GET_AND_INC (comp_unit_count
, hdrptr
, 4, unit_end
);
9476 if (comp_unit_count
== 0)
9477 warn (_("Compilation unit count must be >= 1 in .debug_names\n"));
9479 SAFE_BYTE_GET_AND_INC (local_type_unit_count
, hdrptr
, 4, unit_end
);
9480 SAFE_BYTE_GET_AND_INC (foreign_type_unit_count
, hdrptr
, 4, unit_end
);
9481 SAFE_BYTE_GET_AND_INC (bucket_count
, hdrptr
, 4, unit_end
);
9482 SAFE_BYTE_GET_AND_INC (name_count
, hdrptr
, 4, unit_end
);
9483 SAFE_BYTE_GET_AND_INC (abbrev_table_size
, hdrptr
, 4, unit_end
);
9485 SAFE_BYTE_GET_AND_INC (augmentation_string_size
, hdrptr
, 4, unit_end
);
9486 if (augmentation_string_size
% 4 != 0)
9488 warn (_("Augmentation string length %u must be rounded up "
9489 "to a multiple of 4 in .debug_names.\n"),
9490 augmentation_string_size
);
9491 augmentation_string_size
+= (-augmentation_string_size
) & 3;
9494 printf (_("Augmentation string:"));
9496 augmentation_printable
= TRUE
;
9497 augmentation_string
= (const char *) hdrptr
;
9499 for (i
= 0; i
< augmentation_string_size
; i
++)
9503 SAFE_BYTE_GET_AND_INC (uc
, hdrptr
, 1, unit_end
);
9504 printf (" %02x", uc
);
9506 if (uc
!= 0 && !ISPRINT (uc
))
9507 augmentation_printable
= FALSE
;
9510 if (augmentation_printable
)
9514 i
< augmentation_string_size
&& augmentation_string
[i
];
9516 putchar (augmentation_string
[i
]);
9521 printf (_("CU table:\n"));
9522 for (i
= 0; i
< comp_unit_count
; i
++)
9526 SAFE_BYTE_GET_AND_INC (cu_offset
, hdrptr
, offset_size
, unit_end
);
9527 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) cu_offset
);
9531 printf (_("TU table:\n"));
9532 for (i
= 0; i
< local_type_unit_count
; i
++)
9536 SAFE_BYTE_GET_AND_INC (tu_offset
, hdrptr
, offset_size
, unit_end
);
9537 printf (_("[%3u] 0x%lx\n"), i
, (unsigned long) tu_offset
);
9541 printf (_("Foreign TU table:\n"));
9542 for (i
= 0; i
< foreign_type_unit_count
; i
++)
9546 SAFE_BYTE_GET_AND_INC (signature
, hdrptr
, 8, unit_end
);
9547 printf (_("[%3u] "), i
);
9548 print_dwarf_vma (signature
, 8);
9553 const uint32_t *const hash_table_buckets
= (uint32_t *) hdrptr
;
9554 hdrptr
+= bucket_count
* sizeof (uint32_t);
9555 const uint32_t *const hash_table_hashes
= (uint32_t *) hdrptr
;
9556 hdrptr
+= name_count
* sizeof (uint32_t);
9557 unsigned char *const name_table_string_offsets
= hdrptr
;
9558 hdrptr
+= name_count
* offset_size
;
9559 unsigned char *const name_table_entry_offsets
= hdrptr
;
9560 hdrptr
+= name_count
* offset_size
;
9561 unsigned char *const abbrev_table
= hdrptr
;
9562 hdrptr
+= abbrev_table_size
;
9563 const unsigned char *const abbrev_table_end
= hdrptr
;
9564 unsigned char *const entry_pool
= hdrptr
;
9565 if (hdrptr
> unit_end
)
9567 warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx "
9568 "for unit 0x%lx in the debug_names\n"),
9569 (long) (hdrptr
- section
->start
),
9570 (long) (unit_end
- section
->start
),
9571 (long) (unit_start
- section
->start
));
9575 size_t buckets_filled
= 0;
9577 for (bucketi
= 0; bucketi
< bucket_count
; bucketi
++)
9579 const uint32_t bucket
= hash_table_buckets
[bucketi
];
9584 printf (ngettext ("Used %zu of %lu bucket.\n",
9585 "Used %zu of %lu buckets.\n",
9587 buckets_filled
, (unsigned long) bucket_count
);
9589 uint32_t hash_prev
= 0;
9590 size_t hash_clash_count
= 0;
9591 size_t longest_clash
= 0;
9592 size_t this_length
= 0;
9594 for (hashi
= 0; hashi
< name_count
; hashi
++)
9596 const uint32_t hash_this
= hash_table_hashes
[hashi
];
9600 if (hash_prev
% bucket_count
== hash_this
% bucket_count
)
9604 longest_clash
= MAX (longest_clash
, this_length
);
9609 hash_prev
= hash_this
;
9611 printf (_("Out of %lu items there are %zu bucket clashes"
9612 " (longest of %zu entries).\n"),
9613 (unsigned long) name_count
, hash_clash_count
, longest_clash
);
9614 assert (name_count
== buckets_filled
+ hash_clash_count
);
9616 struct abbrev_lookup_entry
9618 dwarf_vma abbrev_tag
;
9619 unsigned char *abbrev_lookup_ptr
;
9621 struct abbrev_lookup_entry
*abbrev_lookup
= NULL
;
9622 size_t abbrev_lookup_used
= 0;
9623 size_t abbrev_lookup_allocated
= 0;
9625 unsigned char *abbrevptr
= abbrev_table
;
9628 dwarf_vma abbrev_tag
;
9630 READ_ULEB (abbrev_tag
, abbrevptr
, abbrev_table_end
);
9631 if (abbrev_tag
== 0)
9633 if (abbrev_lookup_used
== abbrev_lookup_allocated
)
9635 abbrev_lookup_allocated
= MAX (0x100,
9636 abbrev_lookup_allocated
* 2);
9637 abbrev_lookup
= xrealloc (abbrev_lookup
,
9638 (abbrev_lookup_allocated
9639 * sizeof (*abbrev_lookup
)));
9641 assert (abbrev_lookup_used
< abbrev_lookup_allocated
);
9642 struct abbrev_lookup_entry
*entry
;
9643 for (entry
= abbrev_lookup
;
9644 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9646 if (entry
->abbrev_tag
== abbrev_tag
)
9648 warn (_("Duplicate abbreviation tag %lu "
9649 "in unit 0x%lx in the debug_names\n"),
9650 (long) abbrev_tag
, (long) (unit_start
- section
->start
));
9653 entry
= &abbrev_lookup
[abbrev_lookup_used
++];
9654 entry
->abbrev_tag
= abbrev_tag
;
9655 entry
->abbrev_lookup_ptr
= abbrevptr
;
9657 /* Skip DWARF tag. */
9658 SKIP_ULEB (abbrevptr
, abbrev_table_end
);
9661 dwarf_vma xindex
, form
;
9663 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9664 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9665 if (xindex
== 0 && form
== 0)
9670 printf (_("\nSymbol table:\n"));
9672 for (namei
= 0; namei
< name_count
; ++namei
)
9674 uint64_t string_offset
, entry_offset
;
9676 SAFE_BYTE_GET (string_offset
,
9677 name_table_string_offsets
+ namei
* offset_size
,
9678 offset_size
, unit_end
);
9679 SAFE_BYTE_GET (entry_offset
,
9680 name_table_entry_offsets
+ namei
* offset_size
,
9681 offset_size
, unit_end
);
9683 printf ("[%3u] #%08x %s:", namei
, hash_table_hashes
[namei
],
9684 fetch_indirect_string (string_offset
));
9686 unsigned char *entryptr
= entry_pool
+ entry_offset
;
9688 /* We need to scan first whether there is a single or multiple
9689 entries. TAGNO is -2 for the first entry, it is -1 for the
9690 initial tag read of the second entry, then it becomes 0 for the
9691 first entry for real printing etc. */
9693 /* Initialize it due to a false compiler warning. */
9694 dwarf_vma second_abbrev_tag
= -1;
9697 dwarf_vma abbrev_tag
;
9698 dwarf_vma dwarf_tag
;
9699 const struct abbrev_lookup_entry
*entry
;
9701 READ_ULEB (abbrev_tag
, entryptr
, unit_end
);
9704 second_abbrev_tag
= abbrev_tag
;
9706 entryptr
= entry_pool
+ entry_offset
;
9709 if (abbrev_tag
== 0)
9713 (tagno
== 0 && second_abbrev_tag
== 0 ? " " : "\n\t"),
9714 (unsigned long) abbrev_tag
);
9716 for (entry
= abbrev_lookup
;
9717 entry
< abbrev_lookup
+ abbrev_lookup_used
;
9719 if (entry
->abbrev_tag
== abbrev_tag
)
9721 if (entry
>= abbrev_lookup
+ abbrev_lookup_used
)
9723 warn (_("Undefined abbreviation tag %lu "
9724 "in unit 0x%lx in the debug_names\n"),
9726 (long) (unit_start
- section
->start
));
9729 abbrevptr
= entry
->abbrev_lookup_ptr
;
9730 READ_ULEB (dwarf_tag
, abbrevptr
, abbrev_table_end
);
9732 printf (" %s", get_TAG_name (dwarf_tag
));
9735 dwarf_vma xindex
, form
;
9737 READ_ULEB (xindex
, abbrevptr
, abbrev_table_end
);
9738 READ_ULEB (form
, abbrevptr
, abbrev_table_end
);
9739 if (xindex
== 0 && form
== 0)
9743 printf (" %s", get_IDX_name (xindex
));
9744 entryptr
= read_and_display_attr_value (0, form
, 0,
9745 unit_start
, entryptr
, unit_end
,
9747 dwarf_version
, NULL
,
9754 printf (_(" <no entries>"));
9758 free (abbrev_lookup
);
9765 display_debug_links (struct dwarf_section
* section
,
9766 void * file ATTRIBUTE_UNUSED
)
9768 const unsigned char * filename
;
9769 unsigned int filelen
;
9771 introduce (section
, FALSE
);
9773 /* The .gnu_debuglink section is formatted as:
9774 (c-string) Filename.
9775 (padding) If needed to reach a 4 byte boundary.
9776 (uint32_t) CRC32 value.
9778 The .gun_debugaltlink section is formatted as:
9779 (c-string) Filename.
9780 (binary) Build-ID. */
9782 filename
= section
->start
;
9783 filelen
= strnlen ((const char *) filename
, section
->size
);
9784 if (filelen
== section
->size
)
9786 warn (_("The debuglink filename is corrupt/missing\n"));
9790 printf (_(" Separate debug info file: %s\n"), filename
);
9792 if (const_strneq (section
->name
, ".gnu_debuglink"))
9795 unsigned int crc_offset
;
9797 crc_offset
= filelen
+ 1;
9798 crc_offset
= (crc_offset
+ 3) & ~3;
9799 if (crc_offset
+ 4 > section
->size
)
9801 warn (_("CRC offset missing/truncated\n"));
9805 crc32
= byte_get (filename
+ crc_offset
, 4);
9807 printf (_(" CRC value: %#x\n"), crc32
);
9809 if (crc_offset
+ 4 < section
->size
)
9811 warn (_("There are %#lx extraneous bytes at the end of the section\n"),
9812 (long)(section
->size
- (crc_offset
+ 4)));
9816 else /* const_strneq (section->name, ".gnu_debugaltlink") */
9818 const unsigned char * build_id
= section
->start
+ filelen
+ 1;
9819 bfd_size_type build_id_len
= section
->size
- (filelen
+ 1);
9820 bfd_size_type printed
;
9822 /* FIXME: Should we support smaller build-id notes ? */
9823 if (build_id_len
< 0x14)
9825 warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len
);
9829 printed
= printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len
);
9830 display_data (printed
, build_id
, build_id_len
);
9839 display_gdb_index (struct dwarf_section
*section
,
9840 void *file ATTRIBUTE_UNUSED
)
9842 unsigned char *start
= section
->start
;
9844 uint32_t cu_list_offset
, tu_list_offset
;
9845 uint32_t address_table_offset
, symbol_table_offset
, constant_pool_offset
;
9846 unsigned int cu_list_elements
, tu_list_elements
;
9847 unsigned int address_table_size
, symbol_table_slots
;
9848 unsigned char *cu_list
, *tu_list
;
9849 unsigned char *address_table
, *symbol_table
, *constant_pool
;
9852 /* The documentation for the format of this file is in gdb/dwarf2read.c. */
9854 introduce (section
, FALSE
);
9856 if (section
->size
< 6 * sizeof (uint32_t))
9858 warn (_("Truncated header in the %s section.\n"), section
->name
);
9862 version
= byte_get_little_endian (start
, 4);
9863 printf (_("Version %ld\n"), (long) version
);
9865 /* Prior versions are obsolete, and future versions may not be
9866 backwards compatible. */
9867 if (version
< 3 || version
> 8)
9869 warn (_("Unsupported version %lu.\n"), (unsigned long) version
);
9873 warn (_("The address table data in version 3 may be wrong.\n"));
9875 warn (_("Version 4 does not support case insensitive lookups.\n"));
9877 warn (_("Version 5 does not include inlined functions.\n"));
9879 warn (_("Version 6 does not include symbol attributes.\n"));
9880 /* Version 7 indices generated by Gold have bad type unit references,
9881 PR binutils/15021. But we don't know if the index was generated by
9882 Gold or not, so to avoid worrying users with gdb-generated indices
9883 we say nothing for version 7 here. */
9885 cu_list_offset
= byte_get_little_endian (start
+ 4, 4);
9886 tu_list_offset
= byte_get_little_endian (start
+ 8, 4);
9887 address_table_offset
= byte_get_little_endian (start
+ 12, 4);
9888 symbol_table_offset
= byte_get_little_endian (start
+ 16, 4);
9889 constant_pool_offset
= byte_get_little_endian (start
+ 20, 4);
9891 if (cu_list_offset
> section
->size
9892 || tu_list_offset
> section
->size
9893 || address_table_offset
> section
->size
9894 || symbol_table_offset
> section
->size
9895 || constant_pool_offset
> section
->size
)
9897 warn (_("Corrupt header in the %s section.\n"), section
->name
);
9901 /* PR 17531: file: 418d0a8a. */
9902 if (tu_list_offset
< cu_list_offset
)
9904 warn (_("TU offset (%x) is less than CU offset (%x)\n"),
9905 tu_list_offset
, cu_list_offset
);
9909 cu_list_elements
= (tu_list_offset
- cu_list_offset
) / 8;
9911 if (address_table_offset
< tu_list_offset
)
9913 warn (_("Address table offset (%x) is less than TU offset (%x)\n"),
9914 address_table_offset
, tu_list_offset
);
9918 tu_list_elements
= (address_table_offset
- tu_list_offset
) / 8;
9920 /* PR 17531: file: 18a47d3d. */
9921 if (symbol_table_offset
< address_table_offset
)
9923 warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"),
9924 symbol_table_offset
, address_table_offset
);
9928 address_table_size
= symbol_table_offset
- address_table_offset
;
9930 if (constant_pool_offset
< symbol_table_offset
)
9932 warn (_("Constant pool offset (%x) is less than symbol table offset (%x)\n"),
9933 constant_pool_offset
, symbol_table_offset
);
9937 symbol_table_slots
= (constant_pool_offset
- symbol_table_offset
) / 8;
9939 cu_list
= start
+ cu_list_offset
;
9940 tu_list
= start
+ tu_list_offset
;
9941 address_table
= start
+ address_table_offset
;
9942 symbol_table
= start
+ symbol_table_offset
;
9943 constant_pool
= start
+ constant_pool_offset
;
9945 if (address_table
+ address_table_size
> section
->start
+ section
->size
)
9947 warn (_("Address table extends beyond end of section.\n"));
9951 printf (_("\nCU table:\n"));
9952 for (i
= 0; i
< cu_list_elements
; i
+= 2)
9954 uint64_t cu_offset
= byte_get_little_endian (cu_list
+ i
* 8, 8);
9955 uint64_t cu_length
= byte_get_little_endian (cu_list
+ i
* 8 + 8, 8);
9957 printf (_("[%3u] 0x%lx - 0x%lx\n"), i
/ 2,
9958 (unsigned long) cu_offset
,
9959 (unsigned long) (cu_offset
+ cu_length
- 1));
9962 printf (_("\nTU table:\n"));
9963 for (i
= 0; i
< tu_list_elements
; i
+= 3)
9965 uint64_t tu_offset
= byte_get_little_endian (tu_list
+ i
* 8, 8);
9966 uint64_t type_offset
= byte_get_little_endian (tu_list
+ i
* 8 + 8, 8);
9967 uint64_t signature
= byte_get_little_endian (tu_list
+ i
* 8 + 16, 8);
9969 printf (_("[%3u] 0x%lx 0x%lx "), i
/ 3,
9970 (unsigned long) tu_offset
,
9971 (unsigned long) type_offset
);
9972 print_dwarf_vma (signature
, 8);
9976 printf (_("\nAddress table:\n"));
9977 for (i
= 0; i
< address_table_size
&& i
<= address_table_size
- (2 * 8 + 4);
9980 uint64_t low
= byte_get_little_endian (address_table
+ i
, 8);
9981 uint64_t high
= byte_get_little_endian (address_table
+ i
+ 8, 8);
9982 uint32_t cu_index
= byte_get_little_endian (address_table
+ i
+ 16, 4);
9984 print_dwarf_vma (low
, 8);
9985 print_dwarf_vma (high
, 8);
9986 printf (_("%lu\n"), (unsigned long) cu_index
);
9989 printf (_("\nSymbol table:\n"));
9990 for (i
= 0; i
< symbol_table_slots
; ++i
)
9992 uint32_t name_offset
= byte_get_little_endian (symbol_table
+ i
* 8, 4);
9993 uint32_t cu_vector_offset
= byte_get_little_endian (symbol_table
+ i
* 8 + 4, 4);
9994 uint32_t num_cus
, cu
;
9996 if (name_offset
!= 0
9997 || cu_vector_offset
!= 0)
10000 unsigned char * adr
;
10002 adr
= constant_pool
+ name_offset
;
10003 /* PR 17531: file: 5b7b07ad. */
10004 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
)
10006 printf (_("[%3u] <corrupt offset: %x>"), i
, name_offset
);
10007 warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"),
10011 printf ("[%3u] %.*s:", i
,
10012 (int) (section
->size
- (constant_pool_offset
+ name_offset
)),
10013 constant_pool
+ name_offset
);
10015 adr
= constant_pool
+ cu_vector_offset
;
10016 if (adr
< constant_pool
|| adr
>= section
->start
+ section
->size
- 3)
10018 printf (_("<invalid CU vector offset: %x>\n"), cu_vector_offset
);
10019 warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"),
10020 cu_vector_offset
, i
);
10024 num_cus
= byte_get_little_endian (adr
, 4);
10026 adr
= constant_pool
+ cu_vector_offset
+ 4 + num_cus
* 4;
10027 if (num_cus
* 4 < num_cus
10028 || adr
>= section
->start
+ section
->size
10029 || adr
< constant_pool
)
10031 printf ("<invalid number of CUs: %d>\n", num_cus
);
10032 warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"),
10040 for (j
= 0; j
< num_cus
; ++j
)
10043 gdb_index_symbol_kind kind
;
10045 cu
= byte_get_little_endian (constant_pool
+ cu_vector_offset
+ 4 + j
* 4, 4);
10046 is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu
);
10047 kind
= GDB_INDEX_SYMBOL_KIND_VALUE (cu
);
10048 cu
= GDB_INDEX_CU_VALUE (cu
);
10049 /* Convert to TU number if it's for a type unit. */
10050 if (cu
>= cu_list_elements
/ 2)
10051 printf ("%cT%lu", num_cus
> 1 ? '\t' : ' ',
10052 (unsigned long) (cu
- cu_list_elements
/ 2));
10054 printf ("%c%lu", num_cus
> 1 ? '\t' : ' ', (unsigned long) cu
);
10056 printf (" [%s, %s]",
10057 is_static
? _("static") : _("global"),
10058 get_gdb_index_symbol_kind_name (kind
));
10070 /* Pre-allocate enough space for the CU/TU sets needed. */
10073 prealloc_cu_tu_list (unsigned int nshndx
)
10075 if (shndx_pool
== NULL
)
10077 shndx_pool_size
= nshndx
;
10078 shndx_pool_used
= 0;
10079 shndx_pool
= (unsigned int *) xcmalloc (shndx_pool_size
,
10080 sizeof (unsigned int));
10084 shndx_pool_size
= shndx_pool_used
+ nshndx
;
10085 shndx_pool
= (unsigned int *) xcrealloc (shndx_pool
, shndx_pool_size
,
10086 sizeof (unsigned int));
10091 add_shndx_to_cu_tu_entry (unsigned int shndx
)
10093 if (shndx_pool_used
>= shndx_pool_size
)
10095 error (_("Internal error: out of space in the shndx pool.\n"));
10098 shndx_pool
[shndx_pool_used
++] = shndx
;
10102 end_cu_tu_entry (void)
10104 if (shndx_pool_used
>= shndx_pool_size
)
10106 error (_("Internal error: out of space in the shndx pool.\n"));
10109 shndx_pool
[shndx_pool_used
++] = 0;
10112 /* Return the short name of a DWARF section given by a DW_SECT enumerator. */
10114 static const char *
10115 get_DW_SECT_short_name (unsigned int dw_sect
)
10117 static char buf
[16];
10123 case DW_SECT_TYPES
:
10125 case DW_SECT_ABBREV
:
10131 case DW_SECT_STR_OFFSETS
:
10133 case DW_SECT_MACINFO
:
10135 case DW_SECT_MACRO
:
10141 snprintf (buf
, sizeof (buf
), "%d", dw_sect
);
10145 /* Process a CU or TU index. If DO_DISPLAY is true, print the contents.
10146 These sections are extensions for Fission.
10147 See http://gcc.gnu.org/wiki/DebugFissionDWP. */
10150 process_cu_tu_index (struct dwarf_section
*section
, int do_display
)
10152 unsigned char *phdr
= section
->start
;
10153 unsigned char *limit
= phdr
+ section
->size
;
10154 unsigned char *phash
;
10155 unsigned char *pindex
;
10156 unsigned char *ppool
;
10157 unsigned int version
;
10158 unsigned int ncols
= 0;
10159 unsigned int nused
;
10160 unsigned int nslots
;
10163 dwarf_vma signature_high
;
10164 dwarf_vma signature_low
;
10167 /* PR 17512: file: 002-168123-0.004. */
10170 warn (_("Section %s is empty\n"), section
->name
);
10173 /* PR 17512: file: 002-376-0.004. */
10174 if (section
->size
< 24)
10176 warn (_("Section %s is too small to contain a CU/TU header\n"),
10181 SAFE_BYTE_GET (version
, phdr
, 4, limit
);
10183 SAFE_BYTE_GET (ncols
, phdr
+ 4, 4, limit
);
10184 SAFE_BYTE_GET (nused
, phdr
+ 8, 4, limit
);
10185 SAFE_BYTE_GET (nslots
, phdr
+ 12, 4, limit
);
10188 pindex
= phash
+ (size_t) nslots
* 8;
10189 ppool
= pindex
+ (size_t) nslots
* 4;
10193 introduce (section
, FALSE
);
10195 printf (_(" Version: %u\n"), version
);
10197 printf (_(" Number of columns: %u\n"), ncols
);
10198 printf (_(" Number of used entries: %u\n"), nused
);
10199 printf (_(" Number of slots: %u\n\n"), nslots
);
10202 /* PR 17531: file: 45d69832. */
10203 if ((size_t) nslots
* 8 / 8 != nslots
10204 || phash
< phdr
|| phash
> limit
10205 || pindex
< phash
|| pindex
> limit
10206 || ppool
< pindex
|| ppool
> limit
)
10208 warn (ngettext ("Section %s is too small for %u slot\n",
10209 "Section %s is too small for %u slots\n",
10211 section
->name
, nslots
);
10218 prealloc_cu_tu_list ((limit
- ppool
) / 4);
10219 for (i
= 0; i
< nslots
; i
++)
10221 unsigned char *shndx_list
;
10222 unsigned int shndx
;
10224 SAFE_BYTE_GET64 (phash
, &signature_high
, &signature_low
, limit
);
10225 if (signature_high
!= 0 || signature_low
!= 0)
10227 SAFE_BYTE_GET (j
, pindex
, 4, limit
);
10228 shndx_list
= ppool
+ j
* 4;
10229 /* PR 17531: file: 705e010d. */
10230 if (shndx_list
< ppool
)
10232 warn (_("Section index pool located before start of section\n"));
10237 printf (_(" [%3d] Signature: 0x%s Sections: "),
10238 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10239 buf
, sizeof (buf
)));
10242 if (shndx_list
>= limit
)
10244 warn (_("Section %s too small for shndx pool\n"),
10248 SAFE_BYTE_GET (shndx
, shndx_list
, 4, limit
);
10252 printf (" %d", shndx
);
10254 add_shndx_to_cu_tu_entry (shndx
);
10260 end_cu_tu_entry ();
10266 else if (version
== 2)
10269 unsigned int dw_sect
;
10270 unsigned char *ph
= phash
;
10271 unsigned char *pi
= pindex
;
10272 unsigned char *poffsets
= ppool
+ (size_t) ncols
* 4;
10273 unsigned char *psizes
= poffsets
+ (size_t) nused
* ncols
* 4;
10274 unsigned char *pend
= psizes
+ (size_t) nused
* ncols
* 4;
10275 bfd_boolean is_tu_index
;
10276 struct cu_tu_set
*this_set
= NULL
;
10278 unsigned char *prow
;
10280 is_tu_index
= strcmp (section
->name
, ".debug_tu_index") == 0;
10282 /* PR 17531: file: 0dd159bf.
10283 Check for integer overflow (can occur when size_t is 32-bit)
10284 with overlarge ncols or nused values. */
10286 && ((size_t) ncols
* 4 / 4 != ncols
10287 || (size_t) nused
* ncols
* 4 / ((size_t) ncols
* 4) != nused
10288 || poffsets
< ppool
|| poffsets
> limit
10289 || psizes
< poffsets
|| psizes
> limit
10290 || pend
< psizes
|| pend
> limit
))
10292 warn (_("Section %s too small for offset and size tables\n"),
10299 printf (_(" Offset table\n"));
10300 printf (" slot %-16s ",
10301 is_tu_index
? _("signature") : _("dwo_id"));
10308 tu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10309 this_set
= tu_sets
;
10314 cu_sets
= xcalloc2 (nused
, sizeof (struct cu_tu_set
));
10315 this_set
= cu_sets
;
10321 for (j
= 0; j
< ncols
; j
++)
10323 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10324 printf (" %8s", get_DW_SECT_short_name (dw_sect
));
10329 for (i
= 0; i
< nslots
; i
++)
10331 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
10333 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10336 /* PR 17531: file: a05f6ab3. */
10339 warn (_("Row index (%u) is larger than number of used entries (%u)\n"),
10346 size_t num_copy
= sizeof (uint64_t);
10348 /* PR 23064: Beware of buffer overflow. */
10349 if (ph
+ num_copy
< limit
)
10350 memcpy (&this_set
[row
- 1].signature
, ph
, num_copy
);
10353 warn (_("Signature (%p) extends beyond end of space in section\n"), ph
);
10358 prow
= poffsets
+ (row
- 1) * ncols
* 4;
10359 /* PR 17531: file: b8ce60a8. */
10360 if (prow
< poffsets
|| prow
> limit
)
10362 warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"),
10368 printf (_(" [%3d] 0x%s"),
10369 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10370 buf
, sizeof (buf
)));
10371 for (j
= 0; j
< ncols
; j
++)
10373 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
10375 printf (" %8d", val
);
10378 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10380 /* PR 17531: file: 10796eb3. */
10381 if (dw_sect
>= DW_SECT_MAX
)
10382 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10384 this_set
[row
- 1].section_offsets
[dw_sect
] = val
;
10400 printf (_(" Size table\n"));
10401 printf (" slot %-16s ",
10402 is_tu_index
? _("signature") : _("dwo_id"));
10405 for (j
= 0; j
< ncols
; j
++)
10407 SAFE_BYTE_GET (val
, ppool
+ j
* 4, 4, limit
);
10409 printf (" %8s", get_DW_SECT_short_name (val
));
10415 for (i
= 0; i
< nslots
; i
++)
10417 SAFE_BYTE_GET64 (ph
, &signature_high
, &signature_low
, limit
);
10419 SAFE_BYTE_GET (row
, pi
, 4, limit
);
10422 prow
= psizes
+ (row
- 1) * ncols
* 4;
10425 printf (_(" [%3d] 0x%s"),
10426 i
, dwarf_vmatoa64 (signature_high
, signature_low
,
10427 buf
, sizeof (buf
)));
10429 for (j
= 0; j
< ncols
; j
++)
10431 SAFE_BYTE_GET (val
, prow
+ j
* 4, 4, limit
);
10433 printf (" %8d", val
);
10436 SAFE_BYTE_GET (dw_sect
, ppool
+ j
* 4, 4, limit
);
10437 if (dw_sect
>= DW_SECT_MAX
)
10438 warn (_("Overlarge Dwarf section index detected: %u\n"), dw_sect
);
10440 this_set
[row
- 1].section_sizes
[dw_sect
] = val
;
10452 else if (do_display
)
10453 printf (_(" Unsupported version (%d)\n"), version
);
10461 /* Load the CU and TU indexes if present. This will build a list of
10462 section sets that we can use to associate a .debug_info.dwo section
10463 with its associated .debug_abbrev.dwo section in a .dwp file. */
10466 load_cu_tu_indexes (void *file
)
10468 static int cu_tu_indexes_read
= -1; /* Tri-state variable. */
10470 /* If we have already loaded (or tried to load) the CU and TU indexes
10471 then do not bother to repeat the task. */
10472 if (cu_tu_indexes_read
== -1)
10474 cu_tu_indexes_read
= TRUE
;
10476 if (load_debug_section_with_follow (dwp_cu_index
, file
))
10477 if (! process_cu_tu_index (&debug_displays
[dwp_cu_index
].section
, 0))
10478 cu_tu_indexes_read
= FALSE
;
10480 if (load_debug_section_with_follow (dwp_tu_index
, file
))
10481 if (! process_cu_tu_index (&debug_displays
[dwp_tu_index
].section
, 0))
10482 cu_tu_indexes_read
= FALSE
;
10485 return (bfd_boolean
) cu_tu_indexes_read
;
10488 /* Find the set of sections that includes section SHNDX. */
10491 find_cu_tu_set (void *file
, unsigned int shndx
)
10495 if (! load_cu_tu_indexes (file
))
10498 /* Find SHNDX in the shndx pool. */
10499 for (i
= 0; i
< shndx_pool_used
; i
++)
10500 if (shndx_pool
[i
] == shndx
)
10503 if (i
>= shndx_pool_used
)
10506 /* Now backup to find the first entry in the set. */
10507 while (i
> 0 && shndx_pool
[i
- 1] != 0)
10510 return shndx_pool
+ i
;
10513 /* Display a .debug_cu_index or .debug_tu_index section. */
10516 display_cu_index (struct dwarf_section
*section
, void *file ATTRIBUTE_UNUSED
)
10518 return process_cu_tu_index (section
, 1);
10522 display_debug_not_supported (struct dwarf_section
*section
,
10523 void *file ATTRIBUTE_UNUSED
)
10525 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10531 /* Like malloc, but takes two parameters like calloc.
10532 Verifies that the first parameter is not too large.
10533 Note: does *not* initialise the allocated memory to zero. */
10536 cmalloc (size_t nmemb
, size_t size
)
10538 /* Check for overflow. */
10539 if (nmemb
>= ~(size_t) 0 / size
)
10542 return xmalloc (nmemb
* size
);
10545 /* Like xmalloc, but takes two parameters like calloc.
10546 Verifies that the first parameter is not too large.
10547 Note: does *not* initialise the allocated memory to zero. */
10550 xcmalloc (size_t nmemb
, size_t size
)
10552 /* Check for overflow. */
10553 if (nmemb
>= ~(size_t) 0 / size
)
10556 _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"),
10561 return xmalloc (nmemb
* size
);
10564 /* Like xrealloc, but takes three parameters.
10565 Verifies that the second parameter is not too large.
10566 Note: does *not* initialise any new memory to zero. */
10569 xcrealloc (void *ptr
, size_t nmemb
, size_t size
)
10571 /* Check for overflow. */
10572 if (nmemb
>= ~(size_t) 0 / size
)
10574 error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"),
10579 return xrealloc (ptr
, nmemb
* size
);
10582 /* Like xcalloc, but verifies that the first parameter is not too large. */
10585 xcalloc2 (size_t nmemb
, size_t size
)
10587 /* Check for overflow. */
10588 if (nmemb
>= ~(size_t) 0 / size
)
10590 error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"),
10595 return xcalloc (nmemb
, size
);
10598 static unsigned long
10599 calc_gnu_debuglink_crc32 (unsigned long crc
,
10600 const unsigned char * buf
,
10603 static const unsigned long crc32_table
[256] =
10605 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
10606 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
10607 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
10608 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
10609 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
10610 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
10611 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
10612 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
10613 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
10614 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
10615 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
10616 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
10617 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
10618 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
10619 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
10620 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
10621 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
10622 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
10623 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
10624 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
10625 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
10626 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
10627 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
10628 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
10629 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
10630 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
10631 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
10632 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
10633 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
10634 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
10635 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
10636 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
10637 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
10638 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
10639 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
10640 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
10641 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
10642 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
10643 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
10644 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
10645 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
10646 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
10647 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
10648 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
10649 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
10650 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
10651 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
10652 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
10653 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
10654 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
10655 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
10658 const unsigned char *end
;
10660 crc
= ~crc
& 0xffffffff;
10661 for (end
= buf
+ len
; buf
< end
; ++ buf
)
10662 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
10663 return ~crc
& 0xffffffff;
10666 typedef bfd_boolean (* check_func_type
) (const char *, void *);
10667 typedef const char * (* parse_func_type
) (struct dwarf_section
*, void *);
10670 check_gnu_debuglink (const char * pathname
, void * crc_pointer
)
10672 static unsigned char buffer
[8 * 1024];
10674 bfd_size_type count
;
10675 unsigned long crc
= 0;
10678 sep_data
= open_debug_file (pathname
);
10679 if (sep_data
== NULL
)
10682 /* Yes - we are opening the file twice... */
10683 f
= fopen (pathname
, "rb");
10686 /* Paranoia: This should never happen. */
10687 close_debug_file (sep_data
);
10688 warn (_("Unable to reopen separate debug info file: %s\n"), pathname
);
10692 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
10693 crc
= calc_gnu_debuglink_crc32 (crc
, buffer
, count
);
10697 if (crc
!= * (unsigned long *) crc_pointer
)
10699 close_debug_file (sep_data
);
10700 warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
10708 static const char *
10709 parse_gnu_debuglink (struct dwarf_section
* section
, void * data
)
10712 unsigned int crc_offset
;
10713 unsigned long * crc32
= (unsigned long *) data
;
10715 /* The name is first.
10716 The CRC value is stored after the filename, aligned up to 4 bytes. */
10717 name
= (const char *) section
->start
;
10719 crc_offset
= strnlen (name
, section
->size
) + 1;
10720 crc_offset
= (crc_offset
+ 3) & ~3;
10721 if (crc_offset
+ 4 > section
->size
)
10724 * crc32
= byte_get (section
->start
+ crc_offset
, 4);
10729 check_gnu_debugaltlink (const char * filename
, void * data ATTRIBUTE_UNUSED
)
10731 void * sep_data
= open_debug_file (filename
);
10733 if (sep_data
== NULL
)
10736 /* FIXME: We should now extract the build-id in the separate file
10742 typedef struct build_id_data
10745 const unsigned char * data
;
10748 static const char *
10749 parse_gnu_debugaltlink (struct dwarf_section
* section
, void * data
)
10752 bfd_size_type namelen
;
10753 bfd_size_type id_len
;
10754 Build_id_data
* build_id_data
;
10756 /* The name is first.
10757 The build-id follows immediately, with no padding, up to the section's end. */
10759 name
= (const char *) section
->start
;
10760 namelen
= strnlen (name
, section
->size
) + 1;
10761 if (namelen
>= section
->size
)
10764 id_len
= section
->size
- namelen
;
10768 build_id_data
= (Build_id_data
*) data
;
10769 build_id_data
->len
= id_len
;
10770 build_id_data
->data
= section
->start
+ namelen
;
10776 add_separate_debug_file (const char * filename
, void * handle
)
10778 separate_info
* i
= xmalloc (sizeof * i
);
10780 i
->filename
= filename
;
10781 i
->handle
= handle
;
10782 i
->next
= first_separate_info
;
10783 first_separate_info
= i
;
10786 #if HAVE_LIBDEBUGINFOD
10787 /* Query debuginfod servers for the target debuglink or debugaltlink
10788 file. If successful, store the path of the file in filename and
10789 return TRUE, otherwise return FALSE. */
10792 debuginfod_fetch_separate_debug_info (struct dwarf_section
* section
,
10796 size_t build_id_len
;
10797 unsigned char * build_id
;
10799 if (strcmp (section
->uncompressed_name
, ".gnu_debuglink") == 0)
10801 /* Get the build-id of file. */
10802 build_id
= get_build_id (file
);
10805 else if (strcmp (section
->uncompressed_name
, ".gnu_debugaltlink") == 0)
10807 /* Get the build-id of the debugaltlink file. */
10808 unsigned int filelen
;
10810 filelen
= strnlen ((const char *)section
->start
, section
->size
);
10811 if (filelen
== section
->size
)
10812 /* Corrupt debugaltlink. */
10815 build_id
= section
->start
+ filelen
+ 1;
10816 build_id_len
= section
->size
- (filelen
+ 1);
10818 if (build_id_len
== 0)
10827 debuginfod_client
* client
;
10829 client
= debuginfod_begin ();
10830 if (client
== NULL
)
10833 /* Query debuginfod servers for the target file. If found its path
10834 will be stored in filename. */
10835 fd
= debuginfod_find_debuginfo (client
, build_id
, build_id_len
, filename
);
10836 debuginfod_end (client
);
10838 /* Only free build_id if we allocated space for a hex string
10839 in get_build_id (). */
10840 if (build_id_len
== 0)
10845 /* File successfully retrieved. Close fd since we want to
10846 use open_debug_file () on filename instead. */
10857 load_separate_debug_info (const char * main_filename
,
10858 struct dwarf_section
* xlink
,
10859 parse_func_type parse_func
,
10860 check_func_type check_func
,
10862 void * file ATTRIBUTE_UNUSED
)
10864 const char * separate_filename
;
10865 char * debug_filename
;
10867 size_t canon_dirlen
;
10870 if ((separate_filename
= parse_func (xlink
, func_data
)) == NULL
)
10872 warn (_("Corrupt debuglink section: %s\n"),
10873 xlink
->name
? xlink
->name
: xlink
->uncompressed_name
);
10877 /* Attempt to locate the separate file.
10878 This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */
10880 canon_dir
= lrealpath (main_filename
);
10882 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
10883 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
10885 canon_dir
[canon_dirlen
] = '\0';
10888 #define DEBUGDIR "/lib/debug"
10890 #ifndef EXTRA_DEBUG_ROOT1
10891 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
10893 #ifndef EXTRA_DEBUG_ROOT2
10894 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
10897 debug_filename
= (char *) malloc (strlen (DEBUGDIR
) + 1
10899 + strlen (".debug/")
10900 #ifdef EXTRA_DEBUG_ROOT1
10901 + strlen (EXTRA_DEBUG_ROOT1
)
10903 #ifdef EXTRA_DEBUG_ROOT2
10904 + strlen (EXTRA_DEBUG_ROOT2
)
10906 + strlen (separate_filename
)
10908 if (debug_filename
== NULL
)
10910 warn (_("Out of memory"));
10915 /* First try in the current directory. */
10916 sprintf (debug_filename
, "%s", separate_filename
);
10917 if (check_func (debug_filename
, func_data
))
10920 /* Then try in a subdirectory called .debug. */
10921 sprintf (debug_filename
, ".debug/%s", separate_filename
);
10922 if (check_func (debug_filename
, func_data
))
10925 /* Then try in the same directory as the original file. */
10926 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
10927 if (check_func (debug_filename
, func_data
))
10930 /* And the .debug subdirectory of that directory. */
10931 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10932 if (check_func (debug_filename
, func_data
))
10935 #ifdef EXTRA_DEBUG_ROOT1
10936 /* Try the first extra debug file root. */
10937 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10938 if (check_func (debug_filename
, func_data
))
10941 /* Try the first extra debug file root. */
10942 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10943 if (check_func (debug_filename
, func_data
))
10947 #ifdef EXTRA_DEBUG_ROOT2
10948 /* Try the second extra debug file root. */
10949 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10950 if (check_func (debug_filename
, func_data
))
10954 /* Then try in the global debug_filename directory. */
10955 strcpy (debug_filename
, DEBUGDIR
);
10956 dirlen
= strlen (DEBUGDIR
) - 1;
10957 if (dirlen
> 0 && DEBUGDIR
[dirlen
] != '/')
10958 strcat (debug_filename
, "/");
10959 strcat (debug_filename
, (const char *) separate_filename
);
10961 if (check_func (debug_filename
, func_data
))
10964 #if HAVE_LIBDEBUGINFOD
10966 char * tmp_filename
;
10968 if (debuginfod_fetch_separate_debug_info (xlink
,
10972 /* File successfully downloaded from server, replace
10973 debug_filename with the file's path. */
10974 free (debug_filename
);
10975 debug_filename
= tmp_filename
;
10981 /* Failed to find the file. */
10982 warn (_("could not find separate debug file '%s'\n"), separate_filename
);
10983 warn (_("tried: %s\n"), debug_filename
);
10985 #ifdef EXTRA_DEBUG_ROOT2
10986 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT2
, separate_filename
);
10987 warn (_("tried: %s\n"), debug_filename
);
10990 #ifdef EXTRA_DEBUG_ROOT1
10991 sprintf (debug_filename
, "%s/%s/%s", EXTRA_DEBUG_ROOT1
, canon_dir
, separate_filename
);
10992 warn (_("tried: %s\n"), debug_filename
);
10994 sprintf (debug_filename
, "%s/%s", EXTRA_DEBUG_ROOT1
, separate_filename
);
10995 warn (_("tried: %s\n"), debug_filename
);
10998 sprintf (debug_filename
, "%s.debug/%s", canon_dir
, separate_filename
);
10999 warn (_("tried: %s\n"), debug_filename
);
11001 sprintf (debug_filename
, "%s%s", canon_dir
, separate_filename
);
11002 warn (_("tried: %s\n"), debug_filename
);
11004 sprintf (debug_filename
, ".debug/%s", separate_filename
);
11005 warn (_("tried: %s\n"), debug_filename
);
11007 sprintf (debug_filename
, "%s", separate_filename
);
11008 warn (_("tried: %s\n"), debug_filename
);
11010 #if HAVE_LIBDEBUGINFOD
11012 char *urls
= getenv (DEBUGINFOD_URLS_ENV_VAR
);
11016 warn (_("tried: DEBUGINFOD_URLS=%s\n"), urls
);
11021 free (debug_filename
);
11027 void * debug_handle
;
11029 /* Now open the file.... */
11030 if ((debug_handle
= open_debug_file (debug_filename
)) == NULL
)
11032 warn (_("failed to open separate debug file: %s\n"), debug_filename
);
11033 free (debug_filename
);
11037 /* FIXME: We do not check to see if there are any other separate debug info
11038 files that would also match. */
11040 printf (_("%s: Found separate debug info file: %s\n\n"), main_filename
, debug_filename
);
11041 add_separate_debug_file (debug_filename
, debug_handle
);
11043 /* Do not free debug_filename - it might be referenced inside
11044 the structure returned by open_debug_file(). */
11045 return debug_handle
;
11048 /* Attempt to load a separate dwarf object file. */
11051 load_dwo_file (const char * main_filename
, const char * name
, const char * dir
, const char * id ATTRIBUTE_UNUSED
)
11053 char * separate_filename
;
11054 void * separate_handle
;
11056 /* FIXME: Skip adding / if dwo_dir ends in /. */
11057 separate_filename
= concat (dir
, "/", name
, NULL
);
11058 if (separate_filename
== NULL
)
11060 warn (_("Out of memory allocating dwo filename\n"));
11064 if ((separate_handle
= open_debug_file (separate_filename
)) == NULL
)
11066 warn (_("Unable to load dwo file: %s\n"), separate_filename
);
11067 free (separate_filename
);
11071 /* FIXME: We should check the dwo_id. */
11073 printf (_("%s: Found separate debug object file: %s\n\n"), main_filename
, separate_filename
);
11074 add_separate_debug_file (separate_filename
, separate_handle
);
11075 /* Note - separate_filename will be freed in free_debug_memory(). */
11076 return separate_handle
;
11079 /* Load a debuglink section and/or a debugaltlink section, if either are present.
11080 Recursively check the loaded files for more of these sections.
11081 FIXME: Should also check for DWO_* entries in the newlu loaded files. */
11084 check_for_and_load_links (void * file
, const char * filename
)
11086 void * handle
= NULL
;
11088 if (load_debug_section (gnu_debugaltlink
, file
))
11090 Build_id_data build_id_data
;
11092 handle
= load_separate_debug_info (filename
,
11093 & debug_displays
[gnu_debugaltlink
].section
,
11094 parse_gnu_debugaltlink
,
11095 check_gnu_debugaltlink
,
11100 assert (handle
== first_separate_info
->handle
);
11101 check_for_and_load_links (first_separate_info
->handle
,
11102 first_separate_info
->filename
);
11106 if (load_debug_section (gnu_debuglink
, file
))
11108 unsigned long crc32
;
11110 handle
= load_separate_debug_info (filename
,
11111 & debug_displays
[gnu_debuglink
].section
,
11112 parse_gnu_debuglink
,
11113 check_gnu_debuglink
,
11118 assert (handle
== first_separate_info
->handle
);
11119 check_for_and_load_links (first_separate_info
->handle
,
11120 first_separate_info
->filename
);
11125 /* Load the separate debug info file(s) attached to FILE, if any exist.
11126 Returns TRUE if any were found, FALSE otherwise.
11127 If TRUE is returned then the linked list starting at first_separate_info
11128 will be populated with open file handles. */
11131 load_separate_debug_files (void * file
, const char * filename
)
11133 /* Skip this operation if we are not interested in debug links. */
11134 if (! do_follow_links
&& ! do_debug_links
)
11137 /* See if there are any dwo links. */
11138 if (load_debug_section (str
, file
)
11139 && load_debug_section (abbrev
, file
)
11140 && load_debug_section (info
, file
))
11144 if (process_debug_info (& debug_displays
[info
].section
, file
, abbrev
, TRUE
, FALSE
))
11146 bfd_boolean introduced
= FALSE
;
11148 const char * dir
= NULL
;
11149 const char * id
= NULL
;
11151 for (dwinfo
= first_dwo_info
; dwinfo
!= NULL
; dwinfo
= dwinfo
->next
)
11153 switch (dwinfo
->type
)
11156 if (do_debug_links
)
11160 printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
11161 debug_displays
[info
].section
.uncompressed_name
);
11165 printf (_(" Name: %s\n"), dwinfo
->value
);
11166 printf (_(" Directory: %s\n"), dir
? dir
: _("<not-found>"));
11168 display_data (printf (_(" ID: ")), (unsigned char *) id
, 8);
11170 printf (_(" ID: <unknown>\n"));
11174 if (do_follow_links
)
11175 load_dwo_file (filename
, dwinfo
->value
, dir
, id
);
11179 dir
= dwinfo
->value
;
11183 id
= dwinfo
->value
;
11187 error (_("Unexpected DWO INFO type"));
11194 if (! do_follow_links
)
11195 /* The other debug links will be displayed by display_debug_links()
11196 so we do not need to do any further processing here. */
11199 /* FIXME: We do not check for the presence of both link sections in the same file. */
11200 /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
11201 /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */
11203 check_for_and_load_links (file
, filename
);
11204 if (first_separate_info
!= NULL
)
11207 do_follow_links
= 0;
11212 free_debug_memory (void)
11216 free_all_abbrevs ();
11218 free (cu_abbrev_map
);
11219 cu_abbrev_map
= NULL
;
11220 next_free_abbrev_map_entry
= 0;
11222 for (i
= 0; i
< max
; i
++)
11223 free_debug_section ((enum dwarf_section_display_enum
) i
);
11225 if (debug_information
!= NULL
)
11227 for (i
= 0; i
< alloc_num_debug_info_entries
; i
++)
11229 if (debug_information
[i
].max_loc_offsets
)
11231 free (debug_information
[i
].loc_offsets
);
11232 free (debug_information
[i
].have_frame_base
);
11234 if (debug_information
[i
].max_range_lists
)
11235 free (debug_information
[i
].range_lists
);
11237 free (debug_information
);
11238 debug_information
= NULL
;
11239 alloc_num_debug_info_entries
= num_debug_info_entries
= 0;
11243 separate_info
* next
;
11245 for (d
= first_separate_info
; d
!= NULL
; d
= next
)
11247 close_debug_file (d
->handle
);
11248 free ((void *) d
->filename
);
11252 first_separate_info
= NULL
;
11258 dwarf_select_sections_by_names (const char *names
)
11262 const char * option
;
11266 debug_dump_long_opts
;
11268 static const debug_dump_long_opts opts_table
[] =
11270 /* Please keep this table alpha- sorted. */
11271 { "Ranges", & do_debug_ranges
, 1 },
11272 { "abbrev", & do_debug_abbrevs
, 1 },
11273 { "addr", & do_debug_addr
, 1 },
11274 { "aranges", & do_debug_aranges
, 1 },
11275 { "cu_index", & do_debug_cu_index
, 1 },
11276 { "decodedline", & do_debug_lines
, FLAG_DEBUG_LINES_DECODED
},
11277 { "follow-links", & do_follow_links
, 1 },
11278 { "frames", & do_debug_frames
, 1 },
11279 { "frames-interp", & do_debug_frames_interp
, 1 },
11280 /* The special .gdb_index section. */
11281 { "gdb_index", & do_gdb_index
, 1 },
11282 { "info", & do_debug_info
, 1 },
11283 { "line", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
}, /* For backwards compatibility. */
11284 { "links", & do_debug_links
, 1 },
11285 { "loc", & do_debug_loc
, 1 },
11286 { "macro", & do_debug_macinfo
, 1 },
11287 { "pubnames", & do_debug_pubnames
, 1 },
11288 { "pubtypes", & do_debug_pubtypes
, 1 },
11289 /* This entry is for compatibility
11290 with earlier versions of readelf. */
11291 { "ranges", & do_debug_aranges
, 1 },
11292 { "rawline", & do_debug_lines
, FLAG_DEBUG_LINES_RAW
},
11293 { "str", & do_debug_str
, 1 },
11294 { "str-offsets", & do_debug_str_offsets
, 1 },
11295 /* These trace_* sections are used by Itanium VMS. */
11296 { "trace_abbrev", & do_trace_abbrevs
, 1 },
11297 { "trace_aranges", & do_trace_aranges
, 1 },
11298 { "trace_info", & do_trace_info
, 1 },
11307 const debug_dump_long_opts
* entry
;
11309 for (entry
= opts_table
; entry
->option
; entry
++)
11311 size_t len
= strlen (entry
->option
);
11313 if (strncmp (p
, entry
->option
, len
) == 0
11314 && (p
[len
] == ',' || p
[len
] == '\0'))
11316 * entry
->variable
|= entry
->val
;
11318 /* The --debug-dump=frames-interp option also
11319 enables the --debug-dump=frames option. */
11320 if (do_debug_frames_interp
)
11321 do_debug_frames
= 1;
11328 if (entry
->option
== NULL
)
11330 warn (_("Unrecognized debug option '%s'\n"), p
);
11331 p
= strchr (p
, ',');
11342 dwarf_select_sections_by_letters (const char *letters
)
11344 unsigned int lindex
= 0;
11346 while (letters
[lindex
])
11347 switch (letters
[lindex
++])
11349 case 'A': do_debug_addr
= 1; break;
11350 case 'a': do_debug_abbrevs
= 1; break;
11351 case 'c': do_debug_cu_index
= 1; break;
11352 case 'F': do_debug_frames_interp
= 1; /* Fall through. */
11353 case 'f': do_debug_frames
= 1; break;
11354 case 'g': do_gdb_index
= 1; break;
11355 case 'i': do_debug_info
= 1; break;
11356 case 'K': do_follow_links
= 1; break;
11357 case 'k': do_debug_links
= 1; break;
11358 case 'l': do_debug_lines
|= FLAG_DEBUG_LINES_RAW
; break;
11359 case 'L': do_debug_lines
|= FLAG_DEBUG_LINES_DECODED
; break;
11360 case 'm': do_debug_macinfo
= 1; break;
11361 case 'O': do_debug_str_offsets
= 1; break;
11362 case 'o': do_debug_loc
= 1; break;
11363 case 'p': do_debug_pubnames
= 1; break;
11364 case 'R': do_debug_ranges
= 1; break;
11365 case 'r': do_debug_aranges
= 1; break;
11366 case 's': do_debug_str
= 1; break;
11367 case 'T': do_trace_aranges
= 1; break;
11368 case 't': do_debug_pubtypes
= 1; break;
11369 case 'U': do_trace_info
= 1; break;
11370 case 'u': do_trace_abbrevs
= 1; break;
11373 warn (_("Unrecognized debug option '%s'\n"), letters
);
11379 dwarf_select_sections_all (void)
11382 do_debug_abbrevs
= 1;
11383 do_debug_lines
= FLAG_DEBUG_LINES_RAW
;
11384 do_debug_pubnames
= 1;
11385 do_debug_pubtypes
= 1;
11386 do_debug_aranges
= 1;
11387 do_debug_ranges
= 1;
11388 do_debug_frames
= 1;
11389 do_debug_macinfo
= 1;
11394 do_trace_abbrevs
= 1;
11395 do_trace_aranges
= 1;
11397 do_debug_cu_index
= 1;
11398 do_follow_links
= 1;
11399 do_debug_links
= 1;
11400 do_debug_str_offsets
= 1;
11403 #define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL
11404 #define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL
11406 /* N.B. The order here must match the order in section_display_enum. */
11408 struct dwarf_section_display debug_displays
[] =
11410 { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
11411 { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS
}, display_debug_aranges
, &do_debug_aranges
, TRUE
},
11412 { { ".debug_frame", ".zdebug_frame", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
11413 { { ".debug_info", ".zdebug_info", ABBREV (abbrev
)}, display_debug_info
, &do_debug_info
, TRUE
},
11414 { { ".debug_line", ".zdebug_line", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
11415 { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubnames
, FALSE
},
11416 { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubnames
, FALSE
},
11417 { { ".eh_frame", "", NO_ABBREVS
}, display_debug_frames
, &do_debug_frames
, TRUE
},
11418 { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
11419 { { ".debug_macro", ".zdebug_macro", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
11420 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11421 { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11422 { { ".debug_loc", ".zdebug_loc", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
11423 { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
11424 { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS
}, display_debug_pubnames
, &do_debug_pubtypes
, FALSE
},
11425 { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS
}, display_debug_gnu_pubnames
, &do_debug_pubtypes
, FALSE
},
11426 { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
11427 { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS
}, display_debug_ranges
, &do_debug_ranges
, TRUE
},
11428 { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
11429 { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
11430 { { ".debug_types", ".zdebug_types", ABBREV (abbrev
) }, display_debug_types
, &do_debug_info
, TRUE
},
11431 { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS
}, display_debug_not_supported
, NULL
, FALSE
},
11432 { { ".gdb_index", "", NO_ABBREVS
}, display_gdb_index
, &do_gdb_index
, FALSE
},
11433 { { ".debug_names", "", NO_ABBREVS
}, display_debug_names
, &do_gdb_index
, FALSE
},
11434 { { ".trace_info", "", ABBREV (trace_abbrev
) }, display_trace_info
, &do_trace_info
, TRUE
},
11435 { { ".trace_abbrev", "", NO_ABBREVS
}, display_debug_abbrev
, &do_trace_abbrevs
, FALSE
},
11436 { { ".trace_aranges", "", NO_ABBREVS
}, display_debug_aranges
, &do_trace_aranges
, FALSE
},
11437 { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo
) }, display_debug_info
, &do_debug_info
, TRUE
},
11438 { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS
}, display_debug_abbrev
, &do_debug_abbrevs
, FALSE
},
11439 { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo
) }, display_debug_types
, &do_debug_info
, TRUE
},
11440 { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS
}, display_debug_lines
, &do_debug_lines
, TRUE
},
11441 { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS
}, display_debug_loc
, &do_debug_loc
, TRUE
},
11442 { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS
}, display_debug_macro
, &do_debug_macinfo
, TRUE
},
11443 { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS
}, display_debug_macinfo
, &do_debug_macinfo
, FALSE
},
11444 { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, TRUE
},
11445 { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
11446 { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS
}, display_debug_str_offsets
, &do_debug_str_offsets
, TRUE
},
11447 { { ".debug_addr", ".zdebug_addr", NO_ABBREVS
}, display_debug_addr
, &do_debug_addr
, TRUE
},
11448 { { ".debug_cu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
11449 { { ".debug_tu_index", "", NO_ABBREVS
}, display_cu_index
, &do_debug_cu_index
, FALSE
},
11450 { { ".gnu_debuglink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
11451 { { ".gnu_debugaltlink", "", NO_ABBREVS
}, display_debug_links
, &do_debug_links
, FALSE
},
11452 /* Separate debug info files can containt their own .debug_str section,
11453 and this might be in *addition* to a .debug_str section already present
11454 in the main file. Hence we need to have two entries for .debug_str. */
11455 { { ".debug_str", ".zdebug_str", NO_ABBREVS
}, display_debug_str
, &do_debug_str
, FALSE
},
11458 /* A static assertion. */
11459 extern int debug_displays_assert
[ARRAY_SIZE (debug_displays
) == max
? 1 : -1];