Subversion Repositories or1k

/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */

/* Dynamic architecture support for GDB, the GNU debugger.

   Copyright 1998, 1999, 2000, 2001 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 2 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

/* This file was created with the aid of ``gdbarch.sh''.

   The Bourne shell script ``gdbarch.sh'' creates the files

   ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them

   against the existing ``gdbarch.[hc]''.  Any differences found

   being reported.

   If editing this file, please also run gdbarch.sh and merge any

   changes into that script. Conversely, when making sweeping changes

   to this file, modifying gdbarch.sh and using its output may prove

   easier. */

#include "defs.h"

#include "arch-utils.h"

#if GDB_MULTI_ARCH

#include "gdbcmd.h"

#include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */

#else

/* Just include everything in sight so that the every old definition

   of macro is visible. */

#include "gdb_string.h"

#include <ctype.h>

#include "symtab.h"

#include "frame.h"

#include "inferior.h"

#include "breakpoint.h"

#include "gdb_wait.h"

#include "gdbcore.h"

#include "gdbcmd.h"

#include "target.h"

#include "gdbthread.h"

#include "annotate.h"

#include "symfile.h"            /* for overlay functions */

#endif

#include "symcat.h"

#include "floatformat.h"

#include "gdb_assert.h"

/* Static function declarations */

static void verify_gdbarch (struct gdbarch *gdbarch);

static void alloc_gdbarch_data (struct gdbarch *);

static void init_gdbarch_data (struct gdbarch *);

static void free_gdbarch_data (struct gdbarch *);

static void init_gdbarch_swap (struct gdbarch *);

static void swapout_gdbarch_swap (struct gdbarch *);

static void swapin_gdbarch_swap (struct gdbarch *);

/* Convenience macro for allocting typesafe memory. */

#ifndef XMALLOC

#define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))

#endif

/* Non-zero if we want to trace architecture code.  */

#ifndef GDBARCH_DEBUG

#define GDBARCH_DEBUG 0

#endif

int gdbarch_debug = GDBARCH_DEBUG;

/* Maintain the struct gdbarch object */

struct gdbarch

{

  /* basic architectural information */

  const struct bfd_arch_info * bfd_arch_info;

  int byte_order;

  /* target specific vector. */

  struct gdbarch_tdep *tdep;

  gdbarch_dump_tdep_ftype *dump_tdep;

  /* per-architecture data-pointers */

  unsigned nr_data;

  void **data;

  /* per-architecture swap-regions */

  struct gdbarch_swap *swap;

  /* 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

     ``startup_gdbarch()'': Append an initial value to the static

     variable (base values on the host's c-type system).

     get_gdbarch(): Implement the set/get functions (probably using

     the macro's as shortcuts).

     */

  int short_bit;

  int int_bit;

  int long_bit;

  int long_long_bit;

  int float_bit;

  int double_bit;

  int long_double_bit;

  int ptr_bit;

  int addr_bit;

  int bfd_vma_bit;

  int ieee_float;

  gdbarch_read_pc_ftype *read_pc;

  gdbarch_write_pc_ftype *write_pc;

  gdbarch_read_fp_ftype *read_fp;

  gdbarch_write_fp_ftype *write_fp;

  gdbarch_read_sp_ftype *read_sp;

  gdbarch_write_sp_ftype *write_sp;

  gdbarch_register_read_ftype *register_read;

  gdbarch_register_write_ftype *register_write;

  int num_regs;

  int num_pseudo_regs;

  int sp_regnum;

  int fp_regnum;

  int pc_regnum;

  int fp0_regnum;

  int npc_regnum;

  int nnpc_regnum;

  gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;

  gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;

  gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;

  gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;

  gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;

  gdbarch_register_name_ftype *register_name;

  int register_size;

  int register_bytes;

  gdbarch_register_byte_ftype *register_byte;

  gdbarch_register_raw_size_ftype *register_raw_size;

  int max_register_raw_size;

  gdbarch_register_virtual_size_ftype *register_virtual_size;

