Subversion Repositories openrisc_me

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

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

   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007

   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''.

   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"

#include "gdbcmd.h"

#include "inferior.h" 

#include "symcat.h"

#include "floatformat.h"

#include "gdb_assert.h"

#include "gdb_string.h"

#include "gdb-events.h"

#include "reggroups.h"

#include "osabi.h"

#include "gdb_obstack.h"

/* Static function declarations */

static void alloc_gdbarch_data (struct gdbarch *);

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

#ifndef GDBARCH_DEBUG

#define GDBARCH_DEBUG 0

#endif

int gdbarch_debug = GDBARCH_DEBUG;

static void

show_gdbarch_debug (struct ui_file *file, int from_tty,

                    struct cmd_list_element *c, const char *value)

{

  fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);

}

static const char *

pformat (const struct floatformat **format)

{

  if (format == NULL)

    return "(null)";

  else

    /* Just print out one of them - this is only for diagnostics.  */

    return format[0]->name;

}

/* Maintain the struct gdbarch object */

struct gdbarch

{

  /* Has this architecture been fully initialized?  */

  int initialized_p;

  /* An obstack bound to the lifetime of the architecture.  */

  struct obstack *obstack;

  /* basic architectural information */

  const struct bfd_arch_info * bfd_arch_info;

  int byte_order;

  enum gdb_osabi osabi;

  const struct target_desc * target_desc;

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

  int short_bit;

  int int_bit;

  int long_bit;

  int long_long_bit;

  int float_bit;

  const struct floatformat ** float_format;

  int double_bit;

  const struct floatformat ** double_format;

  int long_double_bit;

  const struct floatformat ** long_double_format;

  int ptr_bit;

  int addr_bit;

  int char_signed;

  gdbarch_read_pc_ftype *read_pc;

  gdbarch_write_pc_ftype *write_pc;

  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 pc_regnum;

  int ps_regnum;

  int fp0_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;

  gdbarch_register_type_ftype *register_type;

  gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;

  int deprecated_fp_regnum;

  gdbarch_push_dummy_call_ftype *push_dummy_call;

  int call_dummy_location;

  gdbarch_push_dummy_code_ftype *push_dummy_code;

  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_cannot_fetch_register_ftype *cannot_fetch_register;

  gdbarch_cannot_store_register_ftype *cannot_store_register;

  gdbarch_get_longjmp_target_ftype *get_longjmp_target;

  int believe_pcc_promotion;

  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_value_from_register_ftype *value_from_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_ftype *return_value;

  gdbarch_skip_prologue_ftype *skip_prologue;

  gdbarch_inner_than_ftype *inner_than;

  gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;

  gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;

  gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;

  gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;

  CORE_ADDR decr_pc_after_break;

  CORE_ADDR deprecated_function_start_offset;

  gdbarch_remote_register_number_ftype *remote_register_number;

  gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address;

  CORE_ADDR frame_args_skip;

  gdbarch_unwind_pc_ftype *unwind_pc;

  gdbarch_unwind_sp_ftype *unwind_sp;

  gdbarch_frame_num_args_ftype *frame_num_args;

  gdbarch_frame_align_ftype *frame_align;

  gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;

  int frame_red_zone_size;

  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_single_step_through_delay_ftype *single_step_through_delay;

  gdbarch_print_insn_ftype *print_insn;

  gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;

  gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;

  gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;

  gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;

  gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;

  gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;

  gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;

  const char * name_of_malloc;

  int cannot_step_breakpoint;

  int have_nonsteppable_watchpoint;

  gdbarch_address_class_type_flags_ftype *address_class_type_flags;

  gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;

  gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;

  gdbarch_register_reggroup_p_ftype *register_reggroup_p;

  gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;

  gdbarch_regset_from_core_section_ftype *regset_from_core_section;

  gdbarch_core_xfer_shared_libraries_ftype *core_xfer_shared_libraries;

  int vtable_function_descriptors;

  int vbit_in_delta;

  gdbarch_skip_permanent_breakpoint_ftype *skip_permanent_breakpoint;

