forked from Imagelibrary/binutils-gdb
c915c2c95a
PR libsframe/32589 - function start address is zero in SFrame section dump
Currently, readelf and objdump display the SFrame sections in ET_REL
object files with function start addresses of each function as 0. This
makes it difficult to correlate SFrame stack trace information with the
individual functions in the object file.
For objdump, use the dump_dwarf () interface to dump SFrame section.
Similarly, for readelf, use the display_debug_section () interface to
dump SFrame section. These existing interfaces (for DWARF debug
sections) already support relocating the section contents before
dumping, so lets use them for SFrame sections as well.
When adding a new entry for SFrame in debug_option_table[], use char
'nil' and the option name of "sframe-internal-only". This is done so
that there is no additional (unnecessary) user-exposed ways of dumping
SFrame sections. Additionally, we explicitly disallow the
"sframe-internal-only" from external/user input in --dwarf (objdump).
Similarly, "sframe-internal-only" is explicitly matched and disallowed
from --debug-dump (readelf).
For objdump and readelf, we continue to keep the same error messaging as
earlier:
$ objdump --sframe=sframe bubble_sort.o
...
No sframe section present
$ objdump --sframe=.sfram bubble_sort.o
...
No .sfram section present
$ objdump --sframe=sframe-internal-only sort
...
No sframe-internal-only section present
Similarly for readelf:
$ readelf --sframe= bubble_sort.o
readelf: Error: Section name must be provided
$ readelf --sframe=.sfram bubble_sort.o
readelf: Warning: Section '.sfram' was not dumped because it does not exist
$ readelf --sframe=sframe bubble_sort.o
readelf: Warning: Section 'sframe' was not dumped because it does not exist
PS: Note how this patch adds a new entry to debug_displays[] with a
relocate value set to FALSE. This will be set to TRUE in a subsequent
patch ("bfd: gas: ld: libsframe: emit func start addr field as an offset
from FDE") when fixes are made to emit the value of the
'sfde_func_start_address' field in the new encoding
SFRAME_F_FDE_FUNC_START_PCREL across gas and ld.
binutils/
* dwarf.c (display_sframe): New definition.
(dwarf_select_sections_all): Enable SFrame section too.
(struct dwarf_section_display): Add entry for SFrame section.
* dwarf.h (enum dwarf_section_display_enum): Add enumerator for
SFrame.
* objdump.c (dump_section_sframe): Remove.
(dump_sframe_section): Add new definition.
(dump_bfd): Use dump_sframe_section.
* binutils/readelf.c (dump_section_as_sframe): Remove.
337 lines
9.0 KiB
C
337 lines
9.0 KiB
C
/* dwarf.h - DWARF support header file
|
|
Copyright (C) 2005-2025 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Binutils.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
|
MA 02110-1301, USA. */
|
|
|
|
#include "dwarf2.h" /* for enum dwarf_unit_type */
|
|
|
|
/* Structure found in the .debug_line section. */
|
|
typedef struct
|
|
{
|
|
uint64_t li_length;
|
|
uint16_t li_version;
|
|
uint8_t li_address_size;
|
|
uint8_t li_segment_size;
|
|
uint64_t li_prologue_length;
|
|
uint8_t li_min_insn_length;
|
|
uint8_t li_max_ops_per_insn;
|
|
uint8_t li_default_is_stmt;
|
|
int8_t li_line_base;
|
|
uint8_t li_line_range;
|
|
uint8_t li_opcode_base;
|
|
/* Not part of the header. 4 for 32-bit dwarf, 8 for 64-bit. */
|
|
unsigned int li_offset_size;
|
|
}
|
|
DWARF2_Internal_LineInfo;
|
|
|
|
/* Structure found in .debug_pubnames section. */
|
|
typedef struct
|
|
{
|
|
uint64_t pn_length;
|
|
unsigned short pn_version;
|
|
uint64_t pn_offset;
|
|
uint64_t pn_size;
|
|
}
|
|
DWARF2_Internal_PubNames;
|
|
|
|
/* Structure found in .debug_info section. */
|
|
typedef struct
|
|
{
|
|
uint64_t cu_length;
|
|
unsigned short cu_version;
|
|
uint64_t cu_abbrev_offset;
|
|
unsigned char cu_pointer_size;
|
|
enum dwarf_unit_type cu_unit_type;
|
|
}
|
|
DWARF2_Internal_CompUnit;
|
|
|
|
/* Structure found in .debug_aranges section. */
|
|
typedef struct
|
|
{
|
|
uint64_t ar_length;
|
|
unsigned short ar_version;
|
|
uint64_t ar_info_offset;
|
|
unsigned char ar_pointer_size;
|
|
unsigned char ar_segment_size;
|
|
}
|
|
DWARF2_Internal_ARange;
|
|
|
|
/* N.B. The order here must match the order in debug_displays. */
|
|
|
|
enum dwarf_section_display_enum
|
|
{
|
|
abbrev = 0,
|
|
aranges,
|
|
frame,
|
|
info,
|
|
line,
|
|
pubnames,
|
|
gnu_pubnames,
|
|
eh_frame,
|
|
eh_frame_hdr,
|
|
macinfo,
|
|
macro,
|
|
str,
|
|
line_str,
|
|
loc,
|
|
loclists,
|
|
loclists_dwo,
|
|
pubtypes,
|
|
gnu_pubtypes,
|
|
ranges,
|
|
rnglists,
|
|
rnglists_dwo,
|
|
static_func,
|
|
static_vars,
|
|
types,
|
|
weaknames,
|
|
gdb_index,
|
|
debug_names,
|
|
sframe,
|
|
trace_info,
|
|
trace_abbrev,
|
|
trace_aranges,
|
|
info_dwo,
|
|
abbrev_dwo,
|
|
types_dwo,
|
|
line_dwo,
|
|
loc_dwo,
|
|
macro_dwo,
|
|
macinfo_dwo,
|
|
str_dwo,
|
|
str_index,
|
|
str_index_dwo,
|
|
debug_addr,
|
|
dwp_cu_index,
|
|
dwp_tu_index,
|
|
gnu_debuglink,
|
|
gnu_debugaltlink,
|
|
debug_sup,
|
|
separate_debug_str,
|
|
note_gnu_build_id,
|
|
max
|
|
};
|
|
|
|
struct dwarf_section
|
|
{
|
|
/* A debug section has a different name when it's stored compressed
|
|
or not. XCOFF DWARF section also have a special name.
|
|
COMPRESSED_NAME, UNCOMPRESSED_NAME and XCOFF_NAME are the three
|
|
possibilities. NAME is set to whichever one is used for this
|
|
input file, as determined by load_debug_section(). */
|
|
const char * uncompressed_name;
|
|
const char * compressed_name;
|
|
const char * xcoff_name;
|
|
const char * name;
|
|
/* If non-NULL then FILENAME is the name of the separate debug info
|
|
file containing the section. */
|
|
const char * filename;
|
|
unsigned char * start;
|
|
uint64_t address;
|
|
uint64_t size;
|
|
enum dwarf_section_display_enum abbrev_sec;
|
|
/* Used by clients to help them implement the reloc_at callback. */
|
|
void * reloc_info;
|
|
uint64_t num_relocs;
|
|
};
|
|
|
|
/* A structure containing the name of a debug section
|
|
and a pointer to a function that can decode it. */
|
|
struct dwarf_section_display
|
|
{
|
|
struct dwarf_section section;
|
|
int (*display) (struct dwarf_section *, void *);
|
|
int *enabled;
|
|
bool relocate;
|
|
};
|
|
|
|
extern struct dwarf_section_display debug_displays [];
|
|
|
|
/* This structure records the information that
|
|
we extract from the.debug_info section. */
|
|
typedef struct
|
|
{
|
|
unsigned int pointer_size;
|
|
unsigned int offset_size;
|
|
int dwarf_version;
|
|
uint64_t cu_offset;
|
|
uint64_t base_address;
|
|
/* This field is filled in when reading the attribute DW_AT_GNU_addr_base and
|
|
is used with the form DW_FORM_GNU_addr_index. */
|
|
uint64_t addr_base;
|
|
/* This field is filled in when reading the attribute DW_AT_GNU_ranges_base and
|
|
is used when calculating ranges. */
|
|
uint64_t ranges_base;
|
|
/* This is an array of offsets to the location list table. */
|
|
uint64_t * loc_offsets;
|
|
/* This is an array of offsets to the location view table. */
|
|
uint64_t * loc_views;
|
|
int * have_frame_base;
|
|
|
|
/* Information for associating location lists with CUs. */
|
|
unsigned int num_loc_offsets;
|
|
unsigned int max_loc_offsets;
|
|
unsigned int num_loc_views;
|
|
uint64_t loclists_base;
|
|
|
|
/* List of .debug_ranges offsets seen in this .debug_info. */
|
|
uint64_t * range_lists;
|
|
unsigned int num_range_lists;
|
|
unsigned int max_range_lists;
|
|
uint64_t rnglists_base;
|
|
uint64_t str_offsets_base;
|
|
}
|
|
debug_info;
|
|
|
|
typedef struct separate_info
|
|
{
|
|
void * handle; /* The pointer returned by open_debug_file(). */
|
|
const char * filename;
|
|
struct separate_info * next;
|
|
} separate_info;
|
|
|
|
extern separate_info * first_separate_info;
|
|
|
|
extern unsigned int eh_addr_size;
|
|
|
|
extern int do_debug_info;
|
|
extern int do_debug_abbrevs;
|
|
extern int do_debug_lines;
|
|
extern int do_debug_pubnames;
|
|
extern int do_debug_pubtypes;
|
|
extern int do_debug_aranges;
|
|
extern int do_debug_ranges;
|
|
extern int do_debug_frames;
|
|
extern int do_debug_frames_interp;
|
|
extern int do_debug_macinfo;
|
|
extern int do_debug_str;
|
|
extern int do_debug_str_offsets;
|
|
extern int do_debug_loc;
|
|
extern int do_gdb_index;
|
|
extern int do_trace_info;
|
|
extern int do_trace_abbrevs;
|
|
extern int do_trace_aranges;
|
|
extern int do_debug_addr;
|
|
extern int do_debug_cu_index;
|
|
extern int do_wide;
|
|
extern int do_debug_links;
|
|
extern int do_follow_links;
|
|
#ifdef HAVE_LIBDEBUGINFOD
|
|
extern int use_debuginfod;
|
|
#endif
|
|
extern bool do_checks;
|
|
|
|
extern int dwarf_cutoff_level;
|
|
extern unsigned long dwarf_start_die;
|
|
|
|
extern int dwarf_check;
|
|
|
|
extern void init_dwarf_regnames_by_elf_machine_code (unsigned int);
|
|
extern void init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch,
|
|
unsigned long mach);
|
|
|
|
extern bool load_debug_section (enum dwarf_section_display_enum, void *);
|
|
extern void free_debug_section (enum dwarf_section_display_enum);
|
|
extern bool load_separate_debug_files (void *, const char *);
|
|
extern void close_debug_file (void *);
|
|
extern void *open_debug_file (const char *);
|
|
|
|
extern void free_debug_memory (void);
|
|
|
|
extern int dwarf_select_sections_by_names (const char *);
|
|
extern int dwarf_select_sections_by_letters (const char *);
|
|
extern void dwarf_select_sections_all (void);
|
|
|
|
extern unsigned int * find_cu_tu_set (void *, unsigned int);
|
|
|
|
extern void * cmalloc (uint64_t, size_t);
|
|
extern void * xcalloc2 (uint64_t, size_t);
|
|
extern void * xcmalloc (uint64_t, size_t);
|
|
extern void * xcrealloc (void *, uint64_t, size_t);
|
|
|
|
/* A callback into the client. Returns TRUE if there is a
|
|
relocation against the given debug section at the given
|
|
offset. */
|
|
extern bool reloc_at (struct dwarf_section *, uint64_t);
|
|
|
|
extern uint64_t read_leb128 (unsigned char *, const unsigned char *const,
|
|
bool, unsigned int *, int *);
|
|
|
|
#if HAVE_LIBDEBUGINFOD
|
|
extern unsigned char * get_build_id (void *);
|
|
#endif
|
|
|
|
static inline void
|
|
report_leb_status (int status)
|
|
{
|
|
if ((status & 1) != 0)
|
|
error (_("end of data encountered whilst reading LEB\n"));
|
|
else if ((status & 2) != 0)
|
|
error (_("read LEB value is too large to store in destination variable\n"));
|
|
}
|
|
|
|
#define SKIP_ULEB(start, end) \
|
|
do \
|
|
{ \
|
|
unsigned int _len; \
|
|
read_leb128 (start, end, false, &_len, NULL); \
|
|
start += _len; \
|
|
} \
|
|
while (0)
|
|
|
|
#define SKIP_SLEB(start, end) \
|
|
do \
|
|
{ \
|
|
unsigned int _len; \
|
|
read_leb128 (start, end, true, &_len, NULL); \
|
|
start += _len; \
|
|
} \
|
|
while (0)
|
|
|
|
#define READ_ULEB(var, start, end) \
|
|
do \
|
|
{ \
|
|
uint64_t _val; \
|
|
unsigned int _len; \
|
|
int _status; \
|
|
\
|
|
_val = read_leb128 (start, end, false, &_len, &_status); \
|
|
start += _len; \
|
|
(var) = _val; \
|
|
if ((var) != _val) \
|
|
_status |= 2; \
|
|
report_leb_status (_status); \
|
|
} \
|
|
while (0)
|
|
|
|
#define READ_SLEB(var, start, end) \
|
|
do \
|
|
{ \
|
|
int64_t _val; \
|
|
unsigned int _len; \
|
|
int _status; \
|
|
\
|
|
_val = read_leb128 (start, end, true, &_len, &_status); \
|
|
start += _len; \
|
|
(var) = _val; \
|
|
if ((var) != _val) \
|
|
_status |= 2; \
|
|
report_leb_status (_status); \
|
|
} \
|
|
while (0)
|