# 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 ) : ;;
# 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;bool;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
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, const void *other)> loop_cb;cbfd, pre_loop_cb, loop_cb;;default_read_core_file_mappings;;0
+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"
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
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"
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"
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