# Architecture commands for GDB, the GNU debugger.
#
-# Copyright (C) 1998-2020 Free Software Foundation, Inc.
+# Copyright (C) 1998-2021 Free Software Foundation, Inc.
#
# This file is part of GDB.
#
# hiding something from the ``struct info'' object
# m -> multi-arch function
# hiding a multi-arch function (parameterised with the architecture)
- # M -> multi-arch function + predicate
+ # M -> multi-arch function + predicate
# hiding a multi-arch function + predicate to test function validity
returntype ) : ;;
# machine.
v;int;long_long_bit;;;8 * sizeof (LONGEST);2*gdbarch->long_bit;;0
-# The ABI default bit-size and format for "half", "float", "double", and
+# The ABI default bit-size and format for "bfloat16", "half", "float", "double", and
# "long double". These bit/format pairs should eventually be combined
# into a single object. For the moment, just initialize them as a pair.
# Each format describes both the big and little endian layouts (if
# useful).
+v;int;bfloat16_bit;;;16;2*TARGET_CHAR_BIT;;0
+v;const struct floatformat **;bfloat16_format;;;;;floatformats_bfloat16;;pformat (gdbarch->bfloat16_format)
v;int;half_bit;;;16;2*TARGET_CHAR_BIT;;0
v;const struct floatformat **;half_format;;;;;floatformats_ieee_half;;pformat (gdbarch->half_format)
v;int;float_bit;;;8 * sizeof (float);4*TARGET_CHAR_BIT;;0
# Return -1 if something goes wrong, 0 otherwise.
M;int;ax_pseudo_register_push_stack;struct agent_expr *ax, int reg;ax, reg
-# Some targets/architectures can do extra processing/display of
-# segmentation faults. E.g., Intel MPX boundary faults.
-# Call the architecture dependent function to handle the fault.
+# Some architectures can display additional information for specific
+# signals.
# UIOUT is the output stream where the handler will place information.
-M;void;handle_segmentation_fault;struct ui_out *uiout;uiout
+M;void;report_signal_info;struct ui_out *uiout, enum gdb_signal siggnal;uiout, siggnal
# GDB's standard (or well known) register numbers. These can map onto
# a real register or a pseudo (computed) register or not be defined at
# See comment in target.h about continuable, steppable and
# non-steppable watchpoints.
v;int;have_nonsteppable_watchpoint;;;0;0;;0
-F;int;address_class_type_flags;int byte_size, int dwarf2_addr_class;byte_size, dwarf2_addr_class
-M;const char *;address_class_type_flags_to_name;int type_flags;type_flags
+F;type_instance_flags;address_class_type_flags;int byte_size, int dwarf2_addr_class;byte_size, dwarf2_addr_class
+M;const char *;address_class_type_flags_to_name;type_instance_flags type_flags;type_flags
# Execute vendor-specific DWARF Call Frame Instruction. OP is the instruction.
# FS are passed from the generic execute_cfa_program function.
m;bool;execute_dwarf_cfa_vendor_op;gdb_byte op, struct dwarf2_frame_state *fs;op, fs;;default_execute_dwarf_cfa_vendor_op;;0
# Return the appropriate type_flags for the supplied address class.
-# This function should return 1 if the address class was recognized and
-# type_flags was set, zero otherwise.
-M;int;address_class_name_to_type_flags;const char *name, int *type_flags_ptr;name, type_flags_ptr
+# This function should return true if the address class was recognized and
+# type_flags was set, false otherwise.
+M;bool;address_class_name_to_type_flags;const char *name, type_instance_flags *type_flags_ptr;name, type_flags_ptr
# Is a register in a group
m;int;register_reggroup_p;int regnum, struct reggroup *reggroup;regnum, reggroup;;default_register_reggroup_p;;0
# Fetch the pointer to the ith function argument.
M;void;iterate_over_regset_sections;iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache;cb, cb_data, regcache
# Create core file notes
-M;char *;make_corefile_notes;bfd *obfd, int *note_size;obfd, note_size
+M;gdb::unique_xmalloc_ptr<char>;make_corefile_notes;bfd *obfd, int *note_size;obfd, note_size
# Find core file memory regions
M;int;find_memory_regions;find_memory_region_ftype func, void *data;func, data
# not the copy at TO. The caller should update it to point at TO later.
#
# Return a pointer to data of the architecture's choice to be passed
-# to gdbarch_displaced_step_fixup. Or, return NULL to indicate that
-# the instruction's effects have been completely simulated, with the
-# resulting state written back to REGS.
+# to gdbarch_displaced_step_fixup.
#
# For a general explanation of displaced stepping and how GDB uses it,
# see the comments in infrun.c.
# If the instruction cannot execute out of line, return NULL. The
# core falls back to stepping past the instruction in-line instead in
# that case.
-M;displaced_step_closure_up;displaced_step_copy_insn;CORE_ADDR from, CORE_ADDR to, struct regcache *regs;from, to, regs
+M;displaced_step_copy_insn_closure_up;displaced_step_copy_insn;CORE_ADDR from, CORE_ADDR to, struct regcache *regs;from, to, regs
-# Return true if GDB should use hardware single-stepping to execute
-# the displaced instruction identified by CLOSURE. If false,
-# GDB will simply restart execution at the displaced instruction
-# location, and it is up to the target to ensure GDB will receive
-# control again (e.g. by placing a software breakpoint instruction
-# into the displaced instruction buffer).
+# Return true if GDB should use hardware single-stepping to execute a displaced
+# step instruction. If false, GDB will simply restart execution at the
+# displaced instruction location, and it is up to the target to ensure GDB will
+# receive control again (e.g. by placing a software breakpoint instruction into
+# the displaced instruction buffer).
#
-# The default implementation returns false on all targets that
-# provide a gdbarch_software_single_step routine, and true otherwise.
-m;int;displaced_step_hw_singlestep;struct displaced_step_closure *closure;closure;;default_displaced_step_hw_singlestep;;0
+# The default implementation returns false on all targets that provide a
+# gdbarch_software_single_step routine, and true otherwise.
+m;bool;displaced_step_hw_singlestep;void;;;default_displaced_step_hw_singlestep;;0
# Fix up the state resulting from successfully single-stepping a
# displaced instruction, to give the result we would have gotten from
#
# For a general explanation of displaced stepping and how GDB uses it,
# see the comments in infrun.c.
-M;void;displaced_step_fixup;struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs;closure, from, to, regs;;NULL
+M;void;displaced_step_fixup;struct displaced_step_copy_insn_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs;closure, from, to, regs;;NULL
-# Return the address of an appropriate place to put displaced
-# instructions while we step over them. There need only be one such
-# place, since we're only stepping one thread over a breakpoint at a
-# time.
+# Prepare THREAD for it to displaced step the instruction at its current PC.
#
-# For a general explanation of displaced stepping and how GDB uses it,
-# see the comments in infrun.c.
-m;CORE_ADDR;displaced_step_location;void;;;NULL;;(! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn)
+# Throw an exception if any unexpected error happens.
+M;displaced_step_prepare_status;displaced_step_prepare;thread_info *thread, CORE_ADDR &displaced_pc;thread, displaced_pc
+
+# Clean up after a displaced step of THREAD.
+m;displaced_step_finish_status;displaced_step_finish;thread_info *thread, gdb_signal sig;thread, sig;;NULL;;(! gdbarch->displaced_step_finish) != (! gdbarch->displaced_step_prepare)
+
+# Return the closure associated to the displaced step buffer that is at ADDR.
+F;const displaced_step_copy_insn_closure *;displaced_step_copy_insn_closure_by_addr;inferior *inf, CORE_ADDR addr;inf, addr
+
+# PARENT_INF has forked and CHILD_PTID is the ptid of the child. Restore the
+# contents of all displaced step buffers in the child's address space.
+f;void;displaced_step_restore_all_in_ptid;inferior *parent_inf, ptid_t child_ptid;parent_inf, child_ptid
# Relocate an instruction to execute at a different address. OLDLOC
# is the address in the inferior memory where the instruction to
M;const struct target_desc *;core_read_description;struct target_ops *target, bfd *abfd;target, abfd
-# Handle special encoding of static variables in stabs debug info.
-F;const char *;static_transform_name;const char *name;name
# Set if the address in N_SO or N_FUN stabs may be zero.
v;int;sofun_address_maybe_missing;;;0;0;;0
# Return a string containing any flags for the given PC in the given FRAME.
f;std::string;get_pc_address_flags;frame_info *frame, CORE_ADDR pc;frame, pc;;default_get_pc_address_flags;;0
+# Read core file mappings
+m;void;read_core_file_mappings;struct bfd *cbfd, gdb::function_view<void (ULONGEST count)> pre_loop_cb, gdb::function_view<void (int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs, const char *filename)> loop_cb;cbfd, pre_loop_cb, loop_cb;;default_read_core_file_mappings;;0
+
EOF
}
/* Dynamic architecture support for GDB, the GNU debugger.
- Copyright (C) 1998-2020 Free Software Foundation, Inc.
+ Copyright (C) 1998-2021 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdb_obstack.h"
#include "infrun.h"
#include "osabi.h"
+#include "displaced-stepping.h"
struct floatformat;
struct ui_file;
struct syscalls_info;
struct thread_info;
struct ui_out;
+struct inferior;
#include "regcache.h"
if class_is_predicate_p
then
printf "\n"
- printf "extern int gdbarch_%s_p (struct gdbarch *gdbarch);\n" "$function"
+ printf "extern bool gdbarch_%s_p (struct gdbarch *gdbarch);\n" "$function"
fi
if class_is_variable_p
then
extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
extern void gdbarch_register (enum bfd_architecture architecture,
- gdbarch_init_ftype *,
- gdbarch_dump_tdep_ftype *);
+ gdbarch_init_ftype *,
+ gdbarch_dump_tdep_ftype *);
/* Return a freshly allocated, NULL terminated, array of the valid
extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
-extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
- struct gdbarch_data *data,
- void *pointer);
extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
unsigned int gdbarch_debug = GDBARCH_DEBUG;
static void
show_gdbarch_debug (struct ui_file *file, int from_tty,
- struct cmd_list_element *c, const char *value)
+ struct cmd_list_element *c, const char *value)
{
fprintf_filtered (file, _("Architecture debugging is %s.\\n"), value);
}
cat <<EOF
struct gdbarch *
gdbarch_alloc (const struct gdbarch_info *info,
- struct gdbarch_tdep *tdep)
+ struct gdbarch_tdep *tdep)
{
struct gdbarch *gdbarch;
cat <<EOF
if (!log.empty ())
internal_error (__FILE__, __LINE__,
- _("verify_gdbarch: the following are invalid ...%s"),
- log.c_str ());
+ _("verify_gdbarch: the following are invalid ...%s"),
+ log.c_str ());
}
EOF
gdb_nm_file = GDB_NM_FILE;
#endif
fprintf_unfiltered (file,
- "gdbarch_dump: GDB_NM_FILE = %s\\n",
- gdb_nm_file);
+ "gdbarch_dump: GDB_NM_FILE = %s\\n",
+ gdb_nm_file);
EOF
function_list | sort '-t;' -k 3 | while do_read
do
print="core_addr_to_string_nz (gdbarch->${function})"
;;
:* )
- fmt="%s"
+ fmt="%s"
print="plongest (gdbarch->${function})"
;;
* )
- fmt="%s"
+ fmt="%s"
;;
- esac
+ esac
printf " fprintf_unfiltered (file,\n"
printf " \"gdbarch_dump: %s = %s\\\\n\",\n" "$function" "$fmt"
printf " %s);\n" "$print"
if class_is_predicate_p
then
printf "\n"
- printf "int\n"
+ printf "bool\n"
printf "gdbarch_%s_p (struct gdbarch *gdbarch)\n" "$function"
printf "{\n"
- printf " gdb_assert (gdbarch != NULL);\n"
+ printf " gdb_assert (gdbarch != NULL);\n"
printf " return %s;\n" "$predicate"
printf "}\n"
fi
printf "gdbarch_%s (struct gdbarch *gdbarch, %s)\n" "$function" "$formal"
fi
printf "{\n"
- printf " gdb_assert (gdbarch != NULL);\n"
+ printf " gdb_assert (gdbarch != NULL);\n"
printf " gdb_assert (gdbarch->%s != NULL);\n" "$function"
if class_is_predicate_p && test -n "${predefault}"
then
else
params="${actual}"
fi
- fi
+ fi
if [ "x${returntype}" = "xvoid" ]
then
printf " gdbarch->%s (%s);\n" "$function" "$params"
printf "%s\n" "$returntype"
printf "gdbarch_%s (struct gdbarch *gdbarch)\n" "$function"
printf "{\n"
- printf " gdb_assert (gdbarch != NULL);\n"
+ printf " gdb_assert (gdbarch != NULL);\n"
if [ "x${invalid_p}" = "x0" ]
then
printf " /* Skip verify of %s, invalid_p == 0 */\n" "$function"
printf "%s\n" "$returntype"
printf "gdbarch_%s (struct gdbarch *gdbarch)\n" "$function"
printf "{\n"
- printf " gdb_assert (gdbarch != NULL);\n"
+ printf " gdb_assert (gdbarch != NULL);\n"
printf " if (gdbarch_debug >= 2)\n"
printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_%s called\\\\n\");\n" "$function"
printf " return gdbarch->%s;\n" "$function"
gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
}
-/* Initialize the current value of the specified per-architecture
- data-pointer. */
-
-void
-deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
- struct gdbarch_data *data,
- void *pointer)
-{
- gdb_assert (data->index < gdbarch->nr_data);
- gdb_assert (gdbarch->data[data->index] == NULL);
- gdb_assert (data->pre_init == NULL);
- gdbarch->data[data->index] = pointer;
-}
-
/* Return the current value of the specified per-architecture
data-pointer. */
data->init_p = 1;
}
else
- /* The architecture initialization hasn't completed - punt -
- hope that the caller knows what they are doing. Once
- deprecated_set_gdbarch_data has been initialized, this can be
- changed to an internal error. */
- return NULL;
+ internal_error (__FILE__, __LINE__,
+ _("gdbarch post-init data field can only be used "
+ "after gdbarch is fully initialised"));
gdb_assert (gdbarch->data[data->index] != NULL);
}
return gdbarch->data[data->index];
const struct bfd_arch_info *ap;
ap = bfd_lookup_arch (rego->bfd_architecture, 0);
if (ap == NULL)
- internal_error (__FILE__, __LINE__,
- _("gdbarch_architecture_names: multi-arch unknown"));
+ internal_error (__FILE__, __LINE__,
+ _("gdbarch_architecture_names: multi-arch unknown"));
do
- {
- append_name (&arches, &nr_arches, ap->printable_name);
- ap = ap->next;
- }
+ {
+ append_name (&arches, &nr_arches, ap->printable_name);
+ ap = ap->next;
+ }
while (ap != NULL);
}
append_name (&arches, &nr_arches, NULL);
void
gdbarch_register (enum bfd_architecture bfd_architecture,
- gdbarch_init_ftype *init,
+ gdbarch_init_ftype *init,
gdbarch_dump_tdep_ftype *dump_tdep)
{
struct gdbarch_registration **curr;
if (bfd_arch_info == NULL)
{
internal_error (__FILE__, __LINE__,
- _("gdbarch: Attempt to register "
+ _("gdbarch: Attempt to register "
"unknown architecture (%d)"),
- bfd_architecture);
+ bfd_architecture);
}
/* Check that we haven't seen this architecture before. */
for (curr = &gdbarch_registry;
{
if (bfd_architecture == (*curr)->bfd_architecture)
internal_error (__FILE__, __LINE__,
- _("gdbarch: Duplicate registration "
+ _("gdbarch: Duplicate registration "
"of architecture (%s)"),
- bfd_arch_info->printable_name);
+ bfd_arch_info->printable_name);
}
/* log it */
if (gdbarch_debug)
struct gdbarch_list *
gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
- const struct gdbarch_info *info)
+ const struct gdbarch_info *info)
{
for (; arches != NULL; arches = arches->next)
{
Set architecture debugging."), _("\\
Show architecture debugging."), _("\\
When non-zero, architecture debugging is enabled."),
- NULL,
- show_gdbarch_debug,
- &setdebuglist, &showdebuglist);
+ NULL,
+ show_gdbarch_debug,
+ &setdebuglist, &showdebuglist);
}
EOF
projects / deliverable / binutils-gdb.git / blobdiff