Subversion Repositories or1k

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

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

   Copyright 1998, 1999, 2000, 2001, 2002 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 */

#include "value.h"              /* For old tm.h/nm.h macros.  */

#endif

#include "symcat.h"

#include "floatformat.h"

#include "gdb_assert.h"

#include "gdb_string.h"

#include "gdb-events.h"

/* Static function declarations */

static void verify_gdbarch (struct gdbarch *gdbarch);

static void alloc_gdbarch_data (struct gdbarch *);

static void free_gdbarch_data (struct gdbarch *);

static void init_gdbarch_swap (struct gdbarch *);

static void clear_gdbarch_swap (struct gdbarch *);

static void swapout_gdbarch_swap (struct gdbarch *);

static void swapin_gdbarch_swap (struct gdbarch *);

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

{

  /* Has this architecture been fully initialized?  */

  int initialized_p;

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

  gdbarch_read_pc_ftype *read_pc;

  gdbarch_write_pc_ftype *write_pc;

  gdbarch_read_fp_ftype *read_fp;

  gdbarch_read_sp_ftype *read_sp;

  gdbarch_write_sp_ftype *write_sp;

  gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer;

  gdbarch_pseudo_register_read_ftype *pseudo_register_read;

  gdbarch_pseudo_register_write_ftype *pseudo_register_write;

  int num_regs;

  int num_pseudo_regs;

  int sp_regnum;

  int fp_regnum;

  int pc_regnum;

  int ps_regnum;

  int fp0_regnum;

  int npc_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_print_registers_info_ftype *print_registers_info;

  gdbarch_print_float_info_ftype *print_float_info;

  gdbarch_print_vector_info_ftype *print_vector_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;

  gdbarch_get_longjmp_target_ftype *get_longjmp_target;

  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_convert_register_p_ftype *convert_register_p;

  gdbarch_register_to_value_ftype *register_to_value;

  gdbarch_value_to_register_ftype *value_to_register;

  gdbarch_pointer_to_address_ftype *pointer_to_address;

  gdbarch_address_to_pointer_ftype *address_to_pointer;

  gdbarch_integer_to_address_ftype *integer_to_address;

  gdbarch_return_value_on_stack_ftype *return_value_on_stack;

  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_store_struct_return_ftype *store_struct_return;

  gdbarch_extract_return_value_ftype *extract_return_value;

  gdbarch_store_return_value_ftype *store_return_value;

  gdbarch_deprecated_extract_return_value_ftype *deprecated_extract_return_value;

  gdbarch_deprecated_store_return_value_ftype *deprecated_store_return_value;

  gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;

  gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_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_smash_text_address_ftype *smash_text_address;

  gdbarch_software_single_step_ftype *software_single_step;

  gdbarch_print_insn_ftype *print_insn;

  gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;

  gdbarch_in_solib_call_trampoline_ftype *in_solib_call_trampoline;

  gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;

  gdbarch_pc_in_sigtramp_ftype *pc_in_sigtramp;

  gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;

  gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;

  gdbarch_dwarf2_build_frame_info_ftype *dwarf2_build_frame_info;

  gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;

  gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;

};

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