  gdbarch_overlay_update_ftype *overlay_update;

  gdbarch_core_read_description_ftype *core_read_description;

  gdbarch_static_transform_name_ftype *static_transform_name;

  int sofun_address_maybe_missing;

};

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

  NULL, /* The obstack.  */

  /* basic architecture information */

  &bfd_default_arch_struct,  /* bfd_arch_info */

  BFD_ENDIAN_BIG,  /* byte_order */

  GDB_OSABI_UNKNOWN,  /* osabi */

  0,  /* target_desc */

  /* target specific vector and its dump routine */

  NULL, NULL,

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

  0, NULL, NULL,

  /* Multi-arch values */

  1,  /* bits_big_endian */

  8 * sizeof (short),  /* short_bit */

  8 * sizeof (int),  /* int_bit */

  8 * sizeof (long),  /* long_bit */

  8 * sizeof (LONGEST),  /* long_long_bit */

  8 * sizeof (float),  /* float_bit */

  0,  /* float_format */

  8 * sizeof (double),  /* double_bit */

  0,  /* double_format */

  8 * sizeof (long double),  /* long_double_bit */

  0,  /* long_double_format */

  8 * sizeof (void*),  /* ptr_bit */

  8 * sizeof (void*),  /* addr_bit */

  1,  /* char_signed */

  0,  /* read_pc */

  0,  /* write_pc */

  legacy_virtual_frame_pointer,  /* virtual_frame_pointer */

  0,  /* pseudo_register_read */

  0,  /* pseudo_register_write */

  0,  /* num_regs */

  0,  /* num_pseudo_regs */

  -1,  /* sp_regnum */

  -1,  /* pc_regnum */

  -1,  /* ps_regnum */

  0,  /* fp0_regnum */

  no_op_reg_to_regnum,  /* stab_reg_to_regnum */

  no_op_reg_to_regnum,  /* ecoff_reg_to_regnum */

  no_op_reg_to_regnum,  /* dwarf_reg_to_regnum */

  no_op_reg_to_regnum,  /* sdb_reg_to_regnum */

  no_op_reg_to_regnum,  /* dwarf2_reg_to_regnum */

  0,  /* register_name */

  0,  /* register_type */

  0,  /* unwind_dummy_id */

  -1,  /* deprecated_fp_regnum */

  0,  /* push_dummy_call */

  0,  /* call_dummy_location */

  0,  /* push_dummy_code */

  default_print_registers_info,  /* print_registers_info */

  0,  /* print_float_info */

  0,  /* print_vector_info */

  legacy_register_sim_regno,  /* register_sim_regno */

  cannot_register_not,  /* cannot_fetch_register */

  cannot_register_not,  /* cannot_store_register */

  0,  /* get_longjmp_target */

  0,  /* believe_pcc_promotion */

  generic_convert_register_p,  /* convert_register_p */

  0,  /* register_to_value */

  0,  /* value_to_register */

  0,  /* value_from_register */

  0,  /* pointer_to_address */

  0,  /* address_to_pointer */

  0,  /* integer_to_address */

  0,  /* return_value */

  0,  /* skip_prologue */

  0,  /* inner_than */

  0,  /* breakpoint_from_pc */

  0,  /* adjust_breakpoint_address */

  default_memory_insert_breakpoint,  /* memory_insert_breakpoint */

  default_memory_remove_breakpoint,  /* memory_remove_breakpoint */

  0,  /* decr_pc_after_break */

  0,  /* deprecated_function_start_offset */

  default_remote_register_number,  /* remote_register_number */

  0,  /* fetch_tls_load_module_address */

  0,  /* frame_args_skip */

  0,  /* unwind_pc */

  0,  /* unwind_sp */

  0,  /* frame_num_args */

  0,  /* frame_align */

  default_stabs_argument_has_addr,  /* stabs_argument_has_addr */

  0,  /* frame_red_zone_size */

  convert_from_func_ptr_addr_identity,  /* convert_from_func_ptr_addr */

  0,  /* addr_bits_remove */

  0,  /* smash_text_address */

  0,  /* software_single_step */

  0,  /* single_step_through_delay */

  0,  /* print_insn */

  0,  /* skip_trampoline_code */

  generic_skip_solib_resolver,  /* skip_solib_resolver */

  0,  /* in_solib_return_trampoline */

  generic_in_function_epilogue_p,  /* in_function_epilogue_p */

  construct_inferior_arguments,  /* construct_inferior_arguments */

  0,  /* elf_make_msymbol_special */

  0,  /* coff_make_msymbol_special */

  "malloc",  /* name_of_malloc */

  0,  /* cannot_step_breakpoint */

  0,  /* have_nonsteppable_watchpoint */

  0,  /* address_class_type_flags */

  0,  /* address_class_type_flags_to_name */

  0,  /* address_class_name_to_type_flags */

  default_register_reggroup_p,  /* register_reggroup_p */

  0,  /* fetch_pointer_argument */

  0,  /* regset_from_core_section */

  0,  /* core_xfer_shared_libraries */

  0,  /* vtable_function_descriptors */

  0,  /* vbit_in_delta */

  0,  /* skip_permanent_breakpoint */

  0,  /* overlay_update */

  0,  /* core_read_description */

  0,  /* static_transform_name */

  0,  /* sofun_address_maybe_missing */

  /* startup_gdbarch() */

};