  int max_register_virtual_size;

  gdbarch_register_virtual_type_ftype *register_virtual_type;

  gdbarch_do_registers_info_ftype *do_registers_info;

  gdbarch_register_sim_regno_ftype *register_sim_regno;

  gdbarch_register_bytes_ok_ftype *register_bytes_ok;

  gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;

  gdbarch_cannot_store_register_ftype *cannot_store_register;

  int use_generic_dummy_frames;

  int call_dummy_location;

  gdbarch_call_dummy_address_ftype *call_dummy_address;

  CORE_ADDR call_dummy_start_offset;

  CORE_ADDR call_dummy_breakpoint_offset;

  int call_dummy_breakpoint_offset_p;

  int call_dummy_length;

  gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy;

  int call_dummy_p;

  LONGEST * call_dummy_words;

  int sizeof_call_dummy_words;

  int call_dummy_stack_adjust_p;

  int call_dummy_stack_adjust;

  gdbarch_fix_call_dummy_ftype *fix_call_dummy;

  gdbarch_init_frame_pc_first_ftype *init_frame_pc_first;

  gdbarch_init_frame_pc_ftype *init_frame_pc;

  int believe_pcc_promotion;

  int believe_pcc_promotion_type;

  gdbarch_coerce_float_to_double_ftype *coerce_float_to_double;

  gdbarch_get_saved_register_ftype *get_saved_register;

  gdbarch_register_convertible_ftype *register_convertible;

  gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual;

  gdbarch_register_convert_to_raw_ftype *register_convert_to_raw;

  gdbarch_fetch_pseudo_register_ftype *fetch_pseudo_register;

  gdbarch_store_pseudo_register_ftype *store_pseudo_register;

  gdbarch_pointer_to_address_ftype *pointer_to_address;

  gdbarch_address_to_pointer_ftype *address_to_pointer;

  gdbarch_return_value_on_stack_ftype *return_value_on_stack;

  gdbarch_extract_return_value_ftype *extract_return_value;

  gdbarch_push_arguments_ftype *push_arguments;

  gdbarch_push_dummy_frame_ftype *push_dummy_frame;

  gdbarch_push_return_address_ftype *push_return_address;

  gdbarch_pop_frame_ftype *pop_frame;

  gdbarch_d10v_make_daddr_ftype *d10v_make_daddr;

  gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr;

  gdbarch_d10v_daddr_p_ftype *d10v_daddr_p;

  gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p;

  gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw;

  gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw;

  gdbarch_store_struct_return_ftype *store_struct_return;

  gdbarch_store_return_value_ftype *store_return_value;

  gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;

  gdbarch_use_struct_convention_ftype *use_struct_convention;

  gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs;

  gdbarch_init_extra_frame_info_ftype *init_extra_frame_info;

  gdbarch_skip_prologue_ftype *skip_prologue;

  gdbarch_prologue_frameless_p_ftype *prologue_frameless_p;

  gdbarch_inner_than_ftype *inner_than;

  gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;

  gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;

  gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;

  CORE_ADDR decr_pc_after_break;

  gdbarch_prepare_to_proceed_ftype *prepare_to_proceed;

  CORE_ADDR function_start_offset;

  gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;

  CORE_ADDR frame_args_skip;

  gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;

  gdbarch_frame_chain_ftype *frame_chain;

  gdbarch_frame_chain_valid_ftype *frame_chain_valid;

  gdbarch_frame_saved_pc_ftype *frame_saved_pc;

  gdbarch_frame_args_address_ftype *frame_args_address;

  gdbarch_frame_locals_address_ftype *frame_locals_address;

  gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;

  gdbarch_frame_num_args_ftype *frame_num_args;

  gdbarch_stack_align_ftype *stack_align;

  int extra_stack_alignment_needed;

  gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr;

  gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos;

  int parm_boundary;

  const struct floatformat * float_format;

  const struct floatformat * double_format;

  const struct floatformat * long_double_format;

  gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;

