blob: 60a0f60df39634eb314f84c95020bd6fe93384f2 [file] [log] [blame]
/* Dynamic architecture support for GDB, the GNU debugger.
Copyright (C) 1998-2024 Free Software Foundation, Inc.
This file is part of GDB.
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, see <http://www.gnu.org/licenses/>. */
#ifndef GDBARCH_H
#define GDBARCH_H
#include <vector>
#include "frame.h"
#include "dis-asm.h"
#include "gdbsupport/gdb_obstack.h"
#include "infrun.h"
#include "osabi.h"
#include "displaced-stepping.h"
#include "gdbsupport/gdb-checked-static-cast.h"
#include "registry.h"
struct floatformat;
struct ui_file;
struct value;
struct objfile;
struct obj_section;
struct minimal_symbol;
struct regcache;
struct reggroup;
struct regset;
struct disassemble_info;
struct target_ops;
struct obstack;
struct bp_target_info;
struct target_desc;
struct symbol;
struct syscall;
struct agent_expr;
struct axs_value;
struct stap_parse_info;
struct expr_builder;
struct ravenscar_arch_ops;
struct mem_range;
struct syscalls_info;
struct thread_info;
struct ui_out;
struct inferior;
struct x86_xsave_layout;
struct solib_ops;
#include "regcache.h"
/* The base class for every architecture's tdep sub-class. The virtual
destructor ensures the class has RTTI information, which allows
gdb::checked_static_cast to be used in the gdbarch_tdep function. */
struct gdbarch_tdep_base
{
virtual ~gdbarch_tdep_base() = default;
};
using gdbarch_tdep_up = std::unique_ptr<gdbarch_tdep_base>;
/* Callback type for the 'iterate_over_objfiles_in_search_order'
gdbarch method. */
using iterate_over_objfiles_in_search_order_cb_ftype
= gdb::function_view<bool(objfile *)>;
/* Callback type for regset section iterators. The callback usually
invokes the REGSET's supply or collect method, to which it must
pass a buffer - for collects this buffer will need to be created using
COLLECT_SIZE, for supply the existing buffer being read from should
be at least SUPPLY_SIZE. SECT_NAME is a BFD section name, and HUMAN_NAME
is used for diagnostic messages. CB_DATA should have been passed
unchanged through the iterator. */
typedef void (iterate_over_regset_sections_cb)
(const char *sect_name, int supply_size, int collect_size,
const struct regset *regset, const char *human_name, void *cb_data);
/* For a function call, does the function return a value using a
normal value return or a structure return - passing a hidden
argument pointing to storage. For the latter, there are two
cases: language-mandated structure return and target ABI
structure return. */
enum function_call_return_method
{
/* Standard value return. */
return_method_normal = 0,
/* Language ABI structure return. This is handled
by passing the return location as the first parameter to
the function, even preceding "this". */
return_method_hidden_param,
/* Target ABI struct return. This is target-specific; for instance,
on ia64 the first argument is passed in out0 but the hidden
structure return pointer would normally be passed in r8. */
return_method_struct,
};
enum class memtag_type
{
/* Logical tag, the tag that is stored in unused bits of a pointer to a
virtual address. */
logical = 0,
/* Allocation tag, the tag that is associated with every granule of memory in
the physical address space. Allocation tags are used to validate memory
accesses via pointers containing logical tags. */
allocation,
};
/* Callback types for 'read_core_file_mappings' gdbarch method. */
using read_core_file_mappings_pre_loop_ftype =
gdb::function_view<void (ULONGEST count)>;
using read_core_file_mappings_loop_ftype =
gdb::function_view<void (int num,
ULONGEST start,
ULONGEST end,
ULONGEST file_ofs,
const char *filename,
const bfd_build_id *build_id)>;
/* Possible values for gdbarch_call_dummy_location. */
enum call_dummy_location_type
{
ON_STACK,
AT_ENTRY_POINT,
};
#include "gdbarch-gen.h"
/* An internal function that should _only_ be called from gdbarch_tdep.
Returns the gdbarch_tdep_base field held within GDBARCH. */
extern struct gdbarch_tdep_base *gdbarch_tdep_1 (struct gdbarch *gdbarch);
/* Return the gdbarch_tdep_base object held within GDBARCH cast to the type
TDepType, which should be a sub-class of gdbarch_tdep_base.
When GDB is compiled in maintainer mode a run-time check is performed
that the gdbarch_tdep_base within GDBARCH really is of type TDepType.
When GDB is compiled in release mode the run-time check is not
performed, and we assume the caller knows what they are doing. */
template<typename TDepType>
static inline TDepType *
gdbarch_tdep (struct gdbarch *gdbarch)
{
struct gdbarch_tdep_base *tdep = gdbarch_tdep_1 (gdbarch);
return gdb::checked_static_cast<TDepType *> (tdep);
}
/* Mechanism for co-ordinating the selection of a specific
architecture.
GDB targets (*-tdep.c) can register an interest in a specific
architecture. Other GDB components can register a need to maintain
per-architecture data.
The mechanisms below ensures that there is only a loose connection
between the set-architecture command and the various GDB
components. Each component can independently register their need
to maintain architecture specific data with gdbarch.
Pragmatics:
Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
didn't scale.
The more traditional mega-struct containing architecture specific
data for all the various GDB components was also considered. Since
GDB is built from a variable number of (fairly independent)
components it was determined that the global approach was not
applicable. */
/* Register a new architectural family with GDB.
Register support for the specified ARCHITECTURE with GDB. When
gdbarch determines that the specified architecture has been
selected, the corresponding INIT function is called.
--
The INIT function takes two parameters: INFO which contains the
information available to gdbarch about the (possibly new)
architecture; ARCHES which is a list of the previously created
``struct gdbarch'' for this architecture.
The INFO parameter is, as far as possible, be pre-initialized with
information obtained from INFO.ABFD or the global defaults.
The ARCHES parameter is a linked list (sorted most recently used)
of all the previously created architures for this architecture
family. The (possibly NULL) ARCHES->gdbarch can used to access
values from the previously selected architecture for this
architecture family.
The INIT function shall return any of: NULL - indicating that it
doesn't recognize the selected architecture; an existing ``struct
gdbarch'' from the ARCHES list - indicating that the new
architecture is just a synonym for an earlier architecture (see
gdbarch_list_lookup_by_info()); a newly created ``struct gdbarch''
- that describes the selected architecture (see gdbarch_alloc()).
The DUMP_TDEP function shall print out all target specific values.
Care should be taken to ensure that the function works in both the
multi-arch and non- multi-arch cases. */
struct gdbarch_list
{
struct gdbarch *gdbarch;
struct gdbarch_list *next;
};
struct gdbarch_info
{
const struct bfd_arch_info *bfd_arch_info = nullptr;
enum bfd_endian byte_order = BFD_ENDIAN_UNKNOWN;
enum bfd_endian byte_order_for_code = BFD_ENDIAN_UNKNOWN;
bfd *abfd = nullptr;
/* Architecture-specific target description data. */
struct tdesc_arch_data *tdesc_data = nullptr;
enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
const struct target_desc *target_desc = nullptr;
};
typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
typedef bool (gdbarch_supports_arch_info_ftype) (const struct bfd_arch_info *);
extern void gdbarch_register (enum bfd_architecture architecture,
gdbarch_init_ftype *init,
gdbarch_dump_tdep_ftype *dump_tdep = nullptr,
gdbarch_supports_arch_info_ftype *supports_arch_info = nullptr);
/* Return true if ARCH is initialized. */
bool gdbarch_initialized_p (gdbarch *arch);
/* Return a vector of the valid architecture names. Since architectures are
registered during the _initialize phase this function only returns useful
information once initialization has been completed. */
extern std::vector<const char *> gdbarch_printable_names ();
/* Helper function. Search the list of ARCHES for a GDBARCH that
matches the information provided by INFO. */
extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
/* Helper function. Create a preliminary ``struct gdbarch''. Perform
basic initialization using values obtained from the INFO and TDEP
parameters. set_gdbarch_*() functions are called to complete the
initialization of the object. */
extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info,
gdbarch_tdep_up tdep);
/* Helper function. Free a partially-constructed ``struct gdbarch''.
It is assumed that the caller frees the ``struct
gdbarch_tdep''. */
extern void gdbarch_free (struct gdbarch *);
struct gdbarch_deleter
{
void operator() (gdbarch *arch) const
{ gdbarch_free (arch); }
};
using gdbarch_up = std::unique_ptr<gdbarch, gdbarch_deleter>;
/* Get the obstack owned by ARCH. */
extern obstack *gdbarch_obstack (gdbarch *arch);
/* Helper function. Allocate memory from the ``struct gdbarch''
obstack. The memory is freed when the corresponding architecture
is also freed. */
#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) obstack_calloc<TYPE> (gdbarch_obstack ((GDBARCH)), (NR))
#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) obstack_zalloc<TYPE> (gdbarch_obstack ((GDBARCH)))
/* Duplicate STRING, returning an equivalent string that's allocated on the
obstack associated with GDBARCH. The string is freed when the corresponding
architecture is also freed. */
extern char *gdbarch_obstack_strdup (struct gdbarch *arch, const char *string);
/* Helper function. Force an update of INF's architecture.
The actual architecture selected is determined by INFO, ``(gdb) set
architecture'' et.al., the existing architecture and BFD's default
architecture. INFO should be initialized to zero and then selected
fields should be updated.
Returns non-zero if the update succeeds. */
extern int gdbarch_update_p (inferior *inf, gdbarch_info info);
/* Helper function. Find an architecture matching info.
INFO should have relevant fields set, and then finished using
gdbarch_info_fill.
Returns the corresponding architecture, or NULL if no matching
architecture was found. */
extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
/* A registry adaptor for gdbarch. This arranges to store the
registry in the gdbarch. */
template<>
struct registry_accessor<gdbarch>
{
static registry<gdbarch> *get (gdbarch *arch);
};
/* Set the dynamic target-system-dependent parameters (architecture,
byte-order, ...) using information found in the BFD. */
extern void set_gdbarch_from_file (bfd *);
/* Initialize the current architecture to the "first" one we find on
our list. */
extern void initialize_current_architecture (void);
/* gdbarch trace variable */
extern unsigned int gdbarch_debug;
extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
/* Return the number of cooked registers (raw + pseudo) for ARCH. */
static inline int
gdbarch_num_cooked_regs (gdbarch *arch)
{
return gdbarch_num_regs (arch) + gdbarch_num_pseudo_regs (arch);
}
/* Return true if stacks for ARCH grow down, otherwise return true. */
static inline bool
gdbarch_stack_grows_down (gdbarch *arch)
{
return gdbarch_inner_than (arch, 1, 2);
}
#endif