Remove gdbarch.sh

This patch runs gdbarch.py and removes gdbarch.sh.

3 files changed, 66 insertions, 1879 deletions

diff --git a/gdb/gdbarch-gen.h b/gdb/gdbarch-gen.h
index 3edf970..7d4b83a 100644
--- a/gdb/gdbarch-gen.h
+++ b/gdb/gdbarch-gen.h
@@ -20,7 +20,7 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
-/* This file was created with the aid of ``gdbarch.sh''.  */
+/* This file was created with the aid of ``gdbarch.py''.  */
 
 
 
@@ -124,11 +124,11 @@ extern void set_gdbarch_floatformat_for_type (struct gdbarch *gdbarch, gdbarch_f
    address in GDB have the same size and "look the same".  For such a
    target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
    / addr_bit will be set from it.
-  
+
    If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
    also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and
    gdbarch_address_to_pointer as well.
-  
+
    ptr_bit is the size of a pointer on the target */
 
 extern int gdbarch_ptr_bit (struct gdbarch *gdbarch);
@@ -145,10 +145,10 @@ extern void set_gdbarch_addr_bit (struct gdbarch *gdbarch, int addr_bit);
    DWARF2_ADDR_SIZE as defined by the target specific GCC back-end.
    Unfortunately there is no good way to determine this value.  Therefore
    dwarf2_addr_size simply defaults to the target pointer size.
-  
+
    dwarf2_addr_size is not used for .eh_frame FDEs, which are generally
    defined using the target's pointer size so far.
-  
+
    Note that dwarf2_addr_size only needs to be redefined by a target if the
    GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size,
    and if Dwarf versions < 4 need to be supported. */
@@ -371,7 +371,7 @@ extern void set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, gdbarch_
 
 /* Determine the address where a longjmp will land and save this address
    in PC.  Return nonzero on success.
-  
+
    FRAME corresponds to the longjmp frame. */
 
 extern bool gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch);