  gdbarch_addr_bits_remove_ftype *addr_bits_remove;

  gdbarch_software_single_step_ftype *software_single_step;

};

/* The default architecture uses host values (for want of a better

   choice). */

extern const struct bfd_arch_info bfd_default_arch_struct;

struct gdbarch startup_gdbarch =

{

  /* basic architecture information */

  &bfd_default_arch_struct,

  BIG_ENDIAN,

  /* target specific vector and its dump routine */

  NULL, NULL,

  /*per-architecture data-pointers and swap regions */

  0, NULL, NULL,

  /* Multi-arch values */

  8 * sizeof (short),

  8 * sizeof (int),

  8 * sizeof (long),

  8 * sizeof (LONGEST),

  8 * sizeof (float),

  8 * sizeof (double),

  8 * sizeof (long double),

  8 * sizeof (void*),

  8 * sizeof (void*),

  8 * sizeof (void*),

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  generic_get_saved_register,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  /* startup_gdbarch() */

};

struct gdbarch *current_gdbarch = &startup_gdbarch;

/* Do any initialization needed for a non-multiarch configuration

   after the _initialize_MODULE functions have been run.  */

void

initialize_non_multiarch ()

{

  alloc_gdbarch_data (&startup_gdbarch);

  init_gdbarch_data (&startup_gdbarch);

}

/* Create a new ``struct gdbarch'' based on information provided by

   ``struct gdbarch_info''. */

struct gdbarch *

gdbarch_alloc (const struct gdbarch_info *info,

               struct gdbarch_tdep *tdep)

{

  struct gdbarch *gdbarch = XMALLOC (struct gdbarch);

  memset (gdbarch, 0, sizeof (*gdbarch));

  alloc_gdbarch_data (gdbarch);

  gdbarch->tdep = tdep;

  gdbarch->bfd_arch_info = info->bfd_arch_info;

  gdbarch->byte_order = info->byte_order;

  /* Force the explicit initialization of these. */

  gdbarch->short_bit = 2*TARGET_CHAR_BIT;

  gdbarch->int_bit = 4*TARGET_CHAR_BIT;

  gdbarch->long_bit = 4*TARGET_CHAR_BIT;

  gdbarch->long_long_bit = 2*TARGET_LONG_BIT;

  gdbarch->float_bit = 4*TARGET_CHAR_BIT;

  gdbarch->double_bit = 8*TARGET_CHAR_BIT;

  gdbarch->long_double_bit = 2*TARGET_DOUBLE_BIT;

  gdbarch->ptr_bit = TARGET_INT_BIT;

  gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;

  gdbarch->read_pc = generic_target_read_pc;

  gdbarch->write_pc = generic_target_write_pc;

  gdbarch->read_fp = generic_target_read_fp;

  gdbarch->write_fp = generic_target_write_fp;

  gdbarch->read_sp = generic_target_read_sp;

  gdbarch->write_sp = generic_target_write_sp;

  gdbarch->num_regs = -1;

  gdbarch->sp_regnum = -1;

  gdbarch->fp_regnum = -1;

  gdbarch->pc_regnum = -1;

  gdbarch->fp0_regnum = -1;

  gdbarch->npc_regnum = -1;

  gdbarch->nnpc_regnum = -1;

  gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;

  gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;

  gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;

  gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;

  gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;

  gdbarch->register_name = legacy_register_name;

  gdbarch->register_size = -1;

  gdbarch->register_bytes = -1;

  gdbarch->max_register_raw_size = -1;

  gdbarch->max_register_virtual_size = -1;

  gdbarch->do_registers_info = do_registers_info;

  gdbarch->register_sim_regno = default_register_sim_regno;

  gdbarch->cannot_fetch_register = cannot_register_not;

  gdbarch->cannot_store_register = cannot_register_not;

  gdbarch->use_generic_dummy_frames = -1;

  gdbarch->call_dummy_start_offset = -1;

  gdbarch->call_dummy_breakpoint_offset = -1;