{

  1, /* Always initialized.  */

  /* basic architecture information */

  &bfd_default_arch_struct,

  BFD_ENDIAN_BIG,

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

  1,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  -1,

  -1,

  -1,

  -1,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  0,

  generic_register_byte,

  generic_register_size,

  0,

  generic_register_size,

  0,

  0,

  0,

  default_print_registers_info,

  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,

  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_in_function_epilogue_p,

  construct_inferior_arguments,

  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 (void)

{

  alloc_gdbarch_data (&startup_gdbarch);

  /* Ensure that all swap areas are zeroed so that they again think

     they are starting from scratch.  */

  clear_gdbarch_swap (&startup_gdbarch);

  init_gdbarch_swap (&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)

{

  /* NOTE: The new architecture variable is named ``current_gdbarch''

     so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to

     the current local architecture and not the previous global

     architecture.  This ensures that the new architectures initial

     values are not influenced by the previous architecture.  Once

     everything is parameterised with gdbarch, this will go away.  */

  struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);

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

  alloc_gdbarch_data (current_gdbarch);

  current_gdbarch->tdep = tdep;

  current_gdbarch->bfd_arch_info = info->bfd_arch_info;

  current_gdbarch->byte_order = info->byte_order;

  /* Force the explicit initialization of these. */

  current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;

  current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;

  current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;

  current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;

  current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;

  current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;

  current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;

  current_gdbarch->ptr_bit = TARGET_INT_BIT;

  current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;

  current_gdbarch->char_signed = -1;

  current_gdbarch->read_pc = generic_target_read_pc;

  current_gdbarch->write_pc = generic_target_write_pc;

  current_gdbarch->read_fp = generic_target_read_fp;

  current_gdbarch->read_sp = generic_target_read_sp;

  current_gdbarch->write_sp = generic_target_write_sp;

  current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;

  current_gdbarch->num_regs = -1;

  current_gdbarch->sp_regnum = -1;

  current_gdbarch->fp_regnum = -1;

  current_gdbarch->pc_regnum = -1;

  current_gdbarch->ps_regnum = -1;

  current_gdbarch->fp0_regnum = -1;

  current_gdbarch->npc_regnum = -1;

  current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;

  current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;

  current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;

  current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;

  current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;

  current_gdbarch->register_name = legacy_register_name;

  current_gdbarch->register_size = -1;

  current_gdbarch->register_bytes = -1;

  current_gdbarch->register_byte = generic_register_byte;

  current_gdbarch->register_raw_size = generic_register_size;

  current_gdbarch->max_register_raw_size = -1;

  current_gdbarch->register_virtual_size = generic_register_size;

  current_gdbarch->max_register_virtual_size = -1;

  current_gdbarch->print_registers_info = default_print_registers_info;

  current_gdbarch->register_sim_regno = legacy_register_sim_regno;

  current_gdbarch->cannot_fetch_register = cannot_register_not;

  current_gdbarch->cannot_store_register = cannot_register_not;

  current_gdbarch->use_generic_dummy_frames = -1;

  current_gdbarch->call_dummy_start_offset = -1;

  current_gdbarch->call_dummy_breakpoint_offset = -1;

  current_gdbarch->call_dummy_breakpoint_offset_p = -1;

  current_gdbarch->call_dummy_length = -1;

  current_gdbarch->call_dummy_p = -1;

  current_gdbarch->call_dummy_words = legacy_call_dummy_words;

  current_gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;

  current_gdbarch->call_dummy_stack_adjust_p = -1;

  current_gdbarch->init_frame_pc_first = init_frame_pc_noop;

  current_gdbarch->init_frame_pc = init_frame_pc_default;

  current_gdbarch->coerce_float_to_double = default_coerce_float_to_double;

  current_gdbarch->get_saved_register = generic_unwind_get_saved_register;

  current_gdbarch->register_convertible = generic_register_convertible_not;

  current_gdbarch->convert_register_p = legacy_convert_register_p;

  current_gdbarch->register_to_value = legacy_register_to_value;

  current_gdbarch->value_to_register = legacy_value_to_register;

  current_gdbarch->pointer_to_address = unsigned_pointer_to_address;

  current_gdbarch->address_to_pointer = unsigned_address_to_pointer;

  current_gdbarch->return_value_on_stack = generic_return_value_on_stack_not;

  current_gdbarch->push_arguments = default_push_arguments;

  current_gdbarch->extract_return_value = legacy_extract_return_value;

  current_gdbarch->store_return_value = legacy_store_return_value;

  current_gdbarch->use_struct_convention = generic_use_struct_convention;

  current_gdbarch->prologue_frameless_p = generic_prologue_frameless_p;

  current_gdbarch->breakpoint_from_pc = legacy_breakpoint_from_pc;

  current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;

  current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;

  current_gdbarch->decr_pc_after_break = -1;

  current_gdbarch->prepare_to_proceed = default_prepare_to_proceed;

  current_gdbarch->function_start_offset = -1;

  current_gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;

  current_gdbarch->frame_args_skip = -1;

  current_gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;

  current_gdbarch->frame_chain_valid = generic_func_frame_chain_valid;

  current_gdbarch->extra_stack_alignment_needed = 1;

  current_gdbarch->convert_from_func_ptr_addr = core_addr_identity;

  current_gdbarch->addr_bits_remove = core_addr_identity;

  current_gdbarch->smash_text_address = core_addr_identity;

  current_gdbarch->print_insn = legacy_print_insn;

  current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;

  current_gdbarch->in_solib_call_trampoline = generic_in_solib_call_trampoline;

  current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;

  current_gdbarch->pc_in_sigtramp = legacy_pc_in_sigtramp;

  current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;

  current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;

  current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;

  current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;

  /* gdbarch_alloc() */

  return current_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)

{

  struct ui_file *log;

  struct cleanup *cleanups;

  long dummy;

  char *buf;

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

  if (!GDB_MULTI_ARCH)

    return;

  log = mem_fileopen ();

  cleanups = make_cleanup_ui_file_delete (log);

  /* fundamental */

  if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)

    fprintf_unfiltered (log, "\n\tbyte-order");

  if (gdbarch->bfd_arch_info == NULL)

    fprintf_unfiltered (log, "\n\tbfd_arch_info");

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

  if (gdbarch->char_signed == -1)

    gdbarch->char_signed = 1;

  /* 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 read_sp, invalid_p == 0 */

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

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

  /* Skip verify of pseudo_register_read, has predicate */

  /* Skip verify of pseudo_register_write, has predicate */

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tnum_regs");

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

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

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

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

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

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

  /* Skip verify of npc_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 > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tregister_size");

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tregister_bytes");

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

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

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tmax_register_raw_size");

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

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tmax_register_virtual_size");

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tregister_virtual_type");

  /* Skip verify of do_registers_info, has predicate */

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

  /* Skip verify of print_float_info, has predicate */

  /* Skip verify of print_vector_info, has predicate */

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

  /* Skip verify of get_longjmp_target, has predicate */

  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tuse_generic_dummy_frames");

  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tcall_dummy_location");

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tcall_dummy_address");

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tcall_dummy_start_offset");

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset");

  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset_p");

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tcall_dummy_length");

  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tpc_in_call_dummy");

  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tcall_dummy_p");

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

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

  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust_p");

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust");

  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)

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

    fprintf_unfiltered (log, "\n\tfix_call_dummy");

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

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

  /* 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 convert_register_p, invalid_p == 0 */

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