@@ -421,9 +421,9 @@ extern void set_gdbarch_integer_to_address (struct gdbarch *gdbarch, gdbarch_int
 /* Return the return-value convention that will be used by FUNCTION
    to return a value of type VALTYPE.  FUNCTION may be NULL in which
    case the return convention is computed based only on VALTYPE.
-  
+
    If READBUF is not NULL, extract the return value and save it in this buffer.
-  
+
    If WRITEBUF is not NULL, it contains a return value which will be
    stored into the appropriate register.  This can be used when we want
    to force the value returned by a function (see the "return" command
@@ -663,10 +663,10 @@ extern void set_gdbarch_memtag_granule_size (struct gdbarch *gdbarch, CORE_ADDR
 /* FIXME/cagney/2001-01-18: This should be split in two.  A target method that
    indicates if the target needs software single step.  An ISA method to
    implement it.
-  
+
    FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the
    target can single step.  If not, then implement single step using breakpoints.
-  
+
    Return a vector of addresses on which the software single step
    breakpoints should be inserted.  NULL means software single step is
    not used.
@@ -956,24 +956,24 @@ extern void set_gdbarch_max_insn_length (struct gdbarch *gdbarch, ULONGEST max_i
 
 /* Copy the instruction at FROM to TO, and make any adjustments
    necessary to single-step it at that address.
-  
+
    REGS holds the state the thread's registers will have before
    executing the copied instruction; the PC in REGS will refer to FROM,
    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.
-  
+
    For a general explanation of displaced stepping and how GDB uses it,
    see the comments in infrun.c.
-  
+
    The TO area is only guaranteed to have space for
    gdbarch_max_insn_length (arch) bytes, so this function must not
    write more bytes than that to that area.
-  
+
    If you do not provide this function, GDB assumes that the
    architecture does not support displaced stepping.
-  
+
    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. */
@@ -989,7 +989,7 @@ extern void set_gdbarch_displaced_step_copy_insn (struct gdbarch *gdbarch, gdbar
    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. */
 
@@ -1000,17 +1000,17 @@ extern void set_gdbarch_displaced_step_hw_singlestep (struct gdbarch *gdbarch, g
 /* Fix up the state resulting from successfully single-stepping a
    displaced instruction, to give the result we would have gotten from
    stepping the instruction in its original location.
-  
+
    REGS is the register state resulting from single-stepping the
    displaced instruction.
-  
+
    CLOSURE is the result from the matching call to
    gdbarch_displaced_step_copy_insn.
-  
+
    If you provide gdbarch_displaced_step_copy_insn.but not this
    function, then GDB assumes that no fixup is needed after
    single-stepping the instruction.
-  
+
    For a general explanation of displaced stepping and how GDB uses it,
    see the comments in infrun.c. */
 
@@ -1021,7 +1021,7 @@ extern void gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, struct displa
 extern void set_gdbarch_displaced_step_fixup (struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype *displaced_step_fixup);
 
 /* Prepare THREAD for it to displaced step the instruction at its current PC.
-  
+
    Throw an exception if any unexpected error happens. */
 
 extern bool gdbarch_displaced_step_prepare_p (struct gdbarch *gdbarch);
@@ -1137,7 +1137,7 @@ extern int gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch, enum gdb_signa
 extern void set_gdbarch_gdb_signal_to_target (struct gdbarch *gdbarch, gdbarch_gdb_signal_to_target_ftype *gdb_signal_to_target);
 
 /* Extra signal info inspection.
-  
+
    Return a type suitable to inspect extra signal information. */
 
 extern bool gdbarch_get_siginfo_type_p (struct gdbarch *gdbarch);
@@ -1177,9 +1177,9 @@ extern void set_gdbarch_syscalls_info (struct gdbarch *gdbarch, struct syscalls_
    A NULL-terminated array of prefixes used to mark an integer constant
    on the architecture's assembly.
    For example, on x86 integer constants are written as:
-  
-    $10 ;; integer constant 10
-  
+
+   $10 ;; integer constant 10
+
    in this case, this prefix would be the character `$'. */
 
 extern const char *const * gdbarch_stap_integer_prefixes (struct gdbarch *gdbarch);
@@ -1194,9 +1194,9 @@ extern void set_gdbarch_stap_integer_suffixes (struct gdbarch *gdbarch, const ch
 /* A NULL-terminated array of prefixes used to mark a register name on
    the architecture's assembly.
    For example, on x86 the register name is written as:
-  
-    %eax ;; register eax
-  
+
+   %eax ;; register eax
+
    in this case, this prefix would be the character `%'. */
 
 extern const char *const * gdbarch_stap_register_prefixes (struct gdbarch *gdbarch);
@@ -1211,11 +1211,11 @@ extern void set_gdbarch_stap_register_suffixes (struct gdbarch *gdbarch, const c
 /* A NULL-terminated array of prefixes used to mark a register
    indirection on the architecture's assembly.
    For example, on x86 the register indirection is written as:
-  
-    (%eax) ;; indirecting eax
-  
+
+   (%eax) ;; indirecting eax
+
    in this case, this prefix would be the charater `('.
-  
+
    Please note that we use the indirection prefix also for register
    displacement, e.g., `4(%eax)' on x86. */
 
@@ -1225,11 +1225,11 @@ extern void set_gdbarch_stap_register_indirection_prefixes (struct gdbarch *gdba
 /* A NULL-terminated array of suffixes used to mark a register
    indirection on the architecture's assembly.
    For example, on x86 the register indirection is written as:
-  
-    (%eax) ;; indirecting eax
-  
+
+   (%eax) ;; indirecting eax
+
    in this case, this prefix would be the charater `)'.
-  
+
    Please note that we use the indirection suffix also for register
    displacement, e.g., `4(%eax)' on x86. */
 
@@ -1237,7 +1237,7 @@ extern const char *const * gdbarch_stap_register_indirection_suffixes (struct gd
 extern void set_gdbarch_stap_register_indirection_suffixes (struct gdbarch *gdbarch, const char *const * stap_register_indirection_suffixes);
 
 /* Prefix(es) used to name a register using GDB's nomenclature.
-  
+
    For example, on PPC a register is represented by a number in the assembly
    language (e.g., `10' is the 10th general-purpose register).  However,
    inside GDB this same register has an `r' appended to its name, so the 10th
@@ -1252,13 +1252,13 @@ extern const char * gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch);
 extern void set_gdbarch_stap_gdb_register_suffix (struct gdbarch *gdbarch, const char * stap_gdb_register_suffix);
 
 /* Check if S is a single operand.
-  
+
    Single operands can be:
-    - Literal integers, e.g. `$10' on x86
-    - Register access, e.g. `%eax' on x86
-    - Register indirection, e.g. `(%eax)' on x86
-    - Register displacement, e.g. `4(%eax)' on x86
-  
+   - Literal integers, e.g. `$10' on x86
+   - Register access, e.g. `%eax' on x86
+   - Register indirection, e.g. `(%eax)' on x86
+   - Register displacement, e.g. `4(%eax)' on x86
+
    This function should check for these patterns on the string
    and return 1 if some were found, or zero otherwise.  Please try to match
    as much info as you can from the string, i.e., if you have to match
@@ -1271,20 +1271,20 @@ extern int gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, const char *
 extern void set_gdbarch_stap_is_single_operand (struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand);
 
 /* Function used to handle a "special case" in the parser.
-  
+
    A "special case" is considered to be an unknown token, i.e., a token
    that the parser does not know how to parse.  A good example of special
    case would be ARM's register displacement syntax:
-  
-    [R0, #4]  ;; displacing R0 by 4
-  
+
+   [R0, #4]  ;; displacing R0 by 4
+
    Since the parser assumes that a register displacement is of the form:
-  
-    <number> <indirection_prefix> <register_name> <indirection_suffix>
-  
+
+   <number> <indirection_prefix> <register_name> <indirection_suffix>
+
    it means that it will not be able to recognize and parse this odd syntax.
    Therefore, we should add a special case function that will handle this token.
-  
+
    This function should generate the proper expression form of the expression
    using GDB's internal expression mechanism (e.g., `write_exp_elt_opcode'
    and so on).  It should also return 1 if the parsing was successful, or zero
@@ -1299,7 +1299,7 @@ extern expr::operation_up gdbarch_stap_parse_special_token (struct gdbarch *gdba
 extern void set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype *stap_parse_special_token);
 
 /* Perform arch-dependent adjustments to a register name.
-  
+
    In very specific situations, it may be necessary for the register
    name present in a SystemTap probe's argument to be handled in a
    special way.  For example, on i386, GCC may over-optimize the
@@ -1307,19 +1307,19 @@ extern void set_gdbarch_stap_parse_special_token (struct gdbarch *gdbarch, gdbar
    such cases, the client that is reading and evaluating the SystemTap
    probe (ourselves) will need to actually fetch values from the wider
    version of the register in question.
-  
+
    To illustrate the example, consider the following probe argument
    (i386):
-  
-      4@%ax
-  
+
+   4@%ax
+
    This argument says that its value can be found at the %ax register,
    which is a 16-bit register.  However, the argument's prefix says
    that its type is "uint32_t", which is 32-bit in size.  Therefore, in
    this case, GDB should actually fetch the probe's value from register
    %eax, not %ax.  In this scenario, this function would actually
    replace the register name from %ax to %eax.
-  
+
    The rationale for this can be found at PR breakpoints/24541. */
 
 extern bool gdbarch_stap_adjust_register_p (struct gdbarch *gdbarch);
@@ -1403,19 +1403,19 @@ extern void set_gdbarch_guess_tracepoint_registers (struct gdbarch *gdbarch, gdb
 
 /* Return the "auto" target charset. */
 
-typedef const char * (gdbarch_auto_charset_ftype) (void);
+typedef const char * (gdbarch_auto_charset_ftype) ();
 extern const char * gdbarch_auto_charset (struct gdbarch *gdbarch);
 extern void set_gdbarch_auto_charset (struct gdbarch *gdbarch, gdbarch_auto_charset_ftype *auto_charset);
 
 /* Return the "auto" target wide charset. */
 
-typedef const char * (gdbarch_auto_wide_charset_ftype) (void);
+typedef const char * (gdbarch_auto_wide_charset_ftype) ();
 extern const char * gdbarch_auto_wide_charset (struct gdbarch *gdbarch);
 extern void set_gdbarch_auto_wide_charset (struct gdbarch *gdbarch, gdbarch_auto_wide_charset_ftype *auto_wide_charset);
 
 /* If non-empty, this is a file extension that will be opened in place
    of the file extension reported by the shared library list.
-  
+
    This is most useful for toolchains that use a post-linker tool,
    where the names of the files run on the target differ in extension
    compared to the names of the files GDB should load for debug info. */
@@ -1460,15 +1460,15 @@ extern void set_gdbarch_core_info_proc (struct gdbarch *gdbarch, gdbarch_core_in
 
 /* Iterate over all objfiles in the order that makes the most sense
    for the architecture to make global symbol searches.
-  
+
    CB is a callback function where OBJFILE is the objfile to be searched,
    and CB_DATA a pointer to user-defined data (the same data that is passed
    when calling this gdbarch method).  The iteration stops if this function
    returns nonzero.
-  
+
    CB_DATA is a pointer to some user-defined data to be passed to
    the callback.
-  
+
    If not NULL, CURRENT_OBJFILE corresponds to the objfile being
    inspected when the symbol search was requested. */
 
diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 3f96abe..5575ba2 100644
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -20,7 +20,7 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
-/* This file was created with the aid of ``gdbarch.sh''.  */
+/* This file was created with the aid of ``gdbarch.py''.  */
 
 
 /* Maintain the struct gdbarch object.  */
@@ -48,29 +48,6 @@ struct gdbarch
   unsigned nr_data;
   void **data;
 
-  /* Multi-arch values.
-
-     When extending this structure you must:
-
-     Add the field below.
-
-     Declare set/get functions and define the corresponding
-     macro in gdbarch.h.
-
-     gdbarch_alloc(): If zero/NULL is not a suitable default,
-     initialize the new field.
-
-     verify_gdbarch(): Confirm that the target updated the field
-     correctly.
-
-     gdbarch_dump(): Add a fprintf_unfiltered call so that the new
-     field is dumped out
-
-     get_gdbarch(): Implement the set/get functions (probably using
-     the macro's as shortcuts).
-
-     */
-
   int short_bit;
   int int_bit;
   int long_bit;
@@ -3876,7 +3853,7 @@ gdbarch_core_xfer_siginfo (struct gdbarch *gdbarch, gdb_byte *readbuf, ULONGEST
   gdb_assert (gdbarch->core_xfer_siginfo != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_core_xfer_siginfo called\n");
-  return gdbarch->core_xfer_siginfo (gdbarch,  readbuf, offset, len);
+  return gdbarch->core_xfer_siginfo (gdbarch, readbuf, offset, len);
 }
 
 void
diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
deleted file mode 100755
index 9675ef5..0000000
--- a/gdb/gdbarch.sh
+++ /dev/null
@@ -1,1790 +0,0 @@
-#!/bin/sh -u
-
-# Architecture commands for GDB, the GNU debugger.
-#
-# Copyright (C) 1998-2021 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/>.
-
-# Make certain that the script is not running in an internationalized
-# environment.
-LANG=C ; export LANG
-LC_ALL=C ; export LC_ALL
-
-# Format of the input table
-read="class returntype function formal actual staticdefault predefault postdefault invalid_p print garbage_at_eol"
-
-do_read ()
-{
-    comment=""
-    class=""
-    # On some SH's, 'read' trims leading and trailing whitespace by
-    # default (e.g., bash), while on others (e.g., dash), it doesn't.
-    # Set IFS to empty to disable the trimming everywhere.
-    # shellcheck disable=SC2162
-    while IFS='' read line
-    do
-	if test "${line}" = ""
-	then
-	    continue
-	elif test "${line}" = "#" -a "${comment}" = ""
-	then
-	    continue
-	elif expr "${line}" : "#" > /dev/null
-	then
-	    comment="${comment}
-${line}"
-	else
-
-	    # The semantics of IFS varies between different SH's.  Some
-	    # treat ``;;' as three fields while some treat it as just two.
-	    # Work around this by eliminating ``;;'' ....
-	    line="$(echo "${line}" | sed -e 's/;;/; ;/g' -e 's/;;/; ;/g')"
-
-	    OFS="${IFS}" ; IFS="[;]"
-	    eval read "${read}" <<EOF
-${line}
-EOF
-	    IFS="${OFS}"
-
-	    if test -n "${garbage_at_eol:-}"
-	    then
-		echo "Garbage at end-of-line in ${line}" 1>&2
-		kill $$
-		exit 1
-	    fi
-
-	    # .... and then going back through each field and strip out those
-	    # that ended up with just that space character.
-	    for r in ${read}
-	    do
-		if eval test "\"\${${r}}\" = ' '"
-		then
-		    eval "${r}="
-		fi
-	    done
-
-	    case "${class}" in
-		m ) staticdefault="${predefault:-}" ;;
-		M ) staticdefault="0" ;;
-		* ) test "${staticdefault}" || staticdefault=0 ;;
-	    esac
-
-	    case "${class}" in
-	    F | V | M )
-		case "${invalid_p:-}" in
-		"" )
-		    if test -n "${predefault}"
-		    then
-			#invalid_p="gdbarch->${function} == ${predefault}"
-			predicate="gdbarch->${function:-} != ${predefault}"
-		    elif class_is_variable_p
-		    then
-			predicate="gdbarch->${function} != 0"
-		    elif class_is_function_p
-		    then
-			predicate="gdbarch->${function} != NULL"
-		    fi
-		    ;;
-		* )
-		    echo "Predicate function ${function} with invalid_p." 1>&2
-		    kill $$
-		    exit 1
-		    ;;
-		esac
-	    esac
-
-	    #NOT YET: See gdbarch.log for basic verification of
-	    # database
-
-	    break
-	fi
-    done
-    if [ -n "${class}" ]
-    then
-	true
-    else
-	false
-    fi
-}
-
-
-fallback_default_p ()
-{
-    { [ -n "${postdefault:-}" ] && [ "x${invalid_p}" != "x0" ]; } \
-	|| { [ -n "${predefault}" ] && [ "x${invalid_p}" = "x0" ]; }
-}
-
-class_is_variable_p ()
-{
-    case "${class}" in
-	*v* | *V* ) true ;;
-	* ) false ;;
-    esac
-}
-
-class_is_function_p ()
-{
-    case "${class}" in
-	*f* | *F* | *m* | *M* ) true ;;
-	* ) false ;;
-    esac
-}
-
-class_is_multiarch_p ()
-{
-    case "${class}" in
-	*m* | *M* ) true ;;
-	* ) false ;;
-    esac
-}
-
-class_is_predicate_p ()
-{
-    case "${class}" in
-	*F* | *V* | *M* ) true ;;
-	* ) false ;;
-    esac
-}
-
-class_is_info_p ()
-{
-    case "${class}" in
-	*i* ) true ;;
-	* ) false ;;
-    esac
-}
-
-
-# dump out/verify the doco
-for field in ${read}
-do
-  case ${field} in
-
-    class ) : ;;
-
-	# # -> line disable
-	# f -> function
-	#   hiding a function
-	# F -> function + predicate
-	#   hiding a function + predicate to test function validity
-	# v -> variable
-	#   hiding a variable
-	# V -> variable + predicate
-	#   hiding a variable + predicate to test variables validity
-	# i -> set from info
-	#   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
-	#   hiding a multi-arch function + predicate to test function validity
-
-    returntype ) : ;;
-
-	# For functions, the return type; for variables, the data type
-
-    function ) : ;;
-
-	# For functions, the member function name; for variables, the
-	# variable name.  Member function names are always prefixed with
-	# ``gdbarch_'' for name-space purity.
-
-    formal ) : ;;
-
-	# The formal argument list.  It is assumed that the formal
-	# argument list includes the actual name of each list element.
-	# A function with no arguments shall have ``void'' as the
-	# formal argument list.
-
-    actual ) : ;;
-
-	# The list of actual arguments.  The arguments specified shall
-	# match the FORMAL list given above.  Functions with out
-	# arguments leave this blank.
-
-    staticdefault ) : ;;
-
-	# To help with the GDB startup a static gdbarch object is
-	# created.  STATICDEFAULT is the value to insert into that
-	# static gdbarch object.  Since this a static object only
-	# simple expressions can be used.
-
-	# If STATICDEFAULT is empty, zero is used.
-
-    predefault ) : ;;
-
-	# An initial value to assign to MEMBER of the freshly
-	# malloc()ed gdbarch object.  After initialization, the
-	# freshly malloc()ed object is passed to the target
-	# architecture code for further updates.
-
-	# If PREDEFAULT is empty, zero is used.
-
-	# A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
-	# INVALID_P are specified, PREDEFAULT will be used as the
-	# default for the non- multi-arch target.
-
-	# A zero PREDEFAULT function will force the fallback to call
-	# internal_error().
-
-	# Variable declarations can refer to ``gdbarch'' which will
-	# contain the current architecture.  Care should be taken.
-
-    postdefault ) : ;;
-
-	# A value to assign to MEMBER of the new gdbarch object should
-	# the target architecture code fail to change the PREDEFAULT
-	# value.
-
-	# If POSTDEFAULT is empty, no post update is performed.
-
-	# If both INVALID_P and POSTDEFAULT are non-empty then
-	# INVALID_P will be used to determine if MEMBER should be
-	# changed to POSTDEFAULT.
-
-	# If a non-empty POSTDEFAULT and a zero INVALID_P are
-	# specified, POSTDEFAULT will be used as the default for the
-	# non- multi-arch target (regardless of the value of
-	# PREDEFAULT).
-
-	# You cannot specify both a zero INVALID_P and a POSTDEFAULT.
-
-	# Variable declarations can refer to ``gdbarch'' which
-	# will contain the current architecture.  Care should be
-	# taken.
-
-    invalid_p ) : ;;
-
-	# A predicate equation that validates MEMBER.  Non-zero is
-	# returned if the code creating the new architecture failed to
-	# initialize MEMBER or the initialized the member is invalid.
-	# If POSTDEFAULT is non-empty then MEMBER will be updated to
-	# that value.  If POSTDEFAULT is empty then internal_error()
-	# is called.
-
-	# If INVALID_P is empty, a check that MEMBER is no longer
-	# equal to PREDEFAULT is used.
-
-	# The expression ``0'' disables the INVALID_P check making
-	# PREDEFAULT a legitimate value.
-
-	# See also PREDEFAULT and POSTDEFAULT.
-
-    print ) : ;;
-
-	# An optional expression that convers MEMBER to a value
-	# suitable for formatting using %s.
-
-	# If PRINT is empty, core_addr_to_string_nz (for CORE_ADDR)
-	# or plongest (anything else) is used.
-
-    garbage_at_eol ) : ;;
-
-	# Catches stray fields.
-
-    *)
-	echo "Bad field ${field}"
-	exit 1;;
-  esac
-done
-
-
-function_list ()
-{
-  # See below (DOCO) for description of each field
-  cat <<EOF
-i;const struct bfd_arch_info *;bfd_arch_info;;;&bfd_default_arch_struct;;;;gdbarch_bfd_arch_info (gdbarch)->printable_name
-#
-i;enum bfd_endian;byte_order;;;BFD_ENDIAN_BIG
-i;enum bfd_endian;byte_order_for_code;;;BFD_ENDIAN_BIG
-#
-i;enum gdb_osabi;osabi;;;GDB_OSABI_UNKNOWN
-#
-i;const struct target_desc *;target_desc;;;;;;;host_address_to_string (gdbarch->target_desc)
-
-# Number of bits in a short or unsigned short for the target machine.
-v;int;short_bit;;;8 * sizeof (short);2*TARGET_CHAR_BIT;;0
-# Number of bits in an int or unsigned int for the target machine.
-v;int;int_bit;;;8 * sizeof (int);4*TARGET_CHAR_BIT;;0
-# Number of bits in a long or unsigned long for the target machine.
-v;int;long_bit;;;8 * sizeof (long);4*TARGET_CHAR_BIT;;0
-# Number of bits in a long long or unsigned long long for the target
-# machine.
-v;int;long_long_bit;;;8 * sizeof (LONGEST);2*gdbarch->long_bit;;0
-
-# 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
-v;const struct floatformat **;float_format;;;;;floatformats_ieee_single;;pformat (gdbarch->float_format)
-v;int;double_bit;;;8 * sizeof (double);8*TARGET_CHAR_BIT;;0
-v;const struct floatformat **;double_format;;;;;floatformats_ieee_double;;pformat (gdbarch->double_format)
-v;int;long_double_bit;;;8 * sizeof (long double);8*TARGET_CHAR_BIT;;0
-v;const struct floatformat **;long_double_format;;;;;floatformats_ieee_double;;pformat (gdbarch->long_double_format)
-
-# The ABI default bit-size for "wchar_t".  wchar_t is a built-in type
-# starting with C++11.
-v;int;wchar_bit;;;8 * sizeof (wchar_t);4*TARGET_CHAR_BIT;;0
-# One if \`wchar_t' is signed, zero if unsigned.
-v;int;wchar_signed;;;1;-1;1
-
-# Returns the floating-point format to be used for values of length LENGTH.
-# NAME, if non-NULL, is the type name, which may be used to distinguish
-# different target formats of the same length.
-m;const struct floatformat **;floatformat_for_type;const char *name, int length;name, length;0;default_floatformat_for_type;;0
-
-# For most targets, a pointer on the target and its representation as an
-# address in GDB have the same size and "look the same".  For such a
-# target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit
-# / addr_bit will be set from it.
-#
-# If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably
-# also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and
-# gdbarch_address_to_pointer as well.
-#
-# ptr_bit is the size of a pointer on the target
-v;int;ptr_bit;;;8 * sizeof (void*);gdbarch->int_bit;;0
-# addr_bit is the size of a target address as represented in gdb
-v;int;addr_bit;;;8 * sizeof (void*);0;gdbarch_ptr_bit (gdbarch);
-#
-# dwarf2_addr_size is the target address size as used in the Dwarf debug
-# info.  For .debug_frame FDEs, this is supposed to be the target address
-# size from the associated CU header, and which is equivalent to the
-# DWARF2_ADDR_SIZE as defined by the target specific GCC back-end.
-# Unfortunately there is no good way to determine this value.  Therefore
-# dwarf2_addr_size simply defaults to the target pointer size.
-#
-# dwarf2_addr_size is not used for .eh_frame FDEs, which are generally
-# defined using the target's pointer size so far.
-#
-# Note that dwarf2_addr_size only needs to be redefined by a target if the
-# GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size,
-# and if Dwarf versions < 4 need to be supported.
-v;int;dwarf2_addr_size;;;sizeof (void*);0;gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
-#
-# One if \`char' acts like \`signed char', zero if \`unsigned char'.
-v;int;char_signed;;;1;-1;1
-#
-F;CORE_ADDR;read_pc;readable_regcache *regcache;regcache
-F;void;write_pc;struct regcache *regcache, CORE_ADDR val;regcache, val
-# Function for getting target's idea of a frame pointer.  FIXME: GDB's
-# whole scheme for dealing with "frames" and "frame pointers" needs a
-# serious shakedown.
-m;void;virtual_frame_pointer;CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset;pc, frame_regnum, frame_offset;0;legacy_virtual_frame_pointer;;0
-#
-M;enum register_status;pseudo_register_read;readable_regcache *regcache, int cookednum, gdb_byte *buf;regcache, cookednum, buf
-# Read a register into a new struct value.  If the register is wholly
-# or partly unavailable, this should call mark_value_bytes_unavailable
-# as appropriate.  If this is defined, then pseudo_register_read will
-# never be called.
-M;struct value *;pseudo_register_read_value;readable_regcache *regcache, int cookednum;regcache, cookednum
-M;void;pseudo_register_write;struct regcache *regcache, int cookednum, const gdb_byte *buf;regcache, cookednum, buf
-#
-v;int;num_regs;;;0;-1
-# This macro gives the number of pseudo-registers that live in the
-# register namespace but do not get fetched or stored on the target.
-# These pseudo-registers may be aliases for other registers,
-# combinations of other registers, or they may be computed by GDB.
-v;int;num_pseudo_regs;;;0;0;;0
-
-# Assemble agent expression bytecode to collect pseudo-register REG.
-# Return -1 if something goes wrong, 0 otherwise.
-M;int;ax_pseudo_register_collect;struct agent_expr *ax, int reg;ax, reg
-
-# Assemble agent expression bytecode to push the value of pseudo-register
-# REG on the interpreter stack.
-# Return -1 if something goes wrong, 0 otherwise.
-M;int;ax_pseudo_register_push_stack;struct agent_expr *ax, int reg;ax, reg
-
-# Some architectures can display additional information for specific
-# signals.
-# UIOUT is the output stream where the handler will place information.
-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
-# all (-1).
-# gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP.
-v;int;sp_regnum;;;-1;-1;;0
-v;int;pc_regnum;;;-1;-1;;0
-v;int;ps_regnum;;;-1;-1;;0
-v;int;fp0_regnum;;;0;-1;;0
-# Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
-m;int;stab_reg_to_regnum;int stab_regnr;stab_regnr;;no_op_reg_to_regnum;;0
-# Provide a default mapping from a ecoff register number to a gdb REGNUM.
-m;int;ecoff_reg_to_regnum;int ecoff_regnr;ecoff_regnr;;no_op_reg_to_regnum;;0
-# Convert from an sdb register number to an internal gdb register number.
-m;int;sdb_reg_to_regnum;int sdb_regnr;sdb_regnr;;no_op_reg_to_regnum;;0
-# Provide a default mapping from a DWARF2 register number to a gdb REGNUM.
-# Return -1 for bad REGNUM.  Note: Several targets get this wrong.
-m;int;dwarf2_reg_to_regnum;int dwarf2_regnr;dwarf2_regnr;;no_op_reg_to_regnum;;0
-m;const char *;register_name;int regnr;regnr;;0
-
-# Return the type of a register specified by the architecture.  Only
-# the register cache should call this function directly; others should
-# use "register_type".
-M;struct type *;register_type;int reg_nr;reg_nr
-
-# Generate a dummy frame_id for THIS_FRAME assuming that the frame is
-# a dummy frame.  A dummy frame is created before an inferior call,
-# the frame_id returned here must match the frame_id that was built
-# for the inferior call.  Usually this means the returned frame_id's
-# stack address should match the address returned by
-# gdbarch_push_dummy_call, and the returned frame_id's code address
-# should match the address at which the breakpoint was set in the dummy
-# frame.
-m;struct frame_id;dummy_id;struct frame_info *this_frame;this_frame;;default_dummy_id;;0
-# Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete
-# deprecated_fp_regnum.
-v;int;deprecated_fp_regnum;;;-1;-1;;0
-
-M;CORE_ADDR;push_dummy_call;struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr;function, regcache, bp_addr, nargs, args, sp, return_method, struct_addr
-v;int;call_dummy_location;;;;AT_ENTRY_POINT;;0
-M;CORE_ADDR;push_dummy_code;CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache;sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache
-
-# Return true if the code of FRAME is writable.
-m;int;code_of_frame_writable;struct frame_info *frame;frame;;default_code_of_frame_writable;;0
-
-m;void;print_registers_info;struct ui_file *file, struct frame_info *frame, int regnum, int all;file, frame, regnum, all;;default_print_registers_info;;0
-m;void;print_float_info;struct ui_file *file, struct frame_info *frame, const char *args;file, frame, args;;default_print_float_info;;0
-M;void;print_vector_info;struct ui_file *file, struct frame_info *frame, const char *args;file, frame, args
-# MAP a GDB RAW register number onto a simulator register number.  See
-# also include/...-sim.h.
-m;int;register_sim_regno;int reg_nr;reg_nr;;legacy_register_sim_regno;;0
-m;int;cannot_fetch_register;int regnum;regnum;;cannot_register_not;;0
-m;int;cannot_store_register;int regnum;regnum;;cannot_register_not;;0
-
-# Determine the address where a longjmp will land and save this address
-# in PC.  Return nonzero on success.
-#
-# FRAME corresponds to the longjmp frame.
-F;int;get_longjmp_target;struct frame_info *frame, CORE_ADDR *pc;frame, pc
-
-#
-v;int;believe_pcc_promotion;;;;;;;
-#
-m;int;convert_register_p;int regnum, struct type *type;regnum, type;0;generic_convert_register_p;;0
-f;int;register_to_value;struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep;frame, regnum, type, buf, optimizedp, unavailablep;0
-f;void;value_to_register;struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf;frame, regnum, type, buf;0
-# Construct a value representing the contents of register REGNUM in
-# frame FRAME_ID, interpreted as type TYPE.  The routine needs to
-# allocate and return a struct value with all value attributes
-# (but not the value contents) filled in.
-m;struct value *;value_from_register;struct type *type, int regnum, struct frame_id frame_id;type, regnum, frame_id;;default_value_from_register;;0
-#
-m;CORE_ADDR;pointer_to_address;struct type *type, const gdb_byte *buf;type, buf;;unsigned_pointer_to_address;;0
-m;void;address_to_pointer;struct type *type, gdb_byte *buf, CORE_ADDR addr;type, buf, addr;;unsigned_address_to_pointer;;0
-M;CORE_ADDR;integer_to_address;struct type *type, const gdb_byte *buf;type, buf
-
-# Return the return-value convention that will be used by FUNCTION
-# to return a value of type VALTYPE.  FUNCTION may be NULL in which
-# case the return convention is computed based only on VALTYPE.
-#
-# If READBUF is not NULL, extract the return value and save it in this buffer.
-#
-# If WRITEBUF is not NULL, it contains a return value which will be
-# stored into the appropriate register.  This can be used when we want
-# to force the value returned by a function (see the "return" command
-# for instance).
-M;enum return_value_convention;return_value;struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf;function, valtype, regcache, readbuf, writebuf
-
-# Return true if the return value of function is stored in the first hidden
-# parameter.  In theory, this feature should be language-dependent, specified
-# by language and its ABI, such as C++.  Unfortunately, compiler may
-# implement it to a target-dependent feature.  So that we need such hook here
-# to be aware of this in GDB.
-m;int;return_in_first_hidden_param_p;struct type *type;type;;default_return_in_first_hidden_param_p;;0
-
-m;CORE_ADDR;skip_prologue;CORE_ADDR ip;ip;0;0
-M;CORE_ADDR;skip_main_prologue;CORE_ADDR ip;ip
-# On some platforms, a single function may provide multiple entry points,
-# e.g. one that is used for function-pointer calls and a different one
-# that is used for direct function calls.
-# In order to ensure that breakpoints set on the function will trigger
-# no matter via which entry point the function is entered, a platform
-# may provide the skip_entrypoint callback.  It is called with IP set
-# to the main entry point of a function (as determined by the symbol table),
-# and should return the address of the innermost entry point, where the
-# actual breakpoint needs to be set.  Note that skip_entrypoint is used
-# by GDB common code even when debugging optimized code, where skip_prologue
-# is not used.
-M;CORE_ADDR;skip_entrypoint;CORE_ADDR ip;ip
-
-f;int;inner_than;CORE_ADDR lhs, CORE_ADDR rhs;lhs, rhs;0;0
-m;const gdb_byte *;breakpoint_from_pc;CORE_ADDR *pcptr, int *lenptr;pcptr, lenptr;0;default_breakpoint_from_pc;;0
-
-# Return the breakpoint kind for this target based on *PCPTR.
-m;int;breakpoint_kind_from_pc;CORE_ADDR *pcptr;pcptr;;0;
-
-# Return the software breakpoint from KIND.  KIND can have target
-# specific meaning like the Z0 kind parameter.
-# SIZE is set to the software breakpoint's length in memory.
-m;const gdb_byte *;sw_breakpoint_from_kind;int kind, int *size;kind, size;;NULL;;0
-
-# Return the breakpoint kind for this target based on the current
-# processor state (e.g. the current instruction mode on ARM) and the
-# *PCPTR.  In default, it is gdbarch->breakpoint_kind_from_pc.
-m;int;breakpoint_kind_from_current_state;struct regcache *regcache, CORE_ADDR *pcptr;regcache, pcptr;0;default_breakpoint_kind_from_current_state;;0
-
-M;CORE_ADDR;adjust_breakpoint_address;CORE_ADDR bpaddr;bpaddr
-m;int;memory_insert_breakpoint;struct bp_target_info *bp_tgt;bp_tgt;0;default_memory_insert_breakpoint;;0
-m;int;memory_remove_breakpoint;struct bp_target_info *bp_tgt;bp_tgt;0;default_memory_remove_breakpoint;;0
-v;CORE_ADDR;decr_pc_after_break;;;0;;;0
-
-# A function can be addressed by either it's "pointer" (possibly a
-# descriptor address) or "entry point" (first executable instruction).
-# The method "convert_from_func_ptr_addr" converting the former to the
-# latter.  gdbarch_deprecated_function_start_offset is being used to implement
-# a simplified subset of that functionality - the function's address
-# corresponds to the "function pointer" and the function's start
-# corresponds to the "function entry point" - and hence is redundant.
-
-v;CORE_ADDR;deprecated_function_start_offset;;;0;;;0
-
-# Return the remote protocol register number associated with this
-# register.  Normally the identity mapping.
-m;int;remote_register_number;int regno;regno;;default_remote_register_number;;0
-
-# Fetch the target specific address used to represent a load module.
-F;CORE_ADDR;fetch_tls_load_module_address;struct objfile *objfile;objfile
-
-# Return the thread-local address at OFFSET in the thread-local
-# storage for the thread PTID and the shared library or executable
-# file given by LM_ADDR.  If that block of thread-local storage hasn't
-# been allocated yet, this function may throw an error.  LM_ADDR may
-# be zero for statically linked multithreaded inferiors.
-
-M;CORE_ADDR;get_thread_local_address;ptid_t ptid, CORE_ADDR lm_addr, CORE_ADDR offset;ptid, lm_addr, offset
-#
-v;CORE_ADDR;frame_args_skip;;;0;;;0
-m;CORE_ADDR;unwind_pc;struct frame_info *next_frame;next_frame;;default_unwind_pc;;0
-m;CORE_ADDR;unwind_sp;struct frame_info *next_frame;next_frame;;default_unwind_sp;;0
-# DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
-# frame-base.  Enable frame-base before frame-unwind.
-F;int;frame_num_args;struct frame_info *frame;frame
-#
-M;CORE_ADDR;frame_align;CORE_ADDR address;address
-m;int;stabs_argument_has_addr;struct type *type;type;;default_stabs_argument_has_addr;;0
-v;int;frame_red_zone_size
-#
-m;CORE_ADDR;convert_from_func_ptr_addr;CORE_ADDR addr, struct target_ops *targ;addr, targ;;convert_from_func_ptr_addr_identity;;0
-# On some machines there are bits in addresses which are not really
-# part of the address, but are used by the kernel, the hardware, etc.
-# for special purposes.  gdbarch_addr_bits_remove takes out any such bits so
-# we get a "real" address such as one would find in a symbol table.
-# This is used only for addresses of instructions, and even then I'm
-# not sure it's used in all contexts.  It exists to deal with there
-# being a few stray bits in the PC which would mislead us, not as some
-# sort of generic thing to handle alignment or segmentation (it's
-# possible it should be in TARGET_READ_PC instead).
-m;CORE_ADDR;addr_bits_remove;CORE_ADDR addr;addr;;core_addr_identity;;0
-
-# On some machines, not all bits of an address word are significant.
-# For example, on AArch64, the top bits of an address known as the "tag"
-# are ignored by the kernel, the hardware, etc. and can be regarded as
-# additional data associated with the address.
-v;int;significant_addr_bit;;;;;;0
-
-# Return a string representation of the memory tag TAG.
-m;std::string;memtag_to_string;struct value *tag;tag;;default_memtag_to_string;;0
-
-# Return true if ADDRESS contains a tag and false otherwise.  ADDRESS
-# must be either a pointer or a reference type.
-m;bool;tagged_address_p;struct value *address;address;;default_tagged_address_p;;0
-
-# Return true if the tag from ADDRESS matches the memory tag for that
-# particular address.  Return false otherwise.
-m;bool;memtag_matches_p;struct value *address;address;;default_memtag_matches_p;;0
-
-# Set the tags of type TAG_TYPE, for the memory address range
-# [ADDRESS, ADDRESS + LENGTH) to TAGS.
-# Return true if successful and false otherwise.
-m;bool;set_memtags;struct value *address, size_t length, const gdb::byte_vector \&tags, memtag_type tag_type;address, length, tags, tag_type;;default_set_memtags;;0
-
-# Return the tag of type TAG_TYPE associated with the memory address ADDRESS,
-# assuming ADDRESS is tagged.
-m;struct value *;get_memtag;struct value *address, memtag_type tag_type;address, tag_type;;default_get_memtag;;0
-
-# memtag_granule_size is the size of the allocation tag granule, for
-# architectures that support memory tagging.
-# This is 0 for architectures that do not support memory tagging.
-# For a non-zero value, this represents the number of bytes of memory per tag.
-v;CORE_ADDR;memtag_granule_size;;;;;;0
-
-# FIXME/cagney/2001-01-18: This should be split in two.  A target method that
-# indicates if the target needs software single step.  An ISA method to
-# implement it.
-#
-# FIXME/cagney/2001-01-18: The logic is backwards.  It should be asking if the
-# target can single step.  If not, then implement single step using breakpoints.
-#
-# Return a vector of addresses on which the software single step
-# breakpoints should be inserted.  NULL means software single step is
-# not used.
-# Multiple breakpoints may be inserted for some instructions such as
-# conditional branch.  However, each implementation must always evaluate
-# the condition and only put the breakpoint at the branch destination if
-# the condition is true, so that we ensure forward progress when stepping
-# past a conditional branch to self.
-F;std::vector<CORE_ADDR>;software_single_step;struct regcache *regcache;regcache
-
-# Return non-zero if the processor is executing a delay slot and a
-# further single-step is needed before the instruction finishes.
-M;int;single_step_through_delay;struct frame_info *frame;frame
-# FIXME: cagney/2003-08-28: Need to find a better way of selecting the
-# disassembler.  Perhaps objdump can handle it?
-f;int;print_insn;bfd_vma vma, struct disassemble_info *info;vma, info;;default_print_insn;;0
-f;CORE_ADDR;skip_trampoline_code;struct frame_info *frame, CORE_ADDR pc;frame, pc;;generic_skip_trampoline_code;;0
-
-
-# If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER
-# evaluates non-zero, this is the address where the debugger will place
-# a step-resume breakpoint to get us past the dynamic linker.
-m;CORE_ADDR;skip_solib_resolver;CORE_ADDR pc;pc;;generic_skip_solib_resolver;;0
-# Some systems also have trampoline code for returning from shared libs.
-m;int;in_solib_return_trampoline;CORE_ADDR pc, const char *name;pc, name;;generic_in_solib_return_trampoline;;0
-
-# Return true if PC lies inside an indirect branch thunk.
-m;bool;in_indirect_branch_thunk;CORE_ADDR pc;pc;;default_in_indirect_branch_thunk;;0
-
-# A target might have problems with watchpoints as soon as the stack
-# frame of the current function has been destroyed.  This mostly happens
-# as the first action in a function's epilogue.  stack_frame_destroyed_p()
-# is defined to return a non-zero value if either the given addr is one
-# instruction after the stack destroying instruction up to the trailing
-# return instruction or if we can figure out that the stack frame has
-# already been invalidated regardless of the value of addr.  Targets
-# which don't suffer from that problem could just let this functionality
-# untouched.
-m;int;stack_frame_destroyed_p;CORE_ADDR addr;addr;0;generic_stack_frame_destroyed_p;;0
-# Process an ELF symbol in the minimal symbol table in a backend-specific
-# way.  Normally this hook is supposed to do nothing, however if required,
-# then this hook can be used to apply tranformations to symbols that are
-# considered special in some way.  For example the MIPS backend uses it
-# to interpret \`st_other' information to mark compressed code symbols so
-# that they can be treated in the appropriate manner in the processing of
-# the main symbol table and DWARF-2 records.
-F;void;elf_make_msymbol_special;asymbol *sym, struct minimal_symbol *msym;sym, msym
-f;void;coff_make_msymbol_special;int val, struct minimal_symbol *msym;val, msym;;default_coff_make_msymbol_special;;0
-# Process a symbol in the main symbol table in a backend-specific way.
-# Normally this hook is supposed to do nothing, however if required,
-# then this hook can be used to apply tranformations to symbols that
-# are considered special in some way.  This is currently used by the
-# MIPS backend to make sure compressed code symbols have the ISA bit
-# set.  This in turn is needed for symbol values seen in GDB to match
-# the values used at the runtime by the program itself, for function
-# and label references.
-f;void;make_symbol_special;struct symbol *sym, struct objfile *objfile;sym, objfile;;default_make_symbol_special;;0
-# Adjust the address retrieved from a DWARF-2 record other than a line
-# entry in a backend-specific way.  Normally this hook is supposed to
-# return the address passed unchanged, however if that is incorrect for
-# any reason, then this hook can be used to fix the address up in the
-# required manner.  This is currently used by the MIPS backend to make
-# sure addresses in FDE, range records, etc. referring to compressed
-# code have the ISA bit set, matching line information and the symbol
-# table.
-f;CORE_ADDR;adjust_dwarf2_addr;CORE_ADDR pc;pc;;default_adjust_dwarf2_addr;;0
-# Adjust the address updated by a line entry in a backend-specific way.
-# Normally this hook is supposed to return the address passed unchanged,
-# however in the case of inconsistencies in these records, this hook can
-# be used to fix them up in the required manner.  This is currently used
-# by the MIPS backend to make sure all line addresses in compressed code
-# are presented with the ISA bit set, which is not always the case.  This
-# in turn ensures breakpoint addresses are correctly matched against the
-# stop PC.
-f;CORE_ADDR;adjust_dwarf2_line;CORE_ADDR addr, int rel;addr, rel;;default_adjust_dwarf2_line;;0
-v;int;cannot_step_breakpoint;;;0;0;;0
-# See comment in target.h about continuable, steppable and
-# non-steppable watchpoints.
-v;int;have_nonsteppable_watchpoint;;;0;0;;0
-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 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.
-F;CORE_ADDR;fetch_pointer_argument;struct frame_info *frame, int argi, struct type *type;frame, argi, type
-
-# Iterate over all supported register notes in a core file.  For each
-# supported register note section, the iterator must call CB and pass
-# CB_DATA unchanged.  If REGCACHE is not NULL, the iterator can limit
-# the supported register note sections based on the current register
-# values.  Otherwise it should enumerate all supported register note
-# sections.
-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;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
-
-# Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from
-# core file into buffer READBUF with length LEN.  Return the number of bytes read
-# (zero indicates failure).
-# failed, otherwise, return the red length of READBUF.
-M;ULONGEST;core_xfer_shared_libraries;gdb_byte *readbuf, ULONGEST offset, ULONGEST len;readbuf, offset, len
-
-# Read offset OFFSET of TARGET_OBJECT_LIBRARIES_AIX formatted shared
-# libraries list from core file into buffer READBUF with length LEN.
-# Return the number of bytes read (zero indicates failure).
-M;ULONGEST;core_xfer_shared_libraries_aix;gdb_byte *readbuf, ULONGEST offset, ULONGEST len;readbuf, offset, len
-
-# How the core target converts a PTID from a core file to a string.
-M;std::string;core_pid_to_str;ptid_t ptid;ptid
-
-# How the core target extracts the name of a thread from a core file.
-M;const char *;core_thread_name;struct thread_info *thr;thr
-
-# Read offset OFFSET of TARGET_OBJECT_SIGNAL_INFO signal information
-# from core file into buffer READBUF with length LEN.  Return the number
-# of bytes read (zero indicates EOF, a negative value indicates failure).
-M;LONGEST;core_xfer_siginfo;gdb_byte *readbuf, ULONGEST offset, ULONGEST len; readbuf, offset, len
-
-# BFD target to use when generating a core file.
-V;const char *;gcore_bfd_target;;;0;0;;;pstring (gdbarch->gcore_bfd_target)
-
-# If the elements of C++ vtables are in-place function descriptors rather
-# than normal function pointers (which may point to code or a descriptor),
-# set this to one.
-v;int;vtable_function_descriptors;;;0;0;;0
-
-# Set if the least significant bit of the delta is used instead of the least
-# significant bit of the pfn for pointers to virtual member functions.
-v;int;vbit_in_delta;;;0;0;;0
-
-# Advance PC to next instruction in order to skip a permanent breakpoint.
-f;void;skip_permanent_breakpoint;struct regcache *regcache;regcache;default_skip_permanent_breakpoint;default_skip_permanent_breakpoint;;0
-
-# The maximum length of an instruction on this architecture in bytes.
-V;ULONGEST;max_insn_length;;;0;0
-
-# Copy the instruction at FROM to TO, and make any adjustments
-# necessary to single-step it at that address.
-#
-# REGS holds the state the thread's registers will have before
-# executing the copied instruction; the PC in REGS will refer to FROM,
-# 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.
-#
-# For a general explanation of displaced stepping and how GDB uses it,
-# see the comments in infrun.c.
-#
-# The TO area is only guaranteed to have space for
-# gdbarch_max_insn_length (arch) bytes, so this function must not
-# write more bytes than that to that area.
-#
-# If you do not provide this function, GDB assumes that the
-# architecture does not support displaced stepping.
-#
-# 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_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 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;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
-# stepping the instruction in its original location.
-#
-# REGS is the register state resulting from single-stepping the
-# displaced instruction.
-#
-# CLOSURE is the result from the matching call to
-# gdbarch_displaced_step_copy_insn.
-#
-# If you provide gdbarch_displaced_step_copy_insn.but not this
-# function, then GDB assumes that no fixup is needed after
-# single-stepping the instruction.
-#
-# 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_copy_insn_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs;closure, from, to, regs;;NULL
-
-# Prepare THREAD for it to displaced step the instruction at its current PC.
-#
-# 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
-# relocate is currently at.  On input, TO points to the destination
-# where we want the instruction to be copied (and possibly adjusted)
-# to.  On output, it points to one past the end of the resulting
-# instruction(s).  The effect of executing the instruction at TO shall
-# be the same as if executing it at FROM.  For example, call
-# instructions that implicitly push the return address on the stack
-# should be adjusted to return to the instruction after OLDLOC;
-# relative branches, and other PC-relative instructions need the
-# offset adjusted; etc.
-M;void;relocate_instruction;CORE_ADDR *to, CORE_ADDR from;to, from;;NULL
-
-# Refresh overlay mapped state for section OSECT.
-F;void;overlay_update;struct obj_section *osect;osect
-
-M;const struct target_desc *;core_read_description;struct target_ops *target, bfd *abfd;target, abfd
-
-# Set if the address in N_SO or N_FUN stabs may be zero.
-v;int;sofun_address_maybe_missing;;;0;0;;0
-
-# Parse the instruction at ADDR storing in the record execution log
-# the registers REGCACHE and memory ranges that will be affected when
-# the instruction executes, along with their current values.
-# Return -1 if something goes wrong, 0 otherwise.
-M;int;process_record;struct regcache *regcache, CORE_ADDR addr;regcache, addr
-
-# Save process state after a signal.
-# Return -1 if something goes wrong, 0 otherwise.
-M;int;process_record_signal;struct regcache *regcache, enum gdb_signal signal;regcache, signal
-
-# Signal translation: translate inferior's signal (target's) number
-# into GDB's representation.  The implementation of this method must
-# be host independent.  IOW, don't rely on symbols of the NAT_FILE
-# header (the nm-*.h files), the host <signal.h> header, or similar
-# headers.  This is mainly used when cross-debugging core files ---
-# "Live" targets hide the translation behind the target interface
-# (target_wait, target_resume, etc.).
-M;enum gdb_signal;gdb_signal_from_target;int signo;signo
-
-# Signal translation: translate the GDB's internal signal number into
-# the inferior's signal (target's) representation.  The implementation
-# of this method must be host independent.  IOW, don't rely on symbols
-# of the NAT_FILE header (the nm-*.h files), the host <signal.h>
-# header, or similar headers.
-# Return the target signal number if found, or -1 if the GDB internal
-# signal number is invalid.
-M;int;gdb_signal_to_target;enum gdb_signal signal;signal
-
-# Extra signal info inspection.
-#
-# Return a type suitable to inspect extra signal information.
-M;struct type *;get_siginfo_type;void;
-
-# Record architecture-specific information from the symbol table.
-M;void;record_special_symbol;struct objfile *objfile, asymbol *sym;objfile, sym
-
-# Function for the 'catch syscall' feature.
-
-# Get architecture-specific system calls information from registers.
-M;LONGEST;get_syscall_number;thread_info *thread;thread
-
-# The filename of the XML syscall for this architecture.
-v;const char *;xml_syscall_file;;;0;0;;0;pstring (gdbarch->xml_syscall_file)
-
-# Information about system calls from this architecture
-v;struct syscalls_info *;syscalls_info;;;0;0;;0;host_address_to_string (gdbarch->syscalls_info)
-
-# SystemTap related fields and functions.
-
-# A NULL-terminated array of prefixes used to mark an integer constant
-# on the architecture's assembly.
-# For example, on x86 integer constants are written as:
-#
-#  \$10 ;; integer constant 10
-#
-# in this case, this prefix would be the character \`\$\'.
-v;const char *const *;stap_integer_prefixes;;;0;0;;0;pstring_list (gdbarch->stap_integer_prefixes)
-
-# A NULL-terminated array of suffixes used to mark an integer constant
-# on the architecture's assembly.
-v;const char *const *;stap_integer_suffixes;;;0;0;;0;pstring_list (gdbarch->stap_integer_suffixes)
-
-# A NULL-terminated array of prefixes used to mark a register name on
-# the architecture's assembly.
-# For example, on x86 the register name is written as:
-#
-#  \%eax ;; register eax
-#
-# in this case, this prefix would be the character \`\%\'.
-v;const char *const *;stap_register_prefixes;;;0;0;;0;pstring_list (gdbarch->stap_register_prefixes)
-
-# A NULL-terminated array of suffixes used to mark a register name on
-# the architecture's assembly.
-v;const char *const *;stap_register_suffixes;;;0;0;;0;pstring_list (gdbarch->stap_register_suffixes)
-
-# A NULL-terminated array of prefixes used to mark a register
-# indirection on the architecture's assembly.
-# For example, on x86 the register indirection is written as:
-#
-#  \(\%eax\) ;; indirecting eax
-#
-# in this case, this prefix would be the charater \`\(\'.
-#
-# Please note that we use the indirection prefix also for register
-# displacement, e.g., \`4\(\%eax\)\' on x86.
-v;const char *const *;stap_register_indirection_prefixes;;;0;0;;0;pstring_list (gdbarch->stap_register_indirection_prefixes)
-
-# A NULL-terminated array of suffixes used to mark a register
-# indirection on the architecture's assembly.
-# For example, on x86 the register indirection is written as:
-#
-#  \(\%eax\) ;; indirecting eax
-#
-# in this case, this prefix would be the charater \`\)\'.
-#
-# Please note that we use the indirection suffix also for register
-# displacement, e.g., \`4\(\%eax\)\' on x86.
-v;const char *const *;stap_register_indirection_suffixes;;;0;0;;0;pstring_list (gdbarch->stap_register_indirection_suffixes)
-
-# Prefix(es) used to name a register using GDB's nomenclature.
-#
-# For example, on PPC a register is represented by a number in the assembly
-# language (e.g., \`10\' is the 10th general-purpose register).  However,
-# inside GDB this same register has an \`r\' appended to its name, so the 10th
-# register would be represented as \`r10\' internally.
-v;const char *;stap_gdb_register_prefix;;;0;0;;0;pstring (gdbarch->stap_gdb_register_prefix)
-
-# Suffix used to name a register using GDB's nomenclature.
-v;const char *;stap_gdb_register_suffix;;;0;0;;0;pstring (gdbarch->stap_gdb_register_suffix)
-
-# Check if S is a single operand.
-#
-# Single operands can be:
-#  \- Literal integers, e.g. \`\$10\' on x86
-#  \- Register access, e.g. \`\%eax\' on x86
-#  \- Register indirection, e.g. \`\(\%eax\)\' on x86
-#  \- Register displacement, e.g. \`4\(\%eax\)\' on x86
-#
-# This function should check for these patterns on the string
-# and return 1 if some were found, or zero otherwise.  Please try to match
-# as much info as you can from the string, i.e., if you have to match
-# something like \`\(\%\', do not match just the \`\(\'.
-M;int;stap_is_single_operand;const char *s;s
-
-# Function used to handle a "special case" in the parser.
-#
-# A "special case" is considered to be an unknown token, i.e., a token
-# that the parser does not know how to parse.  A good example of special
-# case would be ARM's register displacement syntax:
-#
-#  [R0, #4]  ;; displacing R0 by 4
-#
-# Since the parser assumes that a register displacement is of the form:
-#
-#  <number> <indirection_prefix> <register_name> <indirection_suffix>
-#
-# it means that it will not be able to recognize and parse this odd syntax.
-# Therefore, we should add a special case function that will handle this token.
-#
-# This function should generate the proper expression form of the expression
-# using GDB\'s internal expression mechanism (e.g., \`write_exp_elt_opcode\'
-# and so on).  It should also return 1 if the parsing was successful, or zero
-# if the token was not recognized as a special token (in this case, returning
-# zero means that the special parser is deferring the parsing to the generic
-# parser), and should advance the buffer pointer (p->arg).
-M;expr::operation_up;stap_parse_special_token;struct stap_parse_info *p;p
-
-# Perform arch-dependent adjustments to a register name.
-#
-# In very specific situations, it may be necessary for the register
-# name present in a SystemTap probe's argument to be handled in a
-# special way.  For example, on i386, GCC may over-optimize the
-# register allocation and use smaller registers than necessary.  In
-# such cases, the client that is reading and evaluating the SystemTap
-# probe (ourselves) will need to actually fetch values from the wider
-# version of the register in question.
-#
-# To illustrate the example, consider the following probe argument
-# (i386):
-#
-#    4@%ax
-#
-# This argument says that its value can be found at the %ax register,
-# which is a 16-bit register.  However, the argument's prefix says
-# that its type is "uint32_t", which is 32-bit in size.  Therefore, in
-# this case, GDB should actually fetch the probe's value from register
-# %eax, not %ax.  In this scenario, this function would actually
-# replace the register name from %ax to %eax.
-#
-# The rationale for this can be found at PR breakpoints/24541.
-M;std::string;stap_adjust_register;struct stap_parse_info *p, const std::string \&regname, int regnum;p, regname, regnum
-
-# DTrace related functions.
-
-# The expression to compute the NARTGth+1 argument to a DTrace USDT probe.
-# NARG must be >= 0.
-M;expr::operation_up;dtrace_parse_probe_argument;int narg;narg
-
-# True if the given ADDR does not contain the instruction sequence
-# corresponding to a disabled DTrace is-enabled probe.
-M;int;dtrace_probe_is_enabled;CORE_ADDR addr;addr
-
-# Enable a DTrace is-enabled probe at ADDR.
-M;void;dtrace_enable_probe;CORE_ADDR addr;addr
-
-# Disable a DTrace is-enabled probe at ADDR.
-M;void;dtrace_disable_probe;CORE_ADDR addr;addr
-
-# True if the list of shared libraries is one and only for all
-# processes, as opposed to a list of shared libraries per inferior.
-# This usually means that all processes, although may or may not share
-# an address space, will see the same set of symbols at the same
-# addresses.
-v;int;has_global_solist;;;0;0;;0
-
-# On some targets, even though each inferior has its own private
-# address space, the debug interface takes care of making breakpoints
-# visible to all address spaces automatically.  For such cases,
-# this property should be set to true.
-v;int;has_global_breakpoints;;;0;0;;0
-
-# True if inferiors share an address space (e.g., uClinux).
-m;int;has_shared_address_space;void;;;default_has_shared_address_space;;0
-
-# True if a fast tracepoint can be set at an address.
-m;int;fast_tracepoint_valid_at;CORE_ADDR addr, std::string *msg;addr, msg;;default_fast_tracepoint_valid_at;;0
-
-# Guess register state based on tracepoint location.  Used for tracepoints
-# where no registers have been collected, but there's only one location,
-# allowing us to guess the PC value, and perhaps some other registers.
-# On entry, regcache has all registers marked as unavailable.
-m;void;guess_tracepoint_registers;struct regcache *regcache, CORE_ADDR addr;regcache, addr;;default_guess_tracepoint_registers;;0
-
-# Return the "auto" target charset.
-f;const char *;auto_charset;void;;default_auto_charset;default_auto_charset;;0
-# Return the "auto" target wide charset.
-f;const char *;auto_wide_charset;void;;default_auto_wide_charset;default_auto_wide_charset;;0
-
-# If non-empty, this is a file extension that will be opened in place
-# of the file extension reported by the shared library list.
-#
-# This is most useful for toolchains that use a post-linker tool,
-# where the names of the files run on the target differ in extension
-# compared to the names of the files GDB should load for debug info.
-v;const char *;solib_symbols_extension;;;;;;;pstring (gdbarch->solib_symbols_extension)
-
-# If true, the target OS has DOS-based file system semantics.  That
-# is, absolute paths include a drive name, and the backslash is
-# considered a directory separator.
-v;int;has_dos_based_file_system;;;0;0;;0
-
-# Generate bytecodes to collect the return address in a frame.
-# Since the bytecodes run on the target, possibly with GDB not even
-# connected, the full unwinding machinery is not available, and
-# typically this function will issue bytecodes for one or more likely
-# places that the return address may be found.
-m;void;gen_return_address;struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope;ax, value, scope;;default_gen_return_address;;0
-
-# Implement the "info proc" command.
-M;void;info_proc;const char *args, enum info_proc_what what;args, what
-
-# Implement the "info proc" command for core files.  Noe that there
-# are two "info_proc"-like methods on gdbarch -- one for core files,
-# one for live targets.
-M;void;core_info_proc;const char *args, enum info_proc_what what;args, what
-
-# Iterate over all objfiles in the order that makes the most sense
-# for the architecture to make global symbol searches.
-#
-# CB is a callback function where OBJFILE is the objfile to be searched,
-# and CB_DATA a pointer to user-defined data (the same data that is passed
-# when calling this gdbarch method).  The iteration stops if this function
-# returns nonzero.
-#
-# CB_DATA is a pointer to some user-defined data to be passed to
-# the callback.
-#
-# If not NULL, CURRENT_OBJFILE corresponds to the objfile being
-# inspected when the symbol search was requested.
-m;void;iterate_over_objfiles_in_search_order;iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile;cb, cb_data, current_objfile;0;default_iterate_over_objfiles_in_search_order;;0
-
-# Ravenscar arch-dependent ops.
-v;struct ravenscar_arch_ops *;ravenscar_ops;;;NULL;NULL;;0;host_address_to_string (gdbarch->ravenscar_ops)
-
-# Return non-zero if the instruction at ADDR is a call; zero otherwise.
-m;int;insn_is_call;CORE_ADDR addr;addr;;default_insn_is_call;;0
-
-# Return non-zero if the instruction at ADDR is a return; zero otherwise.
-m;int;insn_is_ret;CORE_ADDR addr;addr;;default_insn_is_ret;;0
-
-# Return non-zero if the instruction at ADDR is a jump; zero otherwise.
-m;int;insn_is_jump;CORE_ADDR addr;addr;;default_insn_is_jump;;0
-
-# Return true if there's a program/permanent breakpoint planted in
-# memory at ADDRESS, return false otherwise.
-m;bool;program_breakpoint_here_p;CORE_ADDR address;address;;default_program_breakpoint_here_p;;0
-
-# Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
-# Return 0 if *READPTR is already at the end of the buffer.
-# Return -1 if there is insufficient buffer for a whole entry.
-# Return 1 if an entry was read into *TYPEP and *VALP.
-M;int;auxv_parse;gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp;readptr, endptr, typep, valp
-
-# Print the description of a single auxv entry described by TYPE and VAL
-# to FILE.
-m;void;print_auxv_entry;struct ui_file *file, CORE_ADDR type, CORE_ADDR val;file, type, val;;default_print_auxv_entry;;0
-
-# Find the address range of the current inferior's vsyscall/vDSO, and
-# write it to *RANGE.  If the vsyscall's length can't be determined, a
-# range with zero length is returned.  Returns true if the vsyscall is
-# found, false otherwise.
-m;int;vsyscall_range;struct mem_range *range;range;;default_vsyscall_range;;0
-
-# Allocate SIZE bytes of PROT protected page aligned memory in inferior.
-# PROT has GDB_MMAP_PROT_* bitmask format.
-# Throw an error if it is not possible.  Returned address is always valid.
-f;CORE_ADDR;infcall_mmap;CORE_ADDR size, unsigned prot;size, prot;;default_infcall_mmap;;0
-
-# Deallocate SIZE bytes of memory at ADDR in inferior from gdbarch_infcall_mmap.
-# Print a warning if it is not possible.
-f;void;infcall_munmap;CORE_ADDR addr, CORE_ADDR size;addr, size;;default_infcall_munmap;;0
-
-# Return string (caller has to use xfree for it) with options for GCC
-# to produce code for this target, typically "-m64", "-m32" or "-m31".
-# These options are put before CU's DW_AT_producer compilation options so that
-# they can override it.
-m;std::string;gcc_target_options;void;;;default_gcc_target_options;;0
-
-# Return a regular expression that matches names used by this
-# architecture in GNU configury triplets.  The result is statically
-# allocated and must not be freed.  The default implementation simply
-# returns the BFD architecture name, which is correct in nearly every
-# case.
-m;const char *;gnu_triplet_regexp;void;;;default_gnu_triplet_regexp;;0
-
-# Return the size in 8-bit bytes of an addressable memory unit on this
-# architecture.  This corresponds to the number of 8-bit bytes associated to
-# each address in memory.
-m;int;addressable_memory_unit_size;void;;;default_addressable_memory_unit_size;;0
-
-# Functions for allowing a target to modify its disassembler options.
-v;const char *;disassembler_options_implicit;;;0;0;;0;pstring (gdbarch->disassembler_options_implicit)
-v;char **;disassembler_options;;;0;0;;0;pstring_ptr (gdbarch->disassembler_options)
-v;const disasm_options_and_args_t *;valid_disassembler_options;;;0;0;;0;host_address_to_string (gdbarch->valid_disassembler_options)
-
-# Type alignment override method.  Return the architecture specific
-# alignment required for TYPE.  If there is no special handling
-# required for TYPE then return the value 0, GDB will then apply the
-# default rules as laid out in gdbtypes.c:type_align.
-m;ULONGEST;type_align;struct type *type;type;;default_type_align;;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, read_core_file_mappings_pre_loop_ftype pre_loop_cb, read_core_file_mappings_loop_ftype loop_cb;cbfd, pre_loop_cb, loop_cb;;default_read_core_file_mappings;;0
-
-EOF
-}
-
-#
-# The .log file
-#
-exec > gdbarch.log
-function_list | while do_read
-do
-    cat <<EOF
-${class} ${returntype:-} ${function} (${formal:-})
-EOF
-    for r in ${read}
-    do
-	eval echo "\"    ${r}=\${${r}}\""
-    done
-    if class_is_predicate_p && fallback_default_p
-    then
-	echo "Error: predicate function ${function} can not have a non- multi-arch default" 1>&2
-	kill $$
-	exit 1
-    fi
-    if [ "x${invalid_p}" = "x0" ] && [ -n "${postdefault}" ]
-    then
-	echo "Error: postdefault is useless when invalid_p=0" 1>&2
-	kill $$
-	exit 1
-    fi
-    if class_is_multiarch_p
-    then
-	if class_is_predicate_p ; then :
-	elif test "x${predefault}" = "x"
-	then
-	    echo "Error: pure multi-arch function ${function} must have a predefault" 1>&2
-	    kill $$
-	    exit 1
-	fi
-    fi
-    echo ""
-done
-
-exec 1>&2
-
-
-copyright ()
-{
-cat <<EOF
-/* *INDENT-OFF* */ /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
-/* vi:set ro: */
-
-/* Dynamic architecture support for GDB, the GNU debugger.
-
-   Copyright (C) 1998-2021 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/>.  */
-
-/* This file was created with the aid of \`\`gdbarch.sh''.  */
-
-EOF
-}
-
-exec > new-gdbarch-gen.h
-copyright
-
-# function typedef's
-printf "\n"
-printf "\n"
-printf "/* The following are pre-initialized by GDBARCH.  */\n"
-function_list | while do_read
-do
-    if class_is_info_p
-    then
-	printf "\n"
-	printf "extern %s gdbarch_%s (struct gdbarch *gdbarch);\n" "$returntype" "$function"
-	printf "/* set_gdbarch_%s() - not applicable - pre-initialized.  */\n" "$function"
-    fi
-done
-
-# function typedef's
-printf "\n"
-printf "\n"
-printf "/* The following are initialized by the target dependent code.  */\n"
-function_list | while do_read
-do
-    if [ -n "${comment}" ]
-    then
-	echo "${comment}" | sed \
-	    -e '2 s,#,/*,' \
-	    -e '3,$ s,#,  ,' \
-	    -e '$ s,$, */,'
-    fi
-
-    if class_is_predicate_p
-    then
-	printf "\n"
-	printf "extern bool gdbarch_%s_p (struct gdbarch *gdbarch);\n" "$function"
-    fi
-    if class_is_variable_p
-    then
-	printf "\n"
-	printf "extern %s gdbarch_%s (struct gdbarch *gdbarch);\n" "$returntype" "$function"
-	printf "extern void set_gdbarch_%s (struct gdbarch *gdbarch, %s %s);\n" "$function" "$returntype" "$function"
-    fi
-    if class_is_function_p
-    then
-	printf "\n"
-	if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
-	then
-	    printf "typedef %s (gdbarch_%s_ftype) (struct gdbarch *gdbarch);\n" "$returntype" "$function"
-	elif class_is_multiarch_p
-	then
-	    printf "typedef %s (gdbarch_%s_ftype) (struct gdbarch *gdbarch, %s);\n" "$returntype" "$function" "$formal"
-	else
-	    printf "typedef %s (gdbarch_%s_ftype) (%s);\n" "$returntype" "$function" "$formal"
-	fi
-	if [ "x${formal}" = "xvoid" ]
-	then
-	  printf "extern %s gdbarch_%s (struct gdbarch *gdbarch);\n" "$returntype" "$function"
-	else
-	  printf "extern %s gdbarch_%s (struct gdbarch *gdbarch, %s);\n" "$returntype" "$function" "$formal"
-	fi
-	printf "extern void set_gdbarch_%s (struct gdbarch *gdbarch, gdbarch_%s_ftype *%s);\n" "$function" "$function" "$function"
-    fi
-done
-
-exec 1>&2
-../move-if-change new-gdbarch-gen.h gdbarch-gen.h
-rm -f new-gdbarch-gen.h
-
-
-#
-# C file
-#
-
-exec > new-gdbarch.c
-copyright
-
-# gdbarch open the gdbarch object
-printf "\n"
-printf "/* Maintain the struct gdbarch object.  */\n"
-printf "\n"
-printf "struct gdbarch\n"
-printf "{\n"
-printf "  /* Has this architecture been fully initialized?  */\n"
-printf "  int initialized_p;\n"
-printf "\n"
-printf "  /* An obstack bound to the lifetime of the architecture.  */\n"
-printf "  struct obstack *obstack;\n"
-printf "\n"
-printf "  /* basic architectural information.  */\n"
-function_list | while do_read
-do
-    if class_is_info_p
-    then
-	printf "  %s %s;\n" "$returntype" "$function"
-    fi
-done
-printf "\n"
-printf "  /* target specific vector.  */\n"
-printf "  struct gdbarch_tdep *tdep;\n"
-printf "  gdbarch_dump_tdep_ftype *dump_tdep;\n"
-printf "\n"
-printf "  /* per-architecture data-pointers.  */\n"
-printf "  unsigned nr_data;\n"
-printf "  void **data;\n"
-printf "\n"
-cat <<EOF
-  /* Multi-arch values.
-
-     When extending this structure you must:
-
-     Add the field below.
-
-     Declare set/get functions and define the corresponding
-     macro in gdbarch.h.
-
-     gdbarch_alloc(): If zero/NULL is not a suitable default,
-     initialize the new field.
-
-     verify_gdbarch(): Confirm that the target updated the field
-     correctly.
-
-     gdbarch_dump(): Add a fprintf_unfiltered call so that the new
-     field is dumped out
-
-     get_gdbarch(): Implement the set/get functions (probably using
-     the macro's as shortcuts).
-
-     */
-
-EOF
-function_list | while do_read
-do
-    if class_is_variable_p
-    then
-	printf "  %s %s;\n" "$returntype" "$function"
-    elif class_is_function_p
-    then
-	printf "  gdbarch_%s_ftype *%s;\n" "$function" "$function"
-    fi
-done
-printf "};\n"
-
-# Create a new gdbarch struct
-cat <<EOF
-
-/* Create a new \`\`struct gdbarch'' based on information provided by
-   \`\`struct gdbarch_info''.  */
-EOF
-printf "\n"
-cat <<EOF
-struct gdbarch *
-gdbarch_alloc (const struct gdbarch_info *info,
-	       struct gdbarch_tdep *tdep)
-{
-  struct gdbarch *gdbarch;
-
-  /* Create an obstack for allocating all the per-architecture memory,
-     then use that to allocate the architecture vector.  */
-  struct obstack *obstack = XNEW (struct obstack);
-  obstack_init (obstack);
-  gdbarch = XOBNEW (obstack, struct gdbarch);
-  memset (gdbarch, 0, sizeof (*gdbarch));
-  gdbarch->obstack = obstack;
-
-  alloc_gdbarch_data (gdbarch);
-
-  gdbarch->tdep = tdep;
-EOF
-printf "\n"
-function_list | while do_read
-do
-    if class_is_info_p
-    then
-	printf "  gdbarch->%s = info->%s;\n" "$function" "$function"
-    fi
-done
-printf "\n"
-printf "  /* Force the explicit initialization of these.  */\n"
-function_list | while do_read
-do
-    if class_is_function_p || class_is_variable_p
-    then
-	if [ -n "${predefault}" ] && [ "x${predefault}" != "x0" ]
-	then
-	  printf "  gdbarch->%s = %s;\n" "$function" "$predefault"
-	fi
-    fi
-done
-cat <<EOF
-  /* gdbarch_alloc() */
-
-  return gdbarch;
-}
-EOF
-
-# Free a gdbarch struct.
-printf "\n"
-
-# verify a new architecture
-cat <<EOF
-
-
-/* Ensure that all values in a GDBARCH are reasonable.  */
-
-static void
-verify_gdbarch (struct gdbarch *gdbarch)
-{
-  string_file log;
-
-  /* fundamental */
-  if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
-    log.puts ("\n\tbyte-order");
-  if (gdbarch->bfd_arch_info == NULL)
-    log.puts ("\n\tbfd_arch_info");
-  /* Check those that need to be defined for the given multi-arch level.  */
-EOF
-function_list | while do_read
-do
-    if class_is_function_p || class_is_variable_p
-    then
-	if [ "x${invalid_p}" = "x0" ]
-	then
-	    printf "  /* Skip verify of %s, invalid_p == 0 */\n" "$function"
-	elif class_is_predicate_p
-	then
-	    printf "  /* Skip verify of %s, has predicate.  */\n" "$function"
-	# FIXME: See do_read for potential simplification
-	elif [ -n "${invalid_p}" ] && [ -n "${postdefault}" ]
-	then
-	    printf "  if (%s)\n" "$invalid_p"
-	    printf "    gdbarch->%s = %s;\n" "$function" "$postdefault"
-	elif [ -n "${predefault}" ] && [ -n "${postdefault}" ]
-	then
-	    printf "  if (gdbarch->%s == %s)\n" "$function" "$predefault"
-	    printf "    gdbarch->%s = %s;\n" "$function" "$postdefault"
-	elif [ -n "${postdefault}" ]
-	then
-	    printf "  if (gdbarch->%s == 0)\n" "$function"
-	    printf "    gdbarch->%s = %s;\n" "$function" "$postdefault"
-	elif [ -n "${invalid_p}" ]
-	then
-	    printf "  if (%s)\n" "$invalid_p"
-	    printf "    log.puts (\"\\\\n\\\\t%s\");\n" "$function"
-	elif [ -n "${predefault}" ]
-	then
-	    printf "  if (gdbarch->%s == %s)\n" "$function" "$predefault"
-	    printf "    log.puts (\"\\\\n\\\\t%s\");\n" "$function"
-	fi
-    fi
-done
-cat <<EOF
-  if (!log.empty ())
-    internal_error (__FILE__, __LINE__,
-		    _("verify_gdbarch: the following are invalid ...%s"),
-		    log.c_str ());
-}
-EOF
-
-# dump the structure
-printf "\n"
-printf "\n"
-cat <<EOF
-/* Print out the details of the current architecture.  */
-
-void
-gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
-{
-  const char *gdb_nm_file = "<not-defined>";
-
-#if defined (GDB_NM_FILE)
-  gdb_nm_file = GDB_NM_FILE;
-#endif
-  fprintf_unfiltered (file,
-		      "gdbarch_dump: GDB_NM_FILE = %s\\n",
-		      gdb_nm_file);
-EOF
-function_list | while do_read
-do
-    # First the predicate
-    if class_is_predicate_p
-    then
-	printf "  fprintf_unfiltered (file,\n"
-	printf "                      \"gdbarch_dump: gdbarch_%s_p() = %%d\\\\n\",\n" "$function"
-	printf "                      gdbarch_%s_p (gdbarch));\n" "$function"
-    fi
-    # Print the corresponding value.
-    if class_is_function_p
-    then
-	printf "  fprintf_unfiltered (file,\n"
-	printf "                      \"gdbarch_dump: %s = <%%s>\\\\n\",\n" "$function"
-	printf "                      host_address_to_string (gdbarch->%s));\n" "$function"
-    else
-	# It is a variable
-	case "${print}:${returntype}" in
-	    :CORE_ADDR )
-		fmt="%s"
-		print="core_addr_to_string_nz (gdbarch->${function})"
-		;;
-	    :* )
-		fmt="%s"
-		print="plongest (gdbarch->${function})"
-		;;
-	    * )
-		fmt="%s"
-		;;
-	esac
-	printf "  fprintf_unfiltered (file,\n"
-	printf "                      \"gdbarch_dump: %s = %s\\\\n\",\n" "$function" "$fmt"
-	printf "                      %s);\n" "$print"
-    fi
-done
-cat <<EOF
-  if (gdbarch->dump_tdep != NULL)
-    gdbarch->dump_tdep (gdbarch, file);
-}
-EOF
-
-
-printf "\n"
-function_list | while do_read
-do
-    if class_is_predicate_p
-    then
-	printf "\n"
-	printf "bool\n"
-	printf "gdbarch_%s_p (struct gdbarch *gdbarch)\n" "$function"
-	printf "{\n"
-	printf "  gdb_assert (gdbarch != NULL);\n"
-	printf "  return %s;\n" "$predicate"
-	printf "}\n"
-    fi
-    if class_is_function_p
-    then
-	printf "\n"
-	printf "%s\n" "$returntype"
-	if [ "x${formal}" = "xvoid" ]
-	then
-	  printf "gdbarch_%s (struct gdbarch *gdbarch)\n" "$function"
-	else
-	  printf "gdbarch_%s (struct gdbarch *gdbarch, %s)\n" "$function" "$formal"
-	fi
-	printf "{\n"
-	printf "  gdb_assert (gdbarch != NULL);\n"
-	printf "  gdb_assert (gdbarch->%s != NULL);\n" "$function"
-	if class_is_predicate_p && test -n "${predefault}"
-	then
-	    # Allow a call to a function with a predicate.
-	    printf "  /* Do not check predicate: %s, allow call.  */\n" "$predicate"
-	fi
-	printf "  if (gdbarch_debug >= 2)\n"
-	printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_%s called\\\\n\");\n" "$function"
-	if [ "x${actual:-}" = "x-" ] || [ "x${actual:-}" = "x" ]
-	then
-	    if class_is_multiarch_p
-	    then
-		params="gdbarch"
-	    else
-		params=""
-	    fi
-	else
-	    if class_is_multiarch_p
-	    then
-		params="gdbarch, ${actual}"
-	    else
-		params="${actual}"
-	    fi
-	fi
-       	if [ "x${returntype}" = "xvoid" ]
-	then
-	  printf "  gdbarch->%s (%s);\n" "$function" "$params"
-	else
-	  printf "  return gdbarch->%s (%s);\n" "$function" "$params"
-	fi
-	printf "}\n"
-	printf "\n"
-	printf "void\n"
-	printf "set_gdbarch_%s (struct gdbarch *gdbarch,\n" "$function"
-	printf "            %s  gdbarch_%s_ftype %s)\n" "$(echo "$function" | sed -e 's/./ /g')" "$function" "$function"
-	printf "{\n"
-	printf "  gdbarch->%s = %s;\n" "$function" "$function"
-	printf "}\n"
-    elif class_is_variable_p
-    then
-	printf "\n"
-	printf "%s\n" "$returntype"
-	printf "gdbarch_%s (struct gdbarch *gdbarch)\n" "$function"
-	printf "{\n"
-	printf "  gdb_assert (gdbarch != NULL);\n"
-	if [ "x${invalid_p}" = "x0" ]
-	then
-	    printf "  /* Skip verify of %s, invalid_p == 0 */\n" "$function"
-	elif [ -n "${invalid_p}" ]
-	then
-	    printf "  /* Check variable is valid.  */\n"
-	    printf "  gdb_assert (!(%s));\n" "$invalid_p"
-	elif [ -n "${predefault}" ]
-	then
-	    printf "  /* Check variable changed from pre-default.  */\n"
-	    printf "  gdb_assert (gdbarch->%s != %s);\n" "$function" "$predefault"
-	fi
-	printf "  if (gdbarch_debug >= 2)\n"
-	printf "    fprintf_unfiltered (gdb_stdlog, \"gdbarch_%s called\\\\n\");\n" "$function"
-	printf "  return gdbarch->%s;\n" "$function"
-	printf "}\n"
-	printf "\n"
-	printf "void\n"
-	printf "set_gdbarch_%s (struct gdbarch *gdbarch,\n" "$function"
-	printf "            %s  %s %s)\n" "$(echo "$function" | sed -e 's/./ /g')" "$returntype" "$function"
-	printf "{\n"
-	printf "  gdbarch->%s = %s;\n" "$function" "$function"
-	printf "}\n"
-    elif class_is_info_p
-    then
-	printf "\n"
-	printf "%s\n" "$returntype"
-	printf "gdbarch_%s (struct gdbarch *gdbarch)\n" "$function"
-	printf "{\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"
-	printf "}\n"
-    fi
-done
-
-# close things off
-exec 1>&2
-../move-if-change new-gdbarch.c gdbarch.c
-rm -f new-gdbarch.c
-
-exec > gdbarch-components.py
-copyright | sed 1,3d | grep -v 'was created' |
-    sed -e 's,/\*,  ,' -e 's, *\*/,,' -e 's/^  /#/'
-
-function_list | while do_read
-do
-    printf "\n"
-    if class_is_info_p; then
-	printf Info
-    elif class_is_variable_p; then
-	printf Value
-    elif class_is_multiarch_p; then
-	printf Method
-    elif class_is_function_p; then
-	printf Function
-    else
-	echo FAILURE 1>&2
-	exit 1
-    fi
-    printf "(\n"
-    if [ -n "${comment}" ]
-    then
-	printf "    comment=\"\"\""
-	echo "${comment}" | sed 's/^# *//'
-	printf "\"\"\",\n"
-    fi
-
-    # The order here is picked to be type, name, params -- that way
-    # it's relatively "C-like".
-    printf "    type=\"%s\",\n" "$returntype"
-    printf "    name=\"%s\",\n" "$function"
-    if class_is_function_p; then
-	if test -n "$formal" && test "$formal" != void; then
-	    printf "    params=[\n"
-	    # Turn TYPE NAME into ("TYPE", "NAME").
-	    echo "$formal" | sed -e "s/, */,\n/g" |
-		sed -e 's/ *\([a-zA-Z_][a-zA-Z0-9_]*\)\(,*\)$/", "\1")\2/' |
-		sed -e 's/^/        ("/'
-	    printf "    ],\n"
-	else
-	    printf "    params=(),\n"
-	fi
-    fi
-    if class_is_predicate_p; then
-	printf "    predicate=True,\n"
-    fi
-    if ! class_is_info_p; then
-	if test -n "$predefault"; then
-	    printf "    predefault=\"%s\",\n" "$predefault"
-	fi
-	# We can ignore 'actual' and 'staticdefault'.
-	if test -n "$postdefault"; then
-	    printf "    postdefault=\"%s\",\n" "$postdefault"
-	fi
-	# Let's arrange for False to mean suppress checking, and True
-	# to mean default checking.
-	if test "$invalid_p" = "0"; then
-	    printf "    invalid=False,\n"
-	elif test "$invalid_p" = ""; then
-	    printf "    invalid=True,\n"
-	else
-	    printf "    invalid=\"%s\",\n" "$invalid_p"
-	fi
-    fi
-    if test -n "$print"; then
-	printf "    printer=\"%s\",\n" "$print"
-    fi
-    printf ")\n"
-done
-
-exec 1>&2
-black gdbarch-components.py