X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbarch.c;h=6990953c0c8c7d3c5eb99e76b354b70a0aabb37b;hb=a8cdafbd4e8dbf81a28d98de6a046bd9bc5cc097;hp=1493c00cf8346751cadc09338ab0e36a26978890;hpb=2fa5c1e0486475cf585c7ab013fe08f20676ccdd;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 1493c00cf8..6990953c0c 100644
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -71,16 +71,10 @@ 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 clear_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
@@ -148,7 +142,6 @@ struct gdbarch
   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_virtual_frame_pointer_ftype *virtual_frame_pointer;
@@ -159,9 +152,9 @@ struct gdbarch
   int sp_regnum;
   int fp_regnum;
   int pc_regnum;
+  int ps_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;
@@ -182,6 +175,7 @@ struct gdbarch
   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;
@@ -205,6 +199,9 @@ struct gdbarch
   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_fetch_pseudo_register_ftype *fetch_pseudo_register;
   gdbarch_store_pseudo_register_ftype *store_pseudo_register;
   gdbarch_pointer_to_address_ftype *pointer_to_address;
@@ -256,6 +253,7 @@ struct gdbarch
   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_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;
@@ -300,6 +298,10 @@ struct gdbarch startup_gdbarch =
   0,
   0,
   0,
+  -1,
+  -1,
+  -1,
+  -1,
   0,
   0,
   0,
@@ -311,14 +313,14 @@ struct gdbarch startup_gdbarch =
   0,
   0,
   0,
+  generic_register_size,
   0,
+  generic_register_size,
   0,
   0,
   0,
   0,
-  generic_register_raw_size,
   0,
-  generic_register_virtual_size,
   0,
   0,
   0,
@@ -342,11 +344,11 @@ struct gdbarch startup_gdbarch =
   0,
   0,
   0,
+  generic_get_saved_register,
   0,
   0,
   0,
   0,
-  generic_get_saved_register,
   0,
   0,
   0,
@@ -417,6 +419,10 @@ void
 initialize_non_multiarch ()
 {
   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);
   init_gdbarch_data (&startup_gdbarch);
 }
 
@@ -451,14 +457,13 @@ gdbarch_alloc (const struct gdbarch_info *info,
   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 = 2*TARGET_DOUBLE_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->write_fp = generic_target_write_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;
@@ -466,9 +471,9 @@ gdbarch_alloc (const struct gdbarch_info *info,
   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->nnpc_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;
@@ -477,7 +482,9 @@ gdbarch_alloc (const struct gdbarch_info *info,
   current_gdbarch->register_name = legacy_register_name;
   current_gdbarch->register_size = -1;
   current_gdbarch->register_bytes = -1;
+  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->do_registers_info = do_registers_info;
   current_gdbarch->print_float_info = default_print_float_info;
@@ -497,9 +504,13 @@ gdbarch_alloc (const struct gdbarch_info *info,
   current_gdbarch->init_frame_pc = init_frame_pc_default;
   current_gdbarch->coerce_float_to_double = default_coerce_float_to_double;
   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->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;
@@ -511,6 +522,7 @@ gdbarch_alloc (const struct gdbarch_info *info,
   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 = 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;
@@ -518,6 +530,7 @@ gdbarch_alloc (const struct gdbarch_info *info,
   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->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;
@@ -579,56 +592,45 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* 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 virtual_frame_pointer, invalid_p == 0 */
   /* Skip verify of register_read, has predicate */
   /* Skip verify of register_write, has predicate */
-  if ((GDB_MULTI_ARCH >= 2)
+  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 */
-  if ((GDB_MULTI_ARCH >= 2)
-      && (gdbarch->sp_regnum == -1))
-    fprintf_unfiltered (log, "\n\tsp_regnum");
-  if ((GDB_MULTI_ARCH >= 2)
-      && (gdbarch->fp_regnum == -1))
-    fprintf_unfiltered (log, "\n\tfp_regnum");
-  if ((GDB_MULTI_ARCH >= 2)
-      && (gdbarch->pc_regnum == -1))
-    fprintf_unfiltered (log, "\n\tpc_regnum");
+  /* 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 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)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->register_size == -1))
     fprintf_unfiltered (log, "\n\tregister_size");
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->register_bytes == -1))
     fprintf_unfiltered (log, "\n\tregister_bytes");
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->register_byte == 0))
     fprintf_unfiltered (log, "\n\tregister_byte");
-  if ((GDB_MULTI_ARCH >= 2)
-      && (gdbarch->register_raw_size == 0))
-    fprintf_unfiltered (log, "\n\tregister_raw_size");
-  if ((GDB_MULTI_ARCH >= 2)
+  /* 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");
-  if ((GDB_MULTI_ARCH >= 2)
-      && (gdbarch->register_virtual_size == 0))
-    fprintf_unfiltered (log, "\n\tregister_virtual_size");
-  if ((GDB_MULTI_ARCH >= 2)
+  /* 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 >= 2)
+  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, invalid_p == 0 */
@@ -637,125 +639,125 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* 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)
+  /* 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 >= 1)
+  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->call_dummy_location == 0))
     fprintf_unfiltered (log, "\n\tcall_dummy_location");
-  if ((GDB_MULTI_ARCH >= 2)
+  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 >= 2)
+  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 >= 2)
+  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 >= 1)
+  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 >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->call_dummy_length == -1))
     fprintf_unfiltered (log, "\n\tcall_dummy_length");
-  if ((GDB_MULTI_ARCH >= 1)
+  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 >= 1)
+  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 >= 1)
+  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 >= 2)
+  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 >= 2)
+  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 */
-  if ((GDB_MULTI_ARCH >= 1)
+  if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->get_saved_register == 0))
     fprintf_unfiltered (log, "\n\tget_saved_register");
   /* 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 */
+  /* Skip verify of value_to_register, invalid_p == 0 */
   /* Skip verify of fetch_pseudo_register, has predicate */
   /* Skip verify of store_pseudo_register, has predicate */
   /* 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_on_stack, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->extract_return_value == 0))
     fprintf_unfiltered (log, "\n\textract_return_value");
-  if ((GDB_MULTI_ARCH >= 1)
-      && (gdbarch->push_arguments == 0))
-    fprintf_unfiltered (log, "\n\tpush_arguments");
-  if ((GDB_MULTI_ARCH >= 2)
+  /* Skip verify of push_arguments, invalid_p == 0 */
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->push_dummy_frame == 0))
     fprintf_unfiltered (log, "\n\tpush_dummy_frame");
   /* Skip verify of push_return_address, has predicate */
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->pop_frame == 0))
     fprintf_unfiltered (log, "\n\tpop_frame");
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->store_struct_return == 0))
     fprintf_unfiltered (log, "\n\tstore_struct_return");
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->store_return_value == 0))
     fprintf_unfiltered (log, "\n\tstore_return_value");
   /* Skip verify of extract_struct_value_address, has predicate */
   /* Skip verify of use_struct_convention, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->frame_init_saved_regs == 0))
     fprintf_unfiltered (log, "\n\tframe_init_saved_regs");
   /* Skip verify of init_extra_frame_info, has predicate */
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->skip_prologue == 0))
     fprintf_unfiltered (log, "\n\tskip_prologue");
   /* Skip verify of prologue_frameless_p, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->inner_than == 0))
     fprintf_unfiltered (log, "\n\tinner_than");
   /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
   /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
   /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->decr_pc_after_break == -1))
     fprintf_unfiltered (log, "\n\tdecr_pc_after_break");
   /* Skip verify of prepare_to_proceed, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->function_start_offset == -1))
     fprintf_unfiltered (log, "\n\tfunction_start_offset");
   /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->frame_args_skip == -1))
     fprintf_unfiltered (log, "\n\tframe_args_skip");
   /* Skip verify of frameless_function_invocation, invalid_p == 0 */
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->frame_chain == 0))
     fprintf_unfiltered (log, "\n\tframe_chain");