struct gdbarch *current_gdbarch = &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;

  /* Create an obstack for allocating all the per-architecture memory,

     then use that to allocate the architecture vector.  */

  struct obstack *obstack = XMALLOC (struct obstack);

  obstack_init (obstack);

  gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));

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

  gdbarch->obstack = obstack;

  alloc_gdbarch_data (gdbarch);

  gdbarch->tdep = tdep;

  gdbarch->bfd_arch_info = info->bfd_arch_info;

  gdbarch->byte_order = info->byte_order;

  gdbarch->osabi = info->osabi;

  gdbarch->target_desc = info->target_desc;

  /* Force the explicit initialization of these. */

  gdbarch->bits_big_endian = (gdbarch->byte_order == BFD_ENDIAN_BIG);

  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*gdbarch->long_bit;

  gdbarch->float_bit = 4*TARGET_CHAR_BIT;

  gdbarch->double_bit = 8*TARGET_CHAR_BIT;

  gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;

  gdbarch->ptr_bit = gdbarch->int_bit;

  gdbarch->char_signed = -1;

  gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;

  gdbarch->num_regs = -1;

  gdbarch->sp_regnum = -1;

  gdbarch->pc_regnum = -1;

  gdbarch->ps_regnum = -1;

  gdbarch->fp0_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->deprecated_fp_regnum = -1;

  gdbarch->call_dummy_location = AT_ENTRY_POINT;

  gdbarch->print_registers_info = default_print_registers_info;

  gdbarch->register_sim_regno = legacy_register_sim_regno;

  gdbarch->cannot_fetch_register = cannot_register_not;

  gdbarch->cannot_store_register = cannot_register_not;

  gdbarch->convert_register_p = generic_convert_register_p;

  gdbarch->value_from_register = default_value_from_register;

  gdbarch->pointer_to_address = unsigned_pointer_to_address;

  gdbarch->address_to_pointer = unsigned_address_to_pointer;

  gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;

  gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;

  gdbarch->remote_register_number = default_remote_register_number;

  gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;

  gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;

  gdbarch->addr_bits_remove = core_addr_identity;

  gdbarch->smash_text_address = core_addr_identity;

  gdbarch->skip_trampoline_code = generic_skip_trampoline_code;

  gdbarch->skip_solib_resolver = generic_skip_solib_resolver;

  gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;

  gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;

  gdbarch->construct_inferior_arguments = construct_inferior_arguments;

  gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;

  gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;

  gdbarch->name_of_malloc = "malloc";

  gdbarch->register_reggroup_p = default_register_reggroup_p;

  /* gdbarch_alloc() */

  return gdbarch;

}