  gdbarch->call_dummy_breakpoint_offset_p = -1;

  gdbarch->call_dummy_length = -1;

  gdbarch->call_dummy_p = -1;

  gdbarch->call_dummy_words = legacy_call_dummy_words;

  gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;

  gdbarch->call_dummy_stack_adjust_p = -1;

  gdbarch->init_frame_pc_first = init_frame_pc_noop;

  gdbarch->init_frame_pc = init_frame_pc_default;

  gdbarch->coerce_float_to_double = default_coerce_float_to_double;

  gdbarch->register_convertible = generic_register_convertible_not;

  gdbarch->pointer_to_address = unsigned_pointer_to_address;

  gdbarch->address_to_pointer = unsigned_address_to_pointer;

  gdbarch->return_value_on_stack = generic_return_value_on_stack_not;

  gdbarch->prologue_frameless_p = generic_prologue_frameless_p;

  gdbarch->breakpoint_from_pc = legacy_breakpoint_from_pc;

  gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;

  gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;

  gdbarch->decr_pc_after_break = -1;

  gdbarch->prepare_to_proceed = default_prepare_to_proceed;

  gdbarch->function_start_offset = -1;

  gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;

  gdbarch->frame_args_skip = -1;

  gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;

  gdbarch->extra_stack_alignment_needed = 1;

  gdbarch->convert_from_func_ptr_addr = core_addr_identity;

  gdbarch->addr_bits_remove = core_addr_identity;

  /* gdbarch_alloc() */

  return gdbarch;

}

/* Free a gdbarch struct.  This should never happen in normal

   operation --- once you've created a gdbarch, you keep it around.

   However, if an architecture's init function encounters an error

   building the structure, it may need to clean up a partially

   constructed gdbarch.  */

void

gdbarch_free (struct gdbarch *arch)

{

  gdb_assert (arch != NULL);

  free_gdbarch_data (arch);

  xfree (arch);

}

/* Ensure that all values in a GDBARCH are reasonable. */

static void

verify_gdbarch (struct gdbarch *gdbarch)