-  if ((GDB_MULTI_ARCH >= 1)
-      && (gdbarch->frame_chain_valid == 0))
-    fprintf_unfiltered (log, "\n\tframe_chain_valid");
-  if ((GDB_MULTI_ARCH >= 2)
+  /* Skip verify of frame_chain_valid, invalid_p == 0 */
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->frame_saved_pc == 0))
     fprintf_unfiltered (log, "\n\tframe_saved_pc");
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->frame_args_address == 0))
     fprintf_unfiltered (log, "\n\tframe_args_address");
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->frame_locals_address == 0))
     fprintf_unfiltered (log, "\n\tframe_locals_address");
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->saved_pc_after_call == 0))
     fprintf_unfiltered (log, "\n\tsaved_pc_after_call");
-  if ((GDB_MULTI_ARCH >= 2)
+  if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
       && (gdbarch->frame_num_args == 0))
     fprintf_unfiltered (log, "\n\tframe_num_args");
   /* Skip verify of stack_align, has predicate */
@@ -775,6 +777,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
   /* Skip verify of print_insn, invalid_p == 0 */
   /* Skip verify of skip_trampoline_code, invalid_p == 0 */
   /* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
+  /* Skip verify of pc_in_sigtramp, 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 dwarf2_build_frame_info, has predicate */
@@ -1016,6 +1019,17 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->convert_from_func_ptr_addr
                         /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
 #endif
+#ifdef CONVERT_REGISTER_P
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "CONVERT_REGISTER_P(regnum)",
+                      XSTRING (CONVERT_REGISTER_P (regnum)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: CONVERT_REGISTER_P = 0x%08lx\n",
+                        (long) current_gdbarch->convert_register_p
+                        /*CONVERT_REGISTER_P ()*/);
+#endif
 #ifdef DECR_PC_AFTER_BREAK
   fprintf_unfiltered (file,
                       "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
@@ -1283,6 +1297,17 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
                       (long) FUNCTION_START_OFFSET);
 #endif
+#ifdef GET_LONGJMP_TARGET
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "GET_LONGJMP_TARGET(pc)",
+                      XSTRING (GET_LONGJMP_TARGET (pc)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: GET_LONGJMP_TARGET = 0x%08lx\n",
+                        (long) current_gdbarch->get_longjmp_target
+                        /*GET_LONGJMP_TARGET ()*/);
+#endif
 #ifdef GET_SAVED_REGISTER
 #if GDB_MULTI_ARCH
   /* Macro might contain `[{}]' when not multi-arch */
@@ -1410,14 +1435,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->memory_remove_breakpoint
                         /*MEMORY_REMOVE_BREAKPOINT ()*/);
 #endif
-#ifdef NNPC_REGNUM
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: NNPC_REGNUM # %s\n",
-                      XSTRING (NNPC_REGNUM));
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: NNPC_REGNUM = %d\n",
-                      NNPC_REGNUM);
-#endif
 #ifdef NPC_REGNUM
   fprintf_unfiltered (file,
                       "gdbarch_dump: NPC_REGNUM # %s\n",
@@ -1461,6 +1478,17 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->pc_in_call_dummy
                         /*PC_IN_CALL_DUMMY ()*/);
 #endif
+#ifdef PC_IN_SIGTRAMP
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "PC_IN_SIGTRAMP(pc, name)",
+                      XSTRING (PC_IN_SIGTRAMP (pc, name)));
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: PC_IN_SIGTRAMP = 0x%08lx\n",
+                        (long) current_gdbarch->pc_in_sigtramp
+                        /*PC_IN_SIGTRAMP ()*/);
+#endif
 #ifdef PC_REGNUM
   fprintf_unfiltered (file,
                       "gdbarch_dump: PC_REGNUM # %s\n",
@@ -1530,6 +1558,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->prologue_frameless_p
                         /*PROLOGUE_FRAMELESS_P ()*/);
 #endif