/* Allocate extra space using the per-architecture obstack.  */

void *

gdbarch_obstack_zalloc (struct gdbarch *arch, long size)

{

  void *data = obstack_alloc (arch->obstack, size);

  memset (data, 0, size);

  return data;

}

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

{

  struct obstack *obstack;

  gdb_assert (arch != NULL);

  gdb_assert (!arch->initialized_p);

  obstack = arch->obstack;

  obstack_free (obstack, 0); /* Includes the ARCH.  */

  xfree (obstack);

}

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

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

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

  if (gdbarch->float_format == 0)

    gdbarch->float_format = floatformats_ieee_single;

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

  if (gdbarch->double_format == 0)

    gdbarch->double_format = floatformats_ieee_double;

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

  if (gdbarch->long_double_format == 0)

    gdbarch->long_double_format = floatformats_ieee_double;

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

  if (gdbarch->addr_bit == 0)

    gdbarch->addr_bit = gdbarch_ptr_bit (gdbarch);

  if (gdbarch->char_signed == -1)

    gdbarch->char_signed = 1;

  /* Skip verify of read_pc, has predicate */

  /* Skip verify of write_pc, has predicate */

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

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

  /* Skip verify of fp0_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 */

  if (gdbarch->register_name == 0)

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

  /* Skip verify of register_type, has predicate */

  /* Skip verify of unwind_dummy_id, has predicate */

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

  /* Skip verify of push_dummy_call, has predicate */

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

  /* Skip verify of push_dummy_code, 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 cannot_fetch_register, invalid_p == 0 */

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

  /* Skip verify of get_longjmp_target, has predicate */

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

  /* Skip verify of value_from_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 integer_to_address, has predicate */

  /* Skip verify of return_value, has predicate */

  if (gdbarch->skip_prologue == 0)

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

  if (gdbarch->inner_than == 0)

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

  if (gdbarch->breakpoint_from_pc == 0)

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

  /* Skip verify of adjust_breakpoint_address, has predicate */

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

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

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

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

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

  /* Skip verify of fetch_tls_load_module_address, has predicate */

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

  /* Skip verify of unwind_pc, has predicate */

  /* Skip verify of unwind_sp, has predicate */

  /* Skip verify of frame_num_args, has predicate */

  /* Skip verify of frame_align, has predicate */

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

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

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

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

  /* Skip verify of software_single_step, has predicate */

  /* Skip verify of single_step_through_delay, has predicate */

  if (gdbarch->print_insn == 0)

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

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

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

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

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

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

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

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

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

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

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

  /* Skip verify of address_class_type_flags, has predicate */

  /* Skip verify of address_class_type_flags_to_name, has predicate */

  /* Skip verify of address_class_name_to_type_flags, has predicate */

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

  /* Skip verify of fetch_pointer_argument, has predicate */

  /* Skip verify of regset_from_core_section, has predicate */

  /* Skip verify of core_xfer_shared_libraries, has predicate */

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

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

  /* Skip verify of skip_permanent_breakpoint, has predicate */

  /* Skip verify of overlay_update, has predicate */

  /* Skip verify of core_read_description, has predicate */

  /* Skip verify of static_transform_name, has predicate */

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

  buf = ui_file_xstrdup (log, &dummy);

  make_cleanup (xfree, buf);

  if (strlen (buf) > 0)

    internal_error (__FILE__, __LINE__,

                    _("verify_gdbarch: the following are invalid ...%s"),

                    buf);

  do_cleanups (cleanups);

}

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

  fprintf_unfiltered (file,

                      "gdbarch_dump: addr_bit = %s\n",

                      paddr_d (gdbarch->addr_bit));

  fprintf_unfiltered (file,

                      "gdbarch_dump: addr_bits_remove = <0x%lx>\n",

                      (long) gdbarch->addr_bits_remove);

  fprintf_unfiltered (file,

                      "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",

                      gdbarch_address_class_name_to_type_flags_p (gdbarch));

  fprintf_unfiltered (file,

                      "gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\n",

                      (long) gdbarch->address_class_name_to_type_flags);

  fprintf_unfiltered (file,

                      "gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",

                      gdbarch_address_class_type_flags_p (gdbarch));

  fprintf_unfiltered (file,

                      "gdbarch_dump: address_class_type_flags = <0x%lx>\n",

                      (long) gdbarch->address_class_type_flags);

  fprintf_unfiltered (file,

                      "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",

                      gdbarch_address_class_type_flags_to_name_p (gdbarch));

  fprintf_unfiltered (file,

                      "gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",

                      (long) gdbarch->address_class_type_flags_to_name);

  fprintf_unfiltered (file,

                      "gdbarch_dump: address_to_pointer = <0x%lx>\n",

                      (long) gdbarch->address_to_pointer);

  fprintf_unfiltered (file,

                      "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",

                      gdbarch_adjust_breakpoint_address_p (gdbarch));

  fprintf_unfiltered (file,

                      "gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",

                      (long) gdbarch->adjust_breakpoint_address);

  fprintf_unfiltered (file,

                      "gdbarch_dump: believe_pcc_promotion = %s\n",

                      paddr_d (gdbarch->believe_pcc_promotion));

  fprintf_unfiltered (file,

                      "gdbarch_dump: bfd_arch_info = %s\n",

                      gdbarch_bfd_arch_info (gdbarch)->printable_name);

  fprintf_unfiltered (file,

                      "gdbarch_dump: bits_big_endian = %s\n",

                      paddr_d (gdbarch->bits_big_endian));

  fprintf_unfiltered (file,

                      "gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",

                      (long) gdbarch->breakpoint_from_pc);

  fprintf_unfiltered (file,

                      "gdbarch_dump: byte_order = %s\n",

                      paddr_d (gdbarch->byte_order));

  fprintf_unfiltered (file,

                      "gdbarch_dump: call_dummy_location = %s\n",

                      paddr_d (gdbarch->call_dummy_location));

  fprintf_unfiltered (file,

                      "gdbarch_dump: cannot_fetch_register = <0x%lx>\n",

                      (long) gdbarch->cannot_fetch_register);

  fprintf_unfiltered (file,

                      "gdbarch_dump: cannot_step_breakpoint = %s\n",

                      paddr_d (gdbarch->cannot_step_breakpoint));

  fprintf_unfiltered (file,

                      "gdbarch_dump: cannot_store_register = <0x%lx>\n",

                      (long) gdbarch->cannot_store_register);

  fprintf_unfiltered (file,

                      "gdbarch_dump: char_signed = %s\n",

                      paddr_d (gdbarch->char_signed));

  fprintf_unfiltered (file,

                      "gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",

                      (long) gdbarch->coff_make_msymbol_special);

  fprintf_unfiltered (file,

                      "gdbarch_dump: construct_inferior_arguments = <0x%lx>\n",

                      (long) gdbarch->construct_inferior_arguments);

  fprintf_unfiltered (file,

                      "gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",

                      (long) gdbarch->convert_from_func_ptr_addr);

  fprintf_unfiltered (file,

                      "gdbarch_dump: convert_register_p = <0x%lx>\n",

                      (long) gdbarch->convert_register_p);

  fprintf_unfiltered (file,

                      "gdbarch_dump: gdbarch_core_read_description_p() = %d\n",

                      gdbarch_core_read_description_p (gdbarch));

  fprintf_unfiltered (file,

                      "gdbarch_dump: core_read_description = <0x%lx>\n",

                      (long) gdbarch->core_read_description);

  fprintf_unfiltered (file,

                      "gdbarch_dump: gdbarch_core_xfer_shared_libraries_p() = %d\n",

                      gdbarch_core_xfer_shared_libraries_p (gdbarch));

  fprintf_unfiltered (file,

                      "gdbarch_dump: core_xfer_shared_libraries = <0x%lx>\n",

                      (long) gdbarch->core_xfer_shared_libraries);

  fprintf_unfiltered (file,

                      "gdbarch_dump: decr_pc_after_break = 0x%s\n",