{

  /* Only perform sanity checks on a multi-arch target. */

  if (!GDB_MULTI_ARCH)

    return;

  /* fundamental */

  if (gdbarch->byte_order == 0)

    internal_error (__FILE__, __LINE__,

                    "verify_gdbarch: byte-order unset");

  if (gdbarch->bfd_arch_info == NULL)

    internal_error (__FILE__, __LINE__,

                    "verify_gdbarch: bfd_arch_info unset");

  /* Check those that need to be defined for the given multi-arch level. */

  /* Skip verify of short_bit, invalid_p == 0 */

  /* Skip verify of int_bit, invalid_p == 0 */

  /* Skip verify of long_bit, invalid_p == 0 */

  /* Skip verify of long_long_bit, invalid_p == 0 */

  /* Skip verify of float_bit, invalid_p == 0 */

  /* Skip verify of double_bit, invalid_p == 0 */

  /* Skip verify of long_double_bit, invalid_p == 0 */

  /* Skip verify of ptr_bit, invalid_p == 0 */

  if (gdbarch->addr_bit == 0)

    gdbarch->addr_bit = TARGET_PTR_BIT;

  /* Skip verify of bfd_vma_bit, invalid_p == 0 */

  /* Skip verify of ieee_float, invalid_p == 0 */

  /* Skip verify of read_pc, invalid_p == 0 */

  /* Skip verify of write_pc, invalid_p == 0 */

  /* Skip verify of read_fp, invalid_p == 0 */

  /* Skip verify of write_fp, invalid_p == 0 */

  /* Skip verify of read_sp, invalid_p == 0 */

  /* Skip verify of write_sp, invalid_p == 0 */

  /* Skip verify of register_read, has predicate */

  /* Skip verify of register_write, has predicate */

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->num_regs == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: num_regs invalid");

  /* Skip verify of num_pseudo_regs, invalid_p == 0 */

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->sp_regnum == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: sp_regnum invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->fp_regnum == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: fp_regnum invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->pc_regnum == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: pc_regnum invalid");

  /* Skip verify of fp0_regnum, invalid_p == 0 */

  /* Skip verify of npc_regnum, invalid_p == 0 */

  /* Skip verify of nnpc_regnum, invalid_p == 0 */

  /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */

  /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */

  /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */

  /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */

  /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */

  /* Skip verify of register_name, invalid_p == 0 */

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->register_size == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: register_size invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->register_bytes == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: register_bytes invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->register_byte == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: register_byte invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->register_raw_size == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: register_raw_size invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->max_register_raw_size == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: max_register_raw_size invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->register_virtual_size == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: register_virtual_size invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->max_register_virtual_size == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: max_register_virtual_size invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->register_virtual_type == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: register_virtual_type invalid");

  /* Skip verify of do_registers_info, invalid_p == 0 */

  /* Skip verify of register_sim_regno, invalid_p == 0 */

  /* Skip verify of register_bytes_ok, has predicate */

  /* Skip verify of cannot_fetch_register, invalid_p == 0 */

  /* Skip verify of cannot_store_register, invalid_p == 0 */

  if ((GDB_MULTI_ARCH >= 1)

      && (gdbarch->use_generic_dummy_frames == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: use_generic_dummy_frames invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->call_dummy_location == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: call_dummy_location invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: call_dummy_address invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->call_dummy_start_offset == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: call_dummy_start_offset invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->call_dummy_breakpoint_offset == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: call_dummy_breakpoint_offset invalid");

  if ((GDB_MULTI_ARCH >= 1)

      && (gdbarch->call_dummy_breakpoint_offset_p == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: call_dummy_breakpoint_offset_p invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->call_dummy_length == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: call_dummy_length invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->pc_in_call_dummy == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: pc_in_call_dummy invalid");

  if ((GDB_MULTI_ARCH >= 1)

      && (gdbarch->call_dummy_p == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: call_dummy_p invalid");

  /* Skip verify of call_dummy_words, invalid_p == 0 */

  /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */

  if ((GDB_MULTI_ARCH >= 1)

      && (gdbarch->call_dummy_stack_adjust_p == -1))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: call_dummy_stack_adjust_p invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: call_dummy_stack_adjust invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->fix_call_dummy == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: fix_call_dummy invalid");

  /* Skip verify of init_frame_pc_first, invalid_p == 0 */

  /* Skip verify of init_frame_pc, invalid_p == 0 */

  /* Skip verify of coerce_float_to_double, invalid_p == 0 */

  if ((GDB_MULTI_ARCH >= 1)

      && (gdbarch->get_saved_register == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: get_saved_register invalid");

  /* Skip verify of register_convertible, invalid_p == 0 */

  /* Skip verify of register_convert_to_virtual, invalid_p == 0 */

  /* Skip verify of register_convert_to_raw, invalid_p == 0 */

  /* Skip verify of fetch_pseudo_register, invalid_p == 0 */

  /* Skip verify of store_pseudo_register, invalid_p == 0 */

  /* Skip verify of pointer_to_address, invalid_p == 0 */

  /* Skip verify of address_to_pointer, invalid_p == 0 */

  /* Skip verify of return_value_on_stack, invalid_p == 0 */

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->extract_return_value == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: extract_return_value invalid");

  if ((GDB_MULTI_ARCH >= 1)

      && (gdbarch->push_arguments == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: push_arguments invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->push_dummy_frame == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: push_dummy_frame invalid");

  if ((GDB_MULTI_ARCH >= 1)

      && (gdbarch->push_return_address == 0))

    internal_error (__FILE__, __LINE__,

                    "gdbarch: verify_gdbarch: push_return_address invalid");

  if ((GDB_MULTI_ARCH >= 2)

      && (gdbarch->pop_frame == 0))

    internal_error (__FILE__, __LINE__,