+#ifdef PS_REGNUM
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: PS_REGNUM # %s\n",
+                      XSTRING (PS_REGNUM));
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: PS_REGNUM = %d\n",
+                      PS_REGNUM);
+#endif
 #ifdef PUSH_ARGUMENTS
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -1676,6 +1712,20 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                       "gdbarch_dump: REGISTER_SIZE = %d\n",
                       REGISTER_SIZE);
 #endif
+#ifdef REGISTER_TO_VALUE
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "REGISTER_TO_VALUE(regnum, type, from, to)",
+                      XSTRING (REGISTER_TO_VALUE (regnum, type, from, to)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: REGISTER_TO_VALUE = 0x%08lx\n",
+                        (long) current_gdbarch->register_to_value
+                        /*REGISTER_TO_VALUE ()*/);
+#endif
 #ifdef REGISTER_VIRTUAL_SIZE
   fprintf_unfiltered (file,
                       "gdbarch_dump: %s # %s\n",
@@ -2084,20 +2134,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         (long) current_gdbarch->virtual_frame_pointer
                         /*TARGET_VIRTUAL_FRAME_POINTER ()*/);
 #endif
-#ifdef TARGET_WRITE_FP
-#if GDB_MULTI_ARCH
-  /* Macro might contain `[{}]' when not multi-arch */
-  fprintf_unfiltered (file,
-                      "gdbarch_dump: %s # %s\n",
-                      "TARGET_WRITE_FP(val)",
-                      XSTRING (TARGET_WRITE_FP (val)));
-#endif
-  if (GDB_MULTI_ARCH)
-    fprintf_unfiltered (file,
-                        "gdbarch_dump: TARGET_WRITE_FP = 0x%08lx\n",
-                        (long) current_gdbarch->write_fp
-                        /*TARGET_WRITE_FP ()*/);
-#endif
 #ifdef TARGET_WRITE_PC
 #if GDB_MULTI_ARCH
   /* Macro might contain `[{}]' when not multi-arch */
@@ -2144,6 +2180,20 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
                         "gdbarch_dump: USE_STRUCT_CONVENTION = 0x%08lx\n",
                         (long) current_gdbarch->use_struct_convention
                         /*USE_STRUCT_CONVENTION ()*/);
+#endif
+#ifdef VALUE_TO_REGISTER
+#if GDB_MULTI_ARCH
+  /* Macro might contain `[{}]' when not multi-arch */
+  fprintf_unfiltered (file,
+                      "gdbarch_dump: %s # %s\n",
+                      "VALUE_TO_REGISTER(type, regnum, from, to)",
+                      XSTRING (VALUE_TO_REGISTER (type, regnum, from, to)));
+#endif
+  if (GDB_MULTI_ARCH)
+    fprintf_unfiltered (file,
+                        "gdbarch_dump: VALUE_TO_REGISTER = 0x%08lx\n",
+                        (long) current_gdbarch->value_to_register
+                        /*VALUE_TO_REGISTER ()*/);
 #endif
   if (current_gdbarch->dump_tdep != NULL)
     current_gdbarch->dump_tdep (current_gdbarch, file);
@@ -2161,6 +2211,7 @@ gdbarch_tdep (struct gdbarch *gdbarch)
 const struct bfd_arch_info *
 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
   return gdbarch->bfd_arch_info;
@@ -2169,6 +2220,7 @@ gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
 int
 gdbarch_byte_order (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
   return gdbarch->byte_order;
@@ -2177,6 +2229,7 @@ gdbarch_byte_order (struct gdbarch *gdbarch)
 int
 gdbarch_short_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of short_bit, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
@@ -2193,6 +2246,7 @@ set_gdbarch_short_bit (struct gdbarch *gdbarch,
 int
 gdbarch_int_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of int_bit, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
@@ -2209,6 +2263,7 @@ set_gdbarch_int_bit (struct gdbarch *gdbarch,
 int
 gdbarch_long_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of long_bit, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
@@ -2225,6 +2280,7 @@ set_gdbarch_long_bit (struct gdbarch *gdbarch,
 int
 gdbarch_long_long_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of long_long_bit, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
@@ -2241,6 +2297,7 @@ set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
 int
 gdbarch_float_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of float_bit, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
@@ -2257,6 +2314,7 @@ set_gdbarch_float_bit (struct gdbarch *gdbarch,
 int
 gdbarch_double_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of double_bit, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
@@ -2273,6 +2331,7 @@ set_gdbarch_double_bit (struct gdbarch *gdbarch,
 int
 gdbarch_long_double_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of long_double_bit, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
@@ -2289,6 +2348,7 @@ set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
 int
 gdbarch_ptr_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of ptr_bit, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
@@ -2305,6 +2365,7 @@ set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
 int
 gdbarch_addr_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->addr_bit == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_addr_bit invalid");
@@ -2323,6 +2384,7 @@ set_gdbarch_addr_bit (struct gdbarch *gdbarch,
 int
 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of bfd_vma_bit, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
@@ -2339,6 +2401,7 @@ set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
 int
 gdbarch_char_signed (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->char_signed == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_char_signed invalid");
@@ -2357,6 +2420,7 @@ set_gdbarch_char_signed (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->read_pc == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_read_pc invalid");
@@ -2375,6 +2439,7 @@ set_gdbarch_read_pc (struct gdbarch *gdbarch,
 void
 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->write_pc == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_write_pc invalid");
@@ -2393,6 +2458,7 @@ set_gdbarch_write_pc (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_read_fp (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->read_fp == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_read_fp invalid");
@@ -2408,27 +2474,10 @@ set_gdbarch_read_fp (struct gdbarch *gdbarch,
   gdbarch->read_fp = read_fp;
 }
 
-void
-gdbarch_write_fp (struct gdbarch *gdbarch, CORE_ADDR val)
-{
-  if (gdbarch->write_fp == 0)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_write_fp invalid");
-  if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_write_fp called\n");
-  gdbarch->write_fp (val);
-}
-
-void
-set_gdbarch_write_fp (struct gdbarch *gdbarch,
-                      gdbarch_write_fp_ftype write_fp)
-{
-  gdbarch->write_fp = write_fp;
-}
-
 CORE_ADDR
 gdbarch_read_sp (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->read_sp == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_read_sp invalid");
@@ -2447,6 +2496,7 @@ set_gdbarch_read_sp (struct gdbarch *gdbarch,
 void
 gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->write_sp == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_write_sp invalid");
@@ -2465,6 +2515,7 @@ set_gdbarch_write_sp (struct gdbarch *gdbarch,
 void
 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->virtual_frame_pointer == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_virtual_frame_pointer invalid");
@@ -2483,12 +2534,14 @@ set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
 int
 gdbarch_register_read_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->register_read != 0;
 }
 
 void
 gdbarch_register_read (struct gdbarch *gdbarch, int regnum, char *buf)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_read == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_read invalid");
@@ -2507,12 +2560,14 @@ set_gdbarch_register_read (struct gdbarch *gdbarch,
 int
 gdbarch_register_write_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->register_write != 0;
 }
 
 void
 gdbarch_register_write (struct gdbarch *gdbarch, int regnum, char *buf)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_write == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_write invalid");
@@ -2531,6 +2586,7 @@ set_gdbarch_register_write (struct gdbarch *gdbarch,
 int
 gdbarch_num_regs (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->num_regs == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_num_regs invalid");
@@ -2549,6 +2605,7 @@ set_gdbarch_num_regs (struct gdbarch *gdbarch,
 int
 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of num_pseudo_regs, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
@@ -2565,9 +2622,8 @@ set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
 int
 gdbarch_sp_regnum (struct gdbarch *gdbarch)
 {
-  if (gdbarch->sp_regnum == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_sp_regnum invalid");
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of sp_regnum, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
   return gdbarch->sp_regnum;
@@ -2583,9 +2639,8 @@ set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
 int
 gdbarch_fp_regnum (struct gdbarch *gdbarch)
 {
-  if (gdbarch->fp_regnum == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_fp_regnum invalid");
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of fp_regnum, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp_regnum called\n");
   return gdbarch->fp_regnum;
@@ -2601,9 +2656,8 @@ set_gdbarch_fp_regnum (struct gdbarch *gdbarch,
 int
 gdbarch_pc_regnum (struct gdbarch *gdbarch)
 {
-  if (gdbarch->pc_regnum == -1)
-    internal_error (__FILE__, __LINE__,
-                    "gdbarch: gdbarch_pc_regnum invalid");
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of pc_regnum, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
   return gdbarch->pc_regnum;
@@ -2616,9 +2670,27 @@ set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
   gdbarch->pc_regnum = pc_regnum;
 }
 
+int
+gdbarch_ps_regnum (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  /* Skip verify of ps_regnum, invalid_p == 0 */
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
+  return gdbarch->ps_regnum;
+}
+
+void
+set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
+                       int ps_regnum)
+{
+  gdbarch->ps_regnum = ps_regnum;
+}
+
 int
 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of fp0_regnum, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
@@ -2635,6 +2707,7 @@ set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
 int
 gdbarch_npc_regnum (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of npc_regnum, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_npc_regnum called\n");
@@ -2648,25 +2721,10 @@ set_gdbarch_npc_regnum (struct gdbarch *gdbarch,
   gdbarch->npc_regnum = npc_regnum;
 }
 
-int
-gdbarch_nnpc_regnum (struct gdbarch *gdbarch)
-{
-  /* Skip verify of nnpc_regnum, invalid_p == 0 */
-  if (gdbarch_debug >= 2)
-    fprintf_unfiltered (gdb_stdlog, "gdbarch_nnpc_regnum called\n");
-  return gdbarch->nnpc_regnum;
-}
-
-void
-set_gdbarch_nnpc_regnum (struct gdbarch *gdbarch,
-                         int nnpc_regnum)
-{
-  gdbarch->nnpc_regnum = nnpc_regnum;
-}
-
 int
 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->stab_reg_to_regnum == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_stab_reg_to_regnum invalid");
@@ -2685,6 +2743,7 @@ set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
 int
 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->ecoff_reg_to_regnum == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_ecoff_reg_to_regnum invalid");
@@ -2703,6 +2762,7 @@ set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
 int
 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->dwarf_reg_to_regnum == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_dwarf_reg_to_regnum invalid");
@@ -2721,6 +2781,7 @@ set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
 int
 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->sdb_reg_to_regnum == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_sdb_reg_to_regnum invalid");
@@ -2739,6 +2800,7 @@ set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
 int
 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->dwarf2_reg_to_regnum == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_dwarf2_reg_to_regnum invalid");
@@ -2757,6 +2819,7 @@ set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
 char *
 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_name == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_name invalid");
@@ -2775,6 +2838,7 @@ set_gdbarch_register_name (struct gdbarch *gdbarch,
 int
 gdbarch_register_size (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_size == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_size invalid");
@@ -2793,6 +2857,7 @@ set_gdbarch_register_size (struct gdbarch *gdbarch,
 int
 gdbarch_register_bytes (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_bytes == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_bytes invalid");
@@ -2811,6 +2876,7 @@ set_gdbarch_register_bytes (struct gdbarch *gdbarch,
 int
 gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_byte == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_byte invalid");
@@ -2829,6 +2895,7 @@ set_gdbarch_register_byte (struct gdbarch *gdbarch,
 int
 gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_raw_size == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_raw_size invalid");
@@ -2847,6 +2914,7 @@ set_gdbarch_register_raw_size (struct gdbarch *gdbarch,
 int
 gdbarch_max_register_raw_size (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->max_register_raw_size == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_max_register_raw_size invalid");
@@ -2865,6 +2933,7 @@ set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch,
 int
 gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_virtual_size == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_virtual_size invalid");
@@ -2883,6 +2952,7 @@ set_gdbarch_register_virtual_size (struct gdbarch *gdbarch,
 int
 gdbarch_max_register_virtual_size (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->max_register_virtual_size == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_max_register_virtual_size invalid");
@@ -2901,6 +2971,7 @@ set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch,
 struct type *
 gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_virtual_type == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_virtual_type invalid");
@@ -2919,6 +2990,7 @@ set_gdbarch_register_virtual_type (struct gdbarch *gdbarch,
 void
 gdbarch_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->do_registers_info == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_do_registers_info invalid");
@@ -2937,6 +3009,7 @@ set_gdbarch_do_registers_info (struct gdbarch *gdbarch,
 void
 gdbarch_print_float_info (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->print_float_info == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_print_float_info invalid");
@@ -2955,6 +3028,7 @@ set_gdbarch_print_float_info (struct gdbarch *gdbarch,
 int
 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_sim_regno == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_sim_regno invalid");
@@ -2973,12 +3047,14 @@ set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
 int
 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->register_bytes_ok != 0;
 }
 
 int
 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_bytes_ok == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_bytes_ok invalid");
@@ -2997,6 +3073,7 @@ set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
 int
 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->cannot_fetch_register == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_cannot_fetch_register invalid");
@@ -3015,6 +3092,7 @@ set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
 int
 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->cannot_store_register == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_cannot_store_register invalid");
@@ -3030,9 +3108,36 @@ set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
   gdbarch->cannot_store_register = cannot_store_register;
 }
 
+int
+gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
+{
+  gdb_assert (gdbarch != NULL);
+  return gdbarch->get_longjmp_target != 0;
+}
+
+int
+gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->get_longjmp_target == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_get_longjmp_target invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
+  return gdbarch->get_longjmp_target (pc);
+}
+
+void
+set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
+                                gdbarch_get_longjmp_target_ftype get_longjmp_target)
+{
+  gdbarch->get_longjmp_target = get_longjmp_target;
+}
+
 int
 gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->use_generic_dummy_frames == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_use_generic_dummy_frames invalid");
@@ -3051,6 +3156,7 @@ set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch,
 int
 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->call_dummy_location == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_call_dummy_location invalid");
@@ -3069,6 +3175,7 @@ set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_call_dummy_address (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->call_dummy_address == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_call_dummy_address invalid");
@@ -3087,6 +3194,7 @@ set_gdbarch_call_dummy_address (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->call_dummy_start_offset == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_call_dummy_start_offset invalid");
@@ -3105,6 +3213,7 @@ set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
@@ -3123,6 +3232,7 @@ set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
 int
 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->call_dummy_breakpoint_offset_p == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
@@ -3141,6 +3251,7 @@ set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch,
 int
 gdbarch_call_dummy_length (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->call_dummy_length == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_call_dummy_length invalid");
@@ -3159,6 +3270,7 @@ set_gdbarch_call_dummy_length (struct gdbarch *gdbarch,
 int
 gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->pc_in_call_dummy == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_pc_in_call_dummy invalid");
@@ -3177,6 +3289,7 @@ set_gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch,
 int
 gdbarch_call_dummy_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->call_dummy_p == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_call_dummy_p invalid");
@@ -3195,6 +3308,7 @@ set_gdbarch_call_dummy_p (struct gdbarch *gdbarch,
 LONGEST *
 gdbarch_call_dummy_words (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of call_dummy_words, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n");
@@ -3211,6 +3325,7 @@ set_gdbarch_call_dummy_words (struct gdbarch *gdbarch,
 int
 gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n");
@@ -3227,6 +3342,7 @@ set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch,
 int
 gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->call_dummy_stack_adjust_p == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
@@ -3245,6 +3361,7 @@ set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch,
 int
 gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_call_dummy_stack_adjust invalid");
@@ -3263,6 +3380,7 @@ set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch,
 void
 gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->fix_call_dummy == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_fix_call_dummy invalid");
@@ -3281,6 +3399,7 @@ set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch,
 void
 gdbarch_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->init_frame_pc_first == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_init_frame_pc_first invalid");
@@ -3299,6 +3418,7 @@ set_gdbarch_init_frame_pc_first (struct gdbarch *gdbarch,
 void
 gdbarch_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->init_frame_pc == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_init_frame_pc invalid");
@@ -3317,6 +3437,7 @@ set_gdbarch_init_frame_pc (struct gdbarch *gdbarch,
 int
 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
   return gdbarch->believe_pcc_promotion;
@@ -3332,6 +3453,7 @@ set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
 int
 gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion_type called\n");
   return gdbarch->believe_pcc_promotion_type;
@@ -3347,6 +3469,7 @@ set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch,
 int
 gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, struct type *formal, struct type *actual)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->coerce_float_to_double == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_coerce_float_to_double invalid");
@@ -3365,6 +3488,7 @@ set_gdbarch_coerce_float_to_double (struct gdbarch *gdbarch,
 void
 gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->get_saved_register == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_get_saved_register invalid");
@@ -3383,6 +3507,7 @@ set_gdbarch_get_saved_register (struct gdbarch *gdbarch,
 int
 gdbarch_register_convertible (struct gdbarch *gdbarch, int nr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_convertible == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_convertible invalid");
@@ -3401,6 +3526,7 @@ set_gdbarch_register_convertible (struct gdbarch *gdbarch,
 void
 gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_convert_to_virtual == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_convert_to_virtual invalid");
@@ -3419,6 +3545,7 @@ set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch,
 void
 gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->register_convert_to_raw == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_register_convert_to_raw invalid");
@@ -3434,15 +3561,74 @@ set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch,
   gdbarch->register_convert_to_raw = register_convert_to_raw;
 }
 
+int
+gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->convert_register_p == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_convert_register_p invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
+  return gdbarch->convert_register_p (regnum);
+}
+
+void
+set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
+                                gdbarch_convert_register_p_ftype convert_register_p)
+{
+  gdbarch->convert_register_p = convert_register_p;
+}
+
+void
+gdbarch_register_to_value (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->register_to_value == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_register_to_value invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
+  gdbarch->register_to_value (regnum, type, from, to);
+}
+
+void
+set_gdbarch_register_to_value (struct gdbarch *gdbarch,
+                               gdbarch_register_to_value_ftype register_to_value)
+{
+  gdbarch->register_to_value = register_to_value;
+}
+
+void
+gdbarch_value_to_register (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->value_to_register == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_value_to_register invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
+  gdbarch->value_to_register (type, regnum, from, to);
+}
+
+void
+set_gdbarch_value_to_register (struct gdbarch *gdbarch,
+                               gdbarch_value_to_register_ftype value_to_register)
+{
+  gdbarch->value_to_register = value_to_register;
+}
+
 int
 gdbarch_fetch_pseudo_register_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->fetch_pseudo_register != 0;
 }
 
 void
 gdbarch_fetch_pseudo_register (struct gdbarch *gdbarch, int regnum)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->fetch_pseudo_register == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_fetch_pseudo_register invalid");
@@ -3461,12 +3647,14 @@ set_gdbarch_fetch_pseudo_register (struct gdbarch *gdbarch,
 int
 gdbarch_store_pseudo_register_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->store_pseudo_register != 0;
 }
 
 void
 gdbarch_store_pseudo_register (struct gdbarch *gdbarch, int regnum)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->store_pseudo_register == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_store_pseudo_register invalid");
@@ -3485,6 +3673,7 @@ set_gdbarch_store_pseudo_register (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->pointer_to_address == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_pointer_to_address invalid");
@@ -3503,6 +3692,7 @@ set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
 void
 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, void *buf, CORE_ADDR addr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->address_to_pointer == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_address_to_pointer invalid");
@@ -3521,12 +3711,14 @@ set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
 int
 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->integer_to_address != 0;
 }
 
 CORE_ADDR
 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->integer_to_address == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_integer_to_address invalid");
@@ -3545,6 +3737,7 @@ set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
 int
 gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->return_value_on_stack == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_return_value_on_stack invalid");
@@ -3563,6 +3756,7 @@ set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch,
 void
 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->extract_return_value == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_extract_return_value invalid");
@@ -3581,6 +3775,7 @@ set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->push_arguments == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_push_arguments invalid");
@@ -3599,6 +3794,7 @@ set_gdbarch_push_arguments (struct gdbarch *gdbarch,
 void
 gdbarch_push_dummy_frame (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->push_dummy_frame == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_push_dummy_frame invalid");
@@ -3617,12 +3813,14 @@ set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch,
 int
 gdbarch_push_return_address_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->push_return_address != 0;
 }
 
 CORE_ADDR
 gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->push_return_address == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_push_return_address invalid");
@@ -3641,6 +3839,7 @@ set_gdbarch_push_return_address (struct gdbarch *gdbarch,
 void
 gdbarch_pop_frame (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->pop_frame == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_pop_frame invalid");
@@ -3659,6 +3858,7 @@ set_gdbarch_pop_frame (struct gdbarch *gdbarch,
 void
 gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->store_struct_return == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_store_struct_return invalid");
@@ -3677,6 +3877,7 @@ set_gdbarch_store_struct_return (struct gdbarch *gdbarch,
 void
 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->store_return_value == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_store_return_value invalid");
@@ -3695,12 +3896,14 @@ set_gdbarch_store_return_value (struct gdbarch *gdbarch,
 int
 gdbarch_extract_struct_value_address_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->extract_struct_value_address != 0;
 }
 
 CORE_ADDR
 gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->extract_struct_value_address == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_extract_struct_value_address invalid");
@@ -3719,6 +3922,7 @@ set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch,
 int
 gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->use_struct_convention == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_use_struct_convention invalid");
@@ -3737,6 +3941,7 @@ set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
 void
 gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->frame_init_saved_regs == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_frame_init_saved_regs invalid");
@@ -3755,12 +3960,14 @@ set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch,
 int
 gdbarch_init_extra_frame_info_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->init_extra_frame_info != 0;
 }
 
 void
 gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->init_extra_frame_info == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_init_extra_frame_info invalid");
@@ -3779,6 +3986,7 @@ set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->skip_prologue == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_skip_prologue invalid");
@@ -3797,6 +4005,7 @@ set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
 int
 gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, CORE_ADDR ip)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->prologue_frameless_p == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_prologue_frameless_p invalid");
@@ -3815,6 +4024,7 @@ set_gdbarch_prologue_frameless_p (struct gdbarch *gdbarch,
 int
 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->inner_than == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_inner_than invalid");
@@ -3830,9 +4040,10 @@ set_gdbarch_inner_than (struct gdbarch *gdbarch,
   gdbarch->inner_than = inner_than;
 }
 
-unsigned char *
+const unsigned char *
 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->breakpoint_from_pc == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_breakpoint_from_pc invalid");
@@ -3851,6 +4062,7 @@ set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
 int
 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->memory_insert_breakpoint == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_memory_insert_breakpoint invalid");
@@ -3869,6 +4081,7 @@ set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
 int
 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->memory_remove_breakpoint == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_memory_remove_breakpoint invalid");
@@ -3887,6 +4100,7 @@ set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->decr_pc_after_break == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_decr_pc_after_break invalid");
@@ -3905,6 +4119,7 @@ set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
 int
 gdbarch_prepare_to_proceed (struct gdbarch *gdbarch, int select_it)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->prepare_to_proceed == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_prepare_to_proceed invalid");
@@ -3923,6 +4138,7 @@ set_gdbarch_prepare_to_proceed (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_function_start_offset (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->function_start_offset == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_function_start_offset invalid");
@@ -3941,6 +4157,7 @@ set_gdbarch_function_start_offset (struct gdbarch *gdbarch,
 void
 gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->remote_translate_xfer_address == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_remote_translate_xfer_address invalid");
@@ -3959,6 +4176,7 @@ set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->frame_args_skip == -1)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_frame_args_skip invalid");
@@ -3977,6 +4195,7 @@ set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
 int
 gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->frameless_function_invocation == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_frameless_function_invocation invalid");
@@ -3995,6 +4214,7 @@ set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->frame_chain == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_frame_chain invalid");
@@ -4013,6 +4233,7 @@ set_gdbarch_frame_chain (struct gdbarch *gdbarch,
 int
 gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->frame_chain_valid == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_frame_chain_valid invalid");
@@ -4031,6 +4252,7 @@ set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->frame_saved_pc == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_frame_saved_pc invalid");
@@ -4049,6 +4271,7 @@ set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->frame_args_address == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_frame_args_address invalid");
@@ -4067,6 +4290,7 @@ set_gdbarch_frame_args_address (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->frame_locals_address == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_frame_locals_address invalid");
@@ -4085,6 +4309,7 @@ set_gdbarch_frame_locals_address (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->saved_pc_after_call == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_saved_pc_after_call invalid");
@@ -4103,6 +4328,7 @@ set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch,
 int
 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->frame_num_args == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_frame_num_args invalid");
@@ -4121,12 +4347,14 @@ set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
 int
 gdbarch_stack_align_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->stack_align != 0;
 }
 
 CORE_ADDR
 gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->stack_align == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_stack_align invalid");
@@ -4145,6 +4373,7 @@ set_gdbarch_stack_align (struct gdbarch *gdbarch,
 int
 gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_extra_stack_alignment_needed called\n");
@@ -4161,12 +4390,14 @@ set_gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch,
 int
 gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->reg_struct_has_addr != 0;
 }
 
 int
 gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->reg_struct_has_addr == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_reg_struct_has_addr invalid");
@@ -4185,12 +4416,14 @@ set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch,
 int
 gdbarch_save_dummy_frame_tos_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->save_dummy_frame_tos != 0;
 }
 
 void
 gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, CORE_ADDR sp)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->save_dummy_frame_tos == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_save_dummy_frame_tos invalid");
@@ -4209,6 +4442,7 @@ set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch,
 int
 gdbarch_parm_boundary (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_parm_boundary called\n");
   return gdbarch->parm_boundary;
@@ -4224,6 +4458,7 @@ set_gdbarch_parm_boundary (struct gdbarch *gdbarch,
 const struct floatformat *
 gdbarch_float_format (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
   return gdbarch->float_format;
@@ -4239,6 +4474,7 @@ set_gdbarch_float_format (struct gdbarch *gdbarch,
 const struct floatformat *
 gdbarch_double_format (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
   return gdbarch->double_format;
@@ -4254,6 +4490,7 @@ set_gdbarch_double_format (struct gdbarch *gdbarch,
 const struct floatformat *
 gdbarch_long_double_format (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch_debug >= 2)
     fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
   return gdbarch->long_double_format;
@@ -4269,6 +4506,7 @@ set_gdbarch_long_double_format (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->convert_from_func_ptr_addr == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_convert_from_func_ptr_addr invalid");
@@ -4287,6 +4525,7 @@ set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->addr_bits_remove == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_addr_bits_remove invalid");
@@ -4305,6 +4544,7 @@ set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->smash_text_address == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_smash_text_address invalid");
@@ -4323,12 +4563,14 @@ set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
 int
 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->software_single_step != 0;
 }
 
 void
 gdbarch_software_single_step (struct gdbarch *gdbarch, enum target_signal sig, int insert_breakpoints_p)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->software_single_step == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_software_single_step invalid");
@@ -4347,6 +4589,7 @@ set_gdbarch_software_single_step (struct gdbarch *gdbarch,
 int
 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, disassemble_info *info)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->print_insn == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_print_insn invalid");
@@ -4365,6 +4608,7 @@ set_gdbarch_print_insn (struct gdbarch *gdbarch,
 CORE_ADDR
 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->skip_trampoline_code == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_skip_trampoline_code invalid");
@@ -4383,6 +4627,7 @@ set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
 int
 gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->in_solib_call_trampoline == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_in_solib_call_trampoline invalid");
@@ -4398,9 +4643,29 @@ set_gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch,
   gdbarch->in_solib_call_trampoline = in_solib_call_trampoline;
 }
 
+int
+gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
+{
+  gdb_assert (gdbarch != NULL);
+  if (gdbarch->pc_in_sigtramp == 0)
+    internal_error (__FILE__, __LINE__,
+                    "gdbarch: gdbarch_pc_in_sigtramp invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_sigtramp called\n");
+  return gdbarch->pc_in_sigtramp (pc, name);
+}
+
+void
+set_gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch,
+                            gdbarch_pc_in_sigtramp_ftype pc_in_sigtramp)
+{
+  gdbarch->pc_in_sigtramp = pc_in_sigtramp;
+}
+
 int
 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->in_function_epilogue_p == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_in_function_epilogue_p invalid");
@@ -4419,6 +4684,7 @@ set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
 char *
 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->construct_inferior_arguments == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_construct_inferior_arguments invalid");
@@ -4437,12 +4703,14 @@ set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
 int
 gdbarch_dwarf2_build_frame_info_p (struct gdbarch *gdbarch)
 {
+  gdb_assert (gdbarch != NULL);
   return gdbarch->dwarf2_build_frame_info != 0;
 }
 
 void
 gdbarch_dwarf2_build_frame_info (struct gdbarch *gdbarch, struct objfile *objfile)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->dwarf2_build_frame_info == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_dwarf2_build_frame_info invalid");
@@ -4461,6 +4729,7 @@ set_gdbarch_dwarf2_build_frame_info (struct gdbarch *gdbarch,
 void
 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->elf_make_msymbol_special == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_elf_make_msymbol_special invalid");
@@ -4479,6 +4748,7 @@ set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
 void
 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
 {
+  gdb_assert (gdbarch != NULL);
   if (gdbarch->coff_make_msymbol_special == 0)
     internal_error (__FILE__, __LINE__,
                     "gdbarch: gdbarch_coff_make_msymbol_special invalid");
@@ -4610,10 +4880,10 @@ set_gdbarch_data (struct gdbarch *gdbarch,
    data-pointer. */
 
 void *
-gdbarch_data (struct gdbarch_data *data)
+gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
 {
-  gdb_assert (data->index < current_gdbarch->nr_data);
-  return current_gdbarch->data[data->index];
+  gdb_assert (data->index < gdbarch->nr_data);
+  return gdbarch->data[data->index];
 }
 
 
@@ -4662,6 +4932,17 @@ register_gdbarch_swap (void *data,
   (*rego)->sizeof_data = sizeof_data;
 }
 
+static void
+clear_gdbarch_swap (struct gdbarch *gdbarch)
+{
+  struct gdbarch_swap *curr;
+  for (curr = gdbarch->swap;
+       curr != NULL;
+       curr = curr->next)
+    {
+      memset (curr->source->data, 0, curr->source->sizeof_data);
+    }
+}
 
 static void
 init_gdbarch_swap (struct gdbarch *gdbarch)
@@ -4678,7 +4959,6 @@ init_gdbarch_swap (struct gdbarch *gdbarch)
 	  (*curr)->source = rego;
 	  (*curr)->swap = xmalloc (rego->sizeof_data);
 	  (*curr)->next = NULL;
-	  memset (rego->data, 0, rego->sizeof_data);
 	  curr = &(*curr)->next;
 	}
       if (rego->init != NULL)
@@ -4844,7 +5124,7 @@ int
 gdbarch_update_p (struct gdbarch_info info)
 {
   struct gdbarch *new_gdbarch;
-  struct gdbarch_list **list;
+  struct gdbarch *old_gdbarch;
   struct gdbarch_registration *rego;
 
   /* Fill in missing parts of the INFO struct using a number of
@@ -4913,53 +5193,88 @@ gdbarch_update_p (struct gdbarch_info info)
       return 0;
     }
 
+  /* Swap the data belonging to the old target out setting the
+     installed data to zero.  This stops the ->init() function trying
+     to refer to the previous architecture's global data structures.  */
+  swapout_gdbarch_swap (current_gdbarch);
+  clear_gdbarch_swap (current_gdbarch);
+
+  /* Save the previously selected architecture, setting the global to
+     NULL.  This stops ->init() trying to use the previous
+     architecture's configuration.  The previous architecture may not
+     even be of the same architecture family.  The most recent
+     architecture of the same family is found at the head of the
+     rego->arches list.  */
+  old_gdbarch = current_gdbarch;
+  current_gdbarch = NULL;
+
   /* Ask the target for a replacement architecture. */
   new_gdbarch = rego->init (info, rego->arches);
 
-  /* Did the target like it?  No. Reject the change. */
+  /* Did the target like it?  No. Reject the change and revert to the
+     old architecture.  */
   if (new_gdbarch == NULL)
     {
       if (gdbarch_debug)
 	fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
+      swapin_gdbarch_swap (old_gdbarch);
+      current_gdbarch = old_gdbarch;
       return 0;
     }
 
-  /* Did the architecture change?  No. Do nothing. */
-  if (current_gdbarch == new_gdbarch)
+  /* Did the architecture change?  No.  Oops, put the old architecture
+     back.  */
+  if (old_gdbarch == new_gdbarch)
     {
       if (gdbarch_debug)
 	fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
 			    (long) new_gdbarch,
 			    new_gdbarch->bfd_arch_info->printable_name);
+      swapin_gdbarch_swap (old_gdbarch);
+      current_gdbarch = old_gdbarch;
       return 1;
     }
 
-  /* Swap all data belonging to the old target out */
-  swapout_gdbarch_swap (current_gdbarch);
-
-  /* Is this a pre-existing architecture?  Yes. Swap it in.  */
-  for (list = &rego->arches;
-       (*list) != NULL;
-       list = &(*list)->next)
-    {
-      if ((*list)->gdbarch == new_gdbarch)
-	{
-	  if (gdbarch_debug)
-	    fprintf_unfiltered (gdb_stdlog,
-                                "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
-				(long) new_gdbarch,
-				new_gdbarch->bfd_arch_info->printable_name);
-	  current_gdbarch = new_gdbarch;
-	  swapin_gdbarch_swap (new_gdbarch);
-	  architecture_changed_event ();
-	  return 1;
-	}
-    }
-
-  /* Append this new architecture to this targets list. */
-  (*list) = XMALLOC (struct gdbarch_list);
-  (*list)->next = NULL;
-  (*list)->gdbarch = new_gdbarch;
+  /* Is this a pre-existing architecture?  Yes. Move it to the front
+     of the list of architectures (keeping the list sorted Most
+     Recently Used) and then copy it in.  */
+  {
+    struct gdbarch_list **list;
+    for (list = &rego->arches;
+	 (*list) != NULL;
+	 list = &(*list)->next)
+      {
+	if ((*list)->gdbarch == new_gdbarch)
+	  {
+	    struct gdbarch_list *this;
+	    if (gdbarch_debug)
+	      fprintf_unfiltered (gdb_stdlog,
+				  "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
+				  (long) new_gdbarch,
+				  new_gdbarch->bfd_arch_info->printable_name);
+	    /* Unlink this.  */
+	    this = (*list);
+	    (*list) = this->next;
+	    /* Insert in the front.  */
+	    this->next = rego->arches;
+	    rego->arches = this;
+	    /* Copy the new architecture in.  */
+	    current_gdbarch = new_gdbarch;
+	    swapin_gdbarch_swap (new_gdbarch);
+	    architecture_changed_event ();
+	    return 1;
+	  }
+      }
+  }
+
+  /* Prepend this new architecture to the architecture list (keep the
+     list sorted Most Recently Used).  */
+  {
+    struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
+    this->next = rego->arches;
+    this->gdbarch = new_gdbarch;
+    rego->arches = this;
+  }    
 
   /* Switch to this new architecture.  Dump it out. */
   current_gdbarch = new_gdbarch;