X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbarch.c;h=54fd44469bae5fcf3adea54c881b7ac30ad3f1c5;hb=917317f4c6550f3f3e0001d0a9e5a6acd6a2d1be;hp=65d76f8d86ec2a86e766656dd3d2b6d7083b6d91;hpb=adf40b2e16832f7382ee79e498d43a70ad22e305;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c index 65d76f8d86..54fd44469b 100644 --- a/gdb/gdbarch.c +++ b/gdb/gdbarch.c @@ -1,22 +1,36 @@ -/* *INDENT-OFF* */ /* typedef (f)();'' confuses indent */ /* Dynamic architecture support for GDB, the GNU debugger. Copyright 1998-1999, Free Software Foundation, Inc. -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* *INDENT-OFF* */ /* ``typedef (f)();'' confuses indent */ + +/* This file was created with the aid of ``gdbarch.sh''. + + The bourn 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 makeing sweeping changes + to this file, modifying gdbarch.sh and using its output may prove + easier. */ #include "defs.h" @@ -44,6 +58,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "symcat.h" +/* Static function declarations */ + +static void verify_gdbarch (struct gdbarch *gdbarch); +static void init_gdbarch_data (struct gdbarch *); +static void init_gdbarch_swap (struct gdbarch *); +static void swapout_gdbarch_swap (struct gdbarch *); +static void swapin_gdbarch_swap (struct gdbarch *); + /* Convenience macro for allocting typesafe memory. */ #ifndef XMALLOC @@ -170,6 +192,8 @@ struct gdbarch gdbarch_skip_prologue_ftype *skip_prologue; gdbarch_inner_than_ftype *inner_than; gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc; + gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint; + gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint; CORE_ADDR decr_pc_after_break; CORE_ADDR function_start_offset; gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address; @@ -278,6 +302,8 @@ struct gdbarch default_gdbarch = { 0, 0, 0, + 0, + 0, /* default_gdbarch() */ }; struct gdbarch *current_gdbarch = &default_gdbarch; @@ -287,9 +313,8 @@ struct gdbarch *current_gdbarch = &default_gdbarch; ``struct gdbarch_info''. */ struct gdbarch * -gdbarch_alloc (info, tdep) - const struct gdbarch_info *info; - struct gdbarch_tdep *tdep; +gdbarch_alloc (const struct gdbarch_info *info, + struct gdbarch_tdep *tdep) { struct gdbarch *gdbarch = XMALLOC (struct gdbarch); memset (gdbarch, 0, sizeof (*gdbarch)); @@ -315,6 +340,8 @@ gdbarch_alloc (info, tdep) gdbarch->call_dummy_length = -1; gdbarch->call_dummy_p = -1; gdbarch->call_dummy_stack_adjust_p = -1; + gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint; + gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint; gdbarch->decr_pc_after_break = -1; gdbarch->function_start_offset = -1; gdbarch->frame_args_skip = -1; @@ -326,252 +353,256 @@ gdbarch_alloc (info, tdep) /* Ensure that all values in a GDBARCH are reasonable. */ -static void verify_gdbarch PARAMS ((struct gdbarch *gdbarch)); static void -verify_gdbarch (gdbarch) - struct gdbarch *gdbarch; +verify_gdbarch (struct gdbarch *gdbarch) { /* Only perform sanity checks on a multi-arch target. */ if (GDB_MULTI_ARCH <= 0) return; /* fundamental */ if (gdbarch->byte_order == 0) - fatal ("verify_gdbarch: byte-order unset"); + internal_error ("verify_gdbarch: byte-order unset"); if (gdbarch->bfd_arch_info == NULL) - fatal ("verify_gdbarch: bfd_arch_info unset"); + internal_error ("verify_gdbarch: bfd_arch_info unset"); /* Check those that need to be defined for the given multi-arch level. */ if ((GDB_MULTI_ARCH >= 1) && (gdbarch->ptr_bit == 0)) - fatal ("gdbarch: verify_gdbarch: ptr_bit invalid"); + internal_error ("gdbarch: verify_gdbarch: ptr_bit invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->short_bit == 0)) - fatal ("gdbarch: verify_gdbarch: short_bit invalid"); + internal_error ("gdbarch: verify_gdbarch: short_bit invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->int_bit == 0)) - fatal ("gdbarch: verify_gdbarch: int_bit invalid"); + internal_error ("gdbarch: verify_gdbarch: int_bit invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->long_bit == 0)) - fatal ("gdbarch: verify_gdbarch: long_bit invalid"); + internal_error ("gdbarch: verify_gdbarch: long_bit invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->long_long_bit == 0)) - fatal ("gdbarch: verify_gdbarch: long_long_bit invalid"); + internal_error ("gdbarch: verify_gdbarch: long_long_bit invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->float_bit == 0)) - fatal ("gdbarch: verify_gdbarch: float_bit invalid"); + internal_error ("gdbarch: verify_gdbarch: float_bit invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->double_bit == 0)) - fatal ("gdbarch: verify_gdbarch: double_bit invalid"); + internal_error ("gdbarch: verify_gdbarch: double_bit invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->long_double_bit == 0)) - fatal ("gdbarch: verify_gdbarch: long_double_bit invalid"); + internal_error ("gdbarch: verify_gdbarch: long_double_bit invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->read_pc == 0)) - fatal ("gdbarch: verify_gdbarch: read_pc invalid"); + internal_error ("gdbarch: verify_gdbarch: read_pc invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->write_pc == 0)) - fatal ("gdbarch: verify_gdbarch: write_pc invalid"); + internal_error ("gdbarch: verify_gdbarch: write_pc invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->read_fp == 0)) - fatal ("gdbarch: verify_gdbarch: read_fp invalid"); + internal_error ("gdbarch: verify_gdbarch: read_fp invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->write_fp == 0)) - fatal ("gdbarch: verify_gdbarch: write_fp invalid"); + internal_error ("gdbarch: verify_gdbarch: write_fp invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->read_sp == 0)) - fatal ("gdbarch: verify_gdbarch: read_sp invalid"); + internal_error ("gdbarch: verify_gdbarch: read_sp invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->write_sp == 0)) - fatal ("gdbarch: verify_gdbarch: write_sp invalid"); + internal_error ("gdbarch: verify_gdbarch: write_sp invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->num_regs == -1)) - fatal ("gdbarch: verify_gdbarch: num_regs invalid"); + internal_error ("gdbarch: verify_gdbarch: num_regs invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->sp_regnum == -1)) - fatal ("gdbarch: verify_gdbarch: sp_regnum invalid"); + internal_error ("gdbarch: verify_gdbarch: sp_regnum invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->fp_regnum == -1)) - fatal ("gdbarch: verify_gdbarch: fp_regnum invalid"); + internal_error ("gdbarch: verify_gdbarch: fp_regnum invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->pc_regnum == -1)) - fatal ("gdbarch: verify_gdbarch: pc_regnum invalid"); + internal_error ("gdbarch: verify_gdbarch: pc_regnum invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->register_name == 0)) - fatal ("gdbarch: verify_gdbarch: register_name invalid"); + internal_error ("gdbarch: verify_gdbarch: register_name invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->register_size == -1)) - fatal ("gdbarch: verify_gdbarch: register_size invalid"); + internal_error ("gdbarch: verify_gdbarch: register_size invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->register_bytes == -1)) - fatal ("gdbarch: verify_gdbarch: register_bytes invalid"); + internal_error ("gdbarch: verify_gdbarch: register_bytes invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->register_byte == 0)) - fatal ("gdbarch: verify_gdbarch: register_byte invalid"); + internal_error ("gdbarch: verify_gdbarch: register_byte invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->register_raw_size == 0)) - fatal ("gdbarch: verify_gdbarch: register_raw_size invalid"); + internal_error ("gdbarch: verify_gdbarch: register_raw_size invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->max_register_raw_size == -1)) - fatal ("gdbarch: verify_gdbarch: max_register_raw_size invalid"); + internal_error ("gdbarch: verify_gdbarch: max_register_raw_size invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->register_virtual_size == 0)) - fatal ("gdbarch: verify_gdbarch: register_virtual_size invalid"); + internal_error ("gdbarch: verify_gdbarch: register_virtual_size invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->max_register_virtual_size == -1)) - fatal ("gdbarch: verify_gdbarch: max_register_virtual_size invalid"); + internal_error ("gdbarch: verify_gdbarch: max_register_virtual_size invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->register_virtual_type == 0)) - fatal ("gdbarch: verify_gdbarch: register_virtual_type invalid"); + internal_error ("gdbarch: verify_gdbarch: register_virtual_type invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->use_generic_dummy_frames == -1)) - fatal ("gdbarch: verify_gdbarch: use_generic_dummy_frames invalid"); + internal_error ("gdbarch: verify_gdbarch: use_generic_dummy_frames invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->call_dummy_location == 0)) - fatal ("gdbarch: verify_gdbarch: call_dummy_location invalid"); + internal_error ("gdbarch: verify_gdbarch: call_dummy_location invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0)) - fatal ("gdbarch: verify_gdbarch: call_dummy_address invalid"); + internal_error ("gdbarch: verify_gdbarch: call_dummy_address invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->call_dummy_start_offset == -1)) - fatal ("gdbarch: verify_gdbarch: call_dummy_start_offset invalid"); + internal_error ("gdbarch: verify_gdbarch: call_dummy_start_offset invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->call_dummy_breakpoint_offset == -1)) - fatal ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset invalid"); + internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->call_dummy_breakpoint_offset_p == -1)) - fatal ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset_p invalid"); + internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset_p invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->call_dummy_length == -1)) - fatal ("gdbarch: verify_gdbarch: call_dummy_length invalid"); + internal_error ("gdbarch: verify_gdbarch: call_dummy_length invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->pc_in_call_dummy == 0)) - fatal ("gdbarch: verify_gdbarch: pc_in_call_dummy invalid"); + internal_error ("gdbarch: verify_gdbarch: pc_in_call_dummy invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->call_dummy_p == -1)) - fatal ("gdbarch: verify_gdbarch: call_dummy_p invalid"); + internal_error ("gdbarch: verify_gdbarch: call_dummy_p invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->call_dummy_stack_adjust_p == -1)) - fatal ("gdbarch: verify_gdbarch: call_dummy_stack_adjust_p invalid"); + internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust_p invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)) - fatal ("gdbarch: verify_gdbarch: call_dummy_stack_adjust invalid"); + internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->fix_call_dummy == 0)) - fatal ("gdbarch: verify_gdbarch: fix_call_dummy invalid"); + internal_error ("gdbarch: verify_gdbarch: fix_call_dummy invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->get_saved_register == 0)) - fatal ("gdbarch: verify_gdbarch: get_saved_register invalid"); + internal_error ("gdbarch: verify_gdbarch: get_saved_register invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->register_convertible == 0)) - fatal ("gdbarch: verify_gdbarch: register_convertible invalid"); + internal_error ("gdbarch: verify_gdbarch: register_convertible invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->register_convert_to_virtual == 0)) - fatal ("gdbarch: verify_gdbarch: register_convert_to_virtual invalid"); + internal_error ("gdbarch: verify_gdbarch: register_convert_to_virtual invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->register_convert_to_raw == 0)) - fatal ("gdbarch: verify_gdbarch: register_convert_to_raw invalid"); + internal_error ("gdbarch: verify_gdbarch: register_convert_to_raw invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->extract_return_value == 0)) - fatal ("gdbarch: verify_gdbarch: extract_return_value invalid"); + internal_error ("gdbarch: verify_gdbarch: extract_return_value invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->push_arguments == 0)) - fatal ("gdbarch: verify_gdbarch: push_arguments invalid"); + internal_error ("gdbarch: verify_gdbarch: push_arguments invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->push_dummy_frame == 0)) - fatal ("gdbarch: verify_gdbarch: push_dummy_frame invalid"); + internal_error ("gdbarch: verify_gdbarch: push_dummy_frame invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->push_return_address == 0)) - fatal ("gdbarch: verify_gdbarch: push_return_address invalid"); + internal_error ("gdbarch: verify_gdbarch: push_return_address invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->pop_frame == 0)) - fatal ("gdbarch: verify_gdbarch: pop_frame invalid"); + internal_error ("gdbarch: verify_gdbarch: pop_frame invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->d10v_make_daddr == 0)) - fatal ("gdbarch: verify_gdbarch: d10v_make_daddr invalid"); + internal_error ("gdbarch: verify_gdbarch: d10v_make_daddr invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->d10v_make_iaddr == 0)) - fatal ("gdbarch: verify_gdbarch: d10v_make_iaddr invalid"); + internal_error ("gdbarch: verify_gdbarch: d10v_make_iaddr invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->d10v_daddr_p == 0)) - fatal ("gdbarch: verify_gdbarch: d10v_daddr_p invalid"); + internal_error ("gdbarch: verify_gdbarch: d10v_daddr_p invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->d10v_iaddr_p == 0)) - fatal ("gdbarch: verify_gdbarch: d10v_iaddr_p invalid"); + internal_error ("gdbarch: verify_gdbarch: d10v_iaddr_p invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->d10v_convert_daddr_to_raw == 0)) - fatal ("gdbarch: verify_gdbarch: d10v_convert_daddr_to_raw invalid"); + internal_error ("gdbarch: verify_gdbarch: d10v_convert_daddr_to_raw invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->d10v_convert_iaddr_to_raw == 0)) - fatal ("gdbarch: verify_gdbarch: d10v_convert_iaddr_to_raw invalid"); + internal_error ("gdbarch: verify_gdbarch: d10v_convert_iaddr_to_raw invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->store_struct_return == 0)) - fatal ("gdbarch: verify_gdbarch: store_struct_return invalid"); + internal_error ("gdbarch: verify_gdbarch: store_struct_return invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->store_return_value == 0)) - fatal ("gdbarch: verify_gdbarch: store_return_value invalid"); + internal_error ("gdbarch: verify_gdbarch: store_return_value invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->extract_struct_value_address == 0)) - fatal ("gdbarch: verify_gdbarch: extract_struct_value_address invalid"); + internal_error ("gdbarch: verify_gdbarch: extract_struct_value_address invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->use_struct_convention == 0)) - fatal ("gdbarch: verify_gdbarch: use_struct_convention invalid"); + internal_error ("gdbarch: verify_gdbarch: use_struct_convention invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->frame_init_saved_regs == 0)) - fatal ("gdbarch: verify_gdbarch: frame_init_saved_regs invalid"); + internal_error ("gdbarch: verify_gdbarch: frame_init_saved_regs invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->init_extra_frame_info == 0)) - fatal ("gdbarch: verify_gdbarch: init_extra_frame_info invalid"); + internal_error ("gdbarch: verify_gdbarch: init_extra_frame_info invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->skip_prologue == 0)) - fatal ("gdbarch: verify_gdbarch: skip_prologue invalid"); + internal_error ("gdbarch: verify_gdbarch: skip_prologue invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->inner_than == 0)) - fatal ("gdbarch: verify_gdbarch: inner_than invalid"); + internal_error ("gdbarch: verify_gdbarch: inner_than invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->breakpoint_from_pc == 0)) - fatal ("gdbarch: verify_gdbarch: breakpoint_from_pc invalid"); + internal_error ("gdbarch: verify_gdbarch: breakpoint_from_pc invalid"); + if ((GDB_MULTI_ARCH >= 2) + && (0)) + internal_error ("gdbarch: verify_gdbarch: memory_insert_breakpoint invalid"); + if ((GDB_MULTI_ARCH >= 2) + && (0)) + internal_error ("gdbarch: verify_gdbarch: memory_remove_breakpoint invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->decr_pc_after_break == -1)) - fatal ("gdbarch: verify_gdbarch: decr_pc_after_break invalid"); + internal_error ("gdbarch: verify_gdbarch: decr_pc_after_break invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->function_start_offset == -1)) - fatal ("gdbarch: verify_gdbarch: function_start_offset invalid"); + internal_error ("gdbarch: verify_gdbarch: function_start_offset invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->remote_translate_xfer_address == 0)) - fatal ("gdbarch: verify_gdbarch: remote_translate_xfer_address invalid"); + internal_error ("gdbarch: verify_gdbarch: remote_translate_xfer_address invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->frame_args_skip == -1)) - fatal ("gdbarch: verify_gdbarch: frame_args_skip invalid"); + internal_error ("gdbarch: verify_gdbarch: frame_args_skip invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->frameless_function_invocation == 0)) - fatal ("gdbarch: verify_gdbarch: frameless_function_invocation invalid"); + internal_error ("gdbarch: verify_gdbarch: frameless_function_invocation invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->frame_chain == 0)) - fatal ("gdbarch: verify_gdbarch: frame_chain invalid"); + internal_error ("gdbarch: verify_gdbarch: frame_chain invalid"); if ((GDB_MULTI_ARCH >= 1) && (gdbarch->frame_chain_valid == 0)) - fatal ("gdbarch: verify_gdbarch: frame_chain_valid invalid"); + internal_error ("gdbarch: verify_gdbarch: frame_chain_valid invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->frame_saved_pc == 0)) - fatal ("gdbarch: verify_gdbarch: frame_saved_pc invalid"); + internal_error ("gdbarch: verify_gdbarch: frame_saved_pc invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->frame_args_address == 0)) - fatal ("gdbarch: verify_gdbarch: frame_args_address invalid"); + internal_error ("gdbarch: verify_gdbarch: frame_args_address invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->frame_locals_address == 0)) - fatal ("gdbarch: verify_gdbarch: frame_locals_address invalid"); + internal_error ("gdbarch: verify_gdbarch: frame_locals_address invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->saved_pc_after_call == 0)) - fatal ("gdbarch: verify_gdbarch: saved_pc_after_call invalid"); + internal_error ("gdbarch: verify_gdbarch: saved_pc_after_call invalid"); if ((GDB_MULTI_ARCH >= 2) && (gdbarch->frame_num_args == 0)) - fatal ("gdbarch: verify_gdbarch: frame_num_args invalid"); + internal_error ("gdbarch: verify_gdbarch: frame_num_args invalid"); } /* Print out the details of the current architecture. */ void -gdbarch_dump () +gdbarch_dump (void) { if (TARGET_ARCHITECTURE != NULL) fprintf_unfiltered (gdb_stdlog, @@ -825,6 +856,14 @@ gdbarch_dump () "gdbarch_update: BREAKPOINT_FROM_PC = 0x%08lx\n", (long) current_gdbarch->breakpoint_from_pc /*BREAKPOINT_FROM_PC ()*/); + fprintf_unfiltered (gdb_stdlog, + "gdbarch_update: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n", + (long) current_gdbarch->memory_insert_breakpoint + /*MEMORY_INSERT_BREAKPOINT ()*/); + fprintf_unfiltered (gdb_stdlog, + "gdbarch_update: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n", + (long) current_gdbarch->memory_remove_breakpoint + /*MEMORY_REMOVE_BREAKPOINT ()*/); fprintf_unfiltered (gdb_stdlog, "gdbarch_update: DECR_PC_AFTER_BREAK = %ld\n", (long) DECR_PC_AFTER_BREAK); @@ -873,8 +912,7 @@ gdbarch_dump () } struct gdbarch_tdep * -gdbarch_tdep (gdbarch) - struct gdbarch *gdbarch; +gdbarch_tdep (struct gdbarch *gdbarch) { if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ @@ -884,8 +922,7 @@ gdbarch_tdep (gdbarch) const struct bfd_arch_info * -gdbarch_bfd_arch_info (gdbarch) - struct gdbarch *gdbarch; +gdbarch_bfd_arch_info (struct gdbarch *gdbarch) { if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ @@ -894,8 +931,7 @@ gdbarch_bfd_arch_info (gdbarch) } int -gdbarch_byte_order (gdbarch) - struct gdbarch *gdbarch; +gdbarch_byte_order (struct gdbarch *gdbarch) { if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ @@ -904,11 +940,10 @@ gdbarch_byte_order (gdbarch) } int -gdbarch_ptr_bit (gdbarch) - struct gdbarch *gdbarch; +gdbarch_ptr_bit (struct gdbarch *gdbarch) { if (gdbarch->ptr_bit == 0) - fatal ("gdbarch: gdbarch_ptr_bit invalid"); + internal_error ("gdbarch: gdbarch_ptr_bit invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n"); @@ -916,19 +951,17 @@ gdbarch_ptr_bit (gdbarch) } void -set_gdbarch_ptr_bit (gdbarch, ptr_bit) - struct gdbarch *gdbarch; - int ptr_bit; +set_gdbarch_ptr_bit (struct gdbarch *gdbarch, + int ptr_bit) { gdbarch->ptr_bit = ptr_bit; } int -gdbarch_short_bit (gdbarch) - struct gdbarch *gdbarch; +gdbarch_short_bit (struct gdbarch *gdbarch) { if (gdbarch->short_bit == 0) - fatal ("gdbarch: gdbarch_short_bit invalid"); + internal_error ("gdbarch: gdbarch_short_bit invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n"); @@ -936,19 +969,17 @@ gdbarch_short_bit (gdbarch) } void -set_gdbarch_short_bit (gdbarch, short_bit) - struct gdbarch *gdbarch; - int short_bit; +set_gdbarch_short_bit (struct gdbarch *gdbarch, + int short_bit) { gdbarch->short_bit = short_bit; } int -gdbarch_int_bit (gdbarch) - struct gdbarch *gdbarch; +gdbarch_int_bit (struct gdbarch *gdbarch) { if (gdbarch->int_bit == 0) - fatal ("gdbarch: gdbarch_int_bit invalid"); + internal_error ("gdbarch: gdbarch_int_bit invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n"); @@ -956,19 +987,17 @@ gdbarch_int_bit (gdbarch) } void -set_gdbarch_int_bit (gdbarch, int_bit) - struct gdbarch *gdbarch; - int int_bit; +set_gdbarch_int_bit (struct gdbarch *gdbarch, + int int_bit) { gdbarch->int_bit = int_bit; } int -gdbarch_long_bit (gdbarch) - struct gdbarch *gdbarch; +gdbarch_long_bit (struct gdbarch *gdbarch) { if (gdbarch->long_bit == 0) - fatal ("gdbarch: gdbarch_long_bit invalid"); + internal_error ("gdbarch: gdbarch_long_bit invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n"); @@ -976,19 +1005,17 @@ gdbarch_long_bit (gdbarch) } void -set_gdbarch_long_bit (gdbarch, long_bit) - struct gdbarch *gdbarch; - int long_bit; +set_gdbarch_long_bit (struct gdbarch *gdbarch, + int long_bit) { gdbarch->long_bit = long_bit; } int -gdbarch_long_long_bit (gdbarch) - struct gdbarch *gdbarch; +gdbarch_long_long_bit (struct gdbarch *gdbarch) { if (gdbarch->long_long_bit == 0) - fatal ("gdbarch: gdbarch_long_long_bit invalid"); + internal_error ("gdbarch: gdbarch_long_long_bit invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n"); @@ -996,19 +1023,17 @@ gdbarch_long_long_bit (gdbarch) } void -set_gdbarch_long_long_bit (gdbarch, long_long_bit) - struct gdbarch *gdbarch; - int long_long_bit; +set_gdbarch_long_long_bit (struct gdbarch *gdbarch, + int long_long_bit) { gdbarch->long_long_bit = long_long_bit; } int -gdbarch_float_bit (gdbarch) - struct gdbarch *gdbarch; +gdbarch_float_bit (struct gdbarch *gdbarch) { if (gdbarch->float_bit == 0) - fatal ("gdbarch: gdbarch_float_bit invalid"); + internal_error ("gdbarch: gdbarch_float_bit invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n"); @@ -1016,19 +1041,17 @@ gdbarch_float_bit (gdbarch) } void -set_gdbarch_float_bit (gdbarch, float_bit) - struct gdbarch *gdbarch; - int float_bit; +set_gdbarch_float_bit (struct gdbarch *gdbarch, + int float_bit) { gdbarch->float_bit = float_bit; } int -gdbarch_double_bit (gdbarch) - struct gdbarch *gdbarch; +gdbarch_double_bit (struct gdbarch *gdbarch) { if (gdbarch->double_bit == 0) - fatal ("gdbarch: gdbarch_double_bit invalid"); + internal_error ("gdbarch: gdbarch_double_bit invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n"); @@ -1036,19 +1059,17 @@ gdbarch_double_bit (gdbarch) } void -set_gdbarch_double_bit (gdbarch, double_bit) - struct gdbarch *gdbarch; - int double_bit; +set_gdbarch_double_bit (struct gdbarch *gdbarch, + int double_bit) { gdbarch->double_bit = double_bit; } int -gdbarch_long_double_bit (gdbarch) - struct gdbarch *gdbarch; +gdbarch_long_double_bit (struct gdbarch *gdbarch) { if (gdbarch->long_double_bit == 0) - fatal ("gdbarch: gdbarch_long_double_bit invalid"); + internal_error ("gdbarch: gdbarch_long_double_bit invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n"); @@ -1056,9 +1077,8 @@ gdbarch_long_double_bit (gdbarch) } void -set_gdbarch_long_double_bit (gdbarch, long_double_bit) - struct gdbarch *gdbarch; - int long_double_bit; +set_gdbarch_long_double_bit (struct gdbarch *gdbarch, + int long_double_bit) { gdbarch->long_double_bit = long_double_bit; } @@ -1067,7 +1087,7 @@ CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, int pid) { if (gdbarch->read_pc == 0) - fatal ("gdbarch: gdbarch_read_pc invalid"); + internal_error ("gdbarch: gdbarch_read_pc invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n"); @@ -1075,9 +1095,8 @@ gdbarch_read_pc (struct gdbarch *gdbarch, int pid) } void -set_gdbarch_read_pc (gdbarch, read_pc) - struct gdbarch *gdbarch; - gdbarch_read_pc_ftype read_pc; +set_gdbarch_read_pc (struct gdbarch *gdbarch, + gdbarch_read_pc_ftype read_pc) { gdbarch->read_pc = read_pc; } @@ -1086,7 +1105,7 @@ void gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, int pid) { if (gdbarch->write_pc == 0) - fatal ("gdbarch: gdbarch_write_pc invalid"); + internal_error ("gdbarch: gdbarch_write_pc invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n"); @@ -1094,9 +1113,8 @@ gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, int pid) } void -set_gdbarch_write_pc (gdbarch, write_pc) - struct gdbarch *gdbarch; - gdbarch_write_pc_ftype write_pc; +set_gdbarch_write_pc (struct gdbarch *gdbarch, + gdbarch_write_pc_ftype write_pc) { gdbarch->write_pc = write_pc; } @@ -1105,7 +1123,7 @@ CORE_ADDR gdbarch_read_fp (struct gdbarch *gdbarch) { if (gdbarch->read_fp == 0) - fatal ("gdbarch: gdbarch_read_fp invalid"); + internal_error ("gdbarch: gdbarch_read_fp invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_read_fp called\n"); @@ -1113,9 +1131,8 @@ gdbarch_read_fp (struct gdbarch *gdbarch) } void -set_gdbarch_read_fp (gdbarch, read_fp) - struct gdbarch *gdbarch; - gdbarch_read_fp_ftype read_fp; +set_gdbarch_read_fp (struct gdbarch *gdbarch, + gdbarch_read_fp_ftype read_fp) { gdbarch->read_fp = read_fp; } @@ -1124,7 +1141,7 @@ void gdbarch_write_fp (struct gdbarch *gdbarch, CORE_ADDR val) { if (gdbarch->write_fp == 0) - fatal ("gdbarch: gdbarch_write_fp invalid"); + internal_error ("gdbarch: gdbarch_write_fp invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_write_fp called\n"); @@ -1132,9 +1149,8 @@ gdbarch_write_fp (struct gdbarch *gdbarch, CORE_ADDR val) } void -set_gdbarch_write_fp (gdbarch, write_fp) - struct gdbarch *gdbarch; - gdbarch_write_fp_ftype write_fp; +set_gdbarch_write_fp (struct gdbarch *gdbarch, + gdbarch_write_fp_ftype write_fp) { gdbarch->write_fp = write_fp; } @@ -1143,7 +1159,7 @@ CORE_ADDR gdbarch_read_sp (struct gdbarch *gdbarch) { if (gdbarch->read_sp == 0) - fatal ("gdbarch: gdbarch_read_sp invalid"); + internal_error ("gdbarch: gdbarch_read_sp invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_read_sp called\n"); @@ -1151,9 +1167,8 @@ gdbarch_read_sp (struct gdbarch *gdbarch) } void -set_gdbarch_read_sp (gdbarch, read_sp) - struct gdbarch *gdbarch; - gdbarch_read_sp_ftype read_sp; +set_gdbarch_read_sp (struct gdbarch *gdbarch, + gdbarch_read_sp_ftype read_sp) { gdbarch->read_sp = read_sp; } @@ -1162,7 +1177,7 @@ void gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val) { if (gdbarch->write_sp == 0) - fatal ("gdbarch: gdbarch_write_sp invalid"); + internal_error ("gdbarch: gdbarch_write_sp invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_write_sp called\n"); @@ -1170,19 +1185,17 @@ gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val) } void -set_gdbarch_write_sp (gdbarch, write_sp) - struct gdbarch *gdbarch; - gdbarch_write_sp_ftype write_sp; +set_gdbarch_write_sp (struct gdbarch *gdbarch, + gdbarch_write_sp_ftype write_sp) { gdbarch->write_sp = write_sp; } int -gdbarch_num_regs (gdbarch) - struct gdbarch *gdbarch; +gdbarch_num_regs (struct gdbarch *gdbarch) { if (gdbarch->num_regs == -1) - fatal ("gdbarch: gdbarch_num_regs invalid"); + internal_error ("gdbarch: gdbarch_num_regs invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n"); @@ -1190,19 +1203,17 @@ gdbarch_num_regs (gdbarch) } void -set_gdbarch_num_regs (gdbarch, num_regs) - struct gdbarch *gdbarch; - int num_regs; +set_gdbarch_num_regs (struct gdbarch *gdbarch, + int num_regs) { gdbarch->num_regs = num_regs; } int -gdbarch_sp_regnum (gdbarch) - struct gdbarch *gdbarch; +gdbarch_sp_regnum (struct gdbarch *gdbarch) { if (gdbarch->sp_regnum == -1) - fatal ("gdbarch: gdbarch_sp_regnum invalid"); + internal_error ("gdbarch: gdbarch_sp_regnum invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n"); @@ -1210,19 +1221,17 @@ gdbarch_sp_regnum (gdbarch) } void -set_gdbarch_sp_regnum (gdbarch, sp_regnum) - struct gdbarch *gdbarch; - int sp_regnum; +set_gdbarch_sp_regnum (struct gdbarch *gdbarch, + int sp_regnum) { gdbarch->sp_regnum = sp_regnum; } int -gdbarch_fp_regnum (gdbarch) - struct gdbarch *gdbarch; +gdbarch_fp_regnum (struct gdbarch *gdbarch) { if (gdbarch->fp_regnum == -1) - fatal ("gdbarch: gdbarch_fp_regnum invalid"); + internal_error ("gdbarch: gdbarch_fp_regnum invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_fp_regnum called\n"); @@ -1230,19 +1239,17 @@ gdbarch_fp_regnum (gdbarch) } void -set_gdbarch_fp_regnum (gdbarch, fp_regnum) - struct gdbarch *gdbarch; - int fp_regnum; +set_gdbarch_fp_regnum (struct gdbarch *gdbarch, + int fp_regnum) { gdbarch->fp_regnum = fp_regnum; } int -gdbarch_pc_regnum (gdbarch) - struct gdbarch *gdbarch; +gdbarch_pc_regnum (struct gdbarch *gdbarch) { if (gdbarch->pc_regnum == -1) - fatal ("gdbarch: gdbarch_pc_regnum invalid"); + internal_error ("gdbarch: gdbarch_pc_regnum invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n"); @@ -1250,9 +1257,8 @@ gdbarch_pc_regnum (gdbarch) } void -set_gdbarch_pc_regnum (gdbarch, pc_regnum) - struct gdbarch *gdbarch; - int pc_regnum; +set_gdbarch_pc_regnum (struct gdbarch *gdbarch, + int pc_regnum) { gdbarch->pc_regnum = pc_regnum; } @@ -1261,7 +1267,7 @@ char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr) { if (gdbarch->register_name == 0) - fatal ("gdbarch: gdbarch_register_name invalid"); + internal_error ("gdbarch: gdbarch_register_name invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n"); @@ -1269,19 +1275,17 @@ gdbarch_register_name (struct gdbarch *gdbarch, int regnr) } void -set_gdbarch_register_name (gdbarch, register_name) - struct gdbarch *gdbarch; - gdbarch_register_name_ftype register_name; +set_gdbarch_register_name (struct gdbarch *gdbarch, + gdbarch_register_name_ftype register_name) { gdbarch->register_name = register_name; } int -gdbarch_register_size (gdbarch) - struct gdbarch *gdbarch; +gdbarch_register_size (struct gdbarch *gdbarch) { if (gdbarch->register_size == -1) - fatal ("gdbarch: gdbarch_register_size invalid"); + internal_error ("gdbarch: gdbarch_register_size invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n"); @@ -1289,19 +1293,17 @@ gdbarch_register_size (gdbarch) } void -set_gdbarch_register_size (gdbarch, register_size) - struct gdbarch *gdbarch; - int register_size; +set_gdbarch_register_size (struct gdbarch *gdbarch, + int register_size) { gdbarch->register_size = register_size; } int -gdbarch_register_bytes (gdbarch) - struct gdbarch *gdbarch; +gdbarch_register_bytes (struct gdbarch *gdbarch) { if (gdbarch->register_bytes == -1) - fatal ("gdbarch: gdbarch_register_bytes invalid"); + internal_error ("gdbarch: gdbarch_register_bytes invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes called\n"); @@ -1309,9 +1311,8 @@ gdbarch_register_bytes (gdbarch) } void -set_gdbarch_register_bytes (gdbarch, register_bytes) - struct gdbarch *gdbarch; - int register_bytes; +set_gdbarch_register_bytes (struct gdbarch *gdbarch, + int register_bytes) { gdbarch->register_bytes = register_bytes; } @@ -1320,7 +1321,7 @@ int gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr) { if (gdbarch->register_byte == 0) - fatal ("gdbarch: gdbarch_register_byte invalid"); + internal_error ("gdbarch: gdbarch_register_byte invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_byte called\n"); @@ -1328,9 +1329,8 @@ gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr) } void -set_gdbarch_register_byte (gdbarch, register_byte) - struct gdbarch *gdbarch; - gdbarch_register_byte_ftype register_byte; +set_gdbarch_register_byte (struct gdbarch *gdbarch, + gdbarch_register_byte_ftype register_byte) { gdbarch->register_byte = register_byte; } @@ -1339,7 +1339,7 @@ int gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr) { if (gdbarch->register_raw_size == 0) - fatal ("gdbarch: gdbarch_register_raw_size invalid"); + internal_error ("gdbarch: gdbarch_register_raw_size invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_raw_size called\n"); @@ -1347,19 +1347,17 @@ gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr) } void -set_gdbarch_register_raw_size (gdbarch, register_raw_size) - struct gdbarch *gdbarch; - gdbarch_register_raw_size_ftype register_raw_size; +set_gdbarch_register_raw_size (struct gdbarch *gdbarch, + gdbarch_register_raw_size_ftype register_raw_size) { gdbarch->register_raw_size = register_raw_size; } int -gdbarch_max_register_raw_size (gdbarch) - struct gdbarch *gdbarch; +gdbarch_max_register_raw_size (struct gdbarch *gdbarch) { if (gdbarch->max_register_raw_size == -1) - fatal ("gdbarch: gdbarch_max_register_raw_size invalid"); + internal_error ("gdbarch: gdbarch_max_register_raw_size invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_raw_size called\n"); @@ -1367,9 +1365,8 @@ gdbarch_max_register_raw_size (gdbarch) } void -set_gdbarch_max_register_raw_size (gdbarch, max_register_raw_size) - struct gdbarch *gdbarch; - int max_register_raw_size; +set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch, + int max_register_raw_size) { gdbarch->max_register_raw_size = max_register_raw_size; } @@ -1378,7 +1375,7 @@ int gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr) { if (gdbarch->register_virtual_size == 0) - fatal ("gdbarch: gdbarch_register_virtual_size invalid"); + internal_error ("gdbarch: gdbarch_register_virtual_size invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_size called\n"); @@ -1386,19 +1383,17 @@ gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr) } void -set_gdbarch_register_virtual_size (gdbarch, register_virtual_size) - struct gdbarch *gdbarch; - gdbarch_register_virtual_size_ftype register_virtual_size; +set_gdbarch_register_virtual_size (struct gdbarch *gdbarch, + gdbarch_register_virtual_size_ftype register_virtual_size) { gdbarch->register_virtual_size = register_virtual_size; } int -gdbarch_max_register_virtual_size (gdbarch) - struct gdbarch *gdbarch; +gdbarch_max_register_virtual_size (struct gdbarch *gdbarch) { if (gdbarch->max_register_virtual_size == -1) - fatal ("gdbarch: gdbarch_max_register_virtual_size invalid"); + internal_error ("gdbarch: gdbarch_max_register_virtual_size invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_virtual_size called\n"); @@ -1406,9 +1401,8 @@ gdbarch_max_register_virtual_size (gdbarch) } void -set_gdbarch_max_register_virtual_size (gdbarch, max_register_virtual_size) - struct gdbarch *gdbarch; - int max_register_virtual_size; +set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch, + int max_register_virtual_size) { gdbarch->max_register_virtual_size = max_register_virtual_size; } @@ -1417,7 +1411,7 @@ struct type * gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr) { if (gdbarch->register_virtual_type == 0) - fatal ("gdbarch: gdbarch_register_virtual_type invalid"); + internal_error ("gdbarch: gdbarch_register_virtual_type invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_type called\n"); @@ -1425,19 +1419,17 @@ gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr) } void -set_gdbarch_register_virtual_type (gdbarch, register_virtual_type) - struct gdbarch *gdbarch; - gdbarch_register_virtual_type_ftype register_virtual_type; +set_gdbarch_register_virtual_type (struct gdbarch *gdbarch, + gdbarch_register_virtual_type_ftype register_virtual_type) { gdbarch->register_virtual_type = register_virtual_type; } int -gdbarch_use_generic_dummy_frames (gdbarch) - struct gdbarch *gdbarch; +gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch) { if (gdbarch->use_generic_dummy_frames == -1) - fatal ("gdbarch: gdbarch_use_generic_dummy_frames invalid"); + internal_error ("gdbarch: gdbarch_use_generic_dummy_frames invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_use_generic_dummy_frames called\n"); @@ -1445,19 +1437,17 @@ gdbarch_use_generic_dummy_frames (gdbarch) } void -set_gdbarch_use_generic_dummy_frames (gdbarch, use_generic_dummy_frames) - struct gdbarch *gdbarch; - int use_generic_dummy_frames; +set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch, + int use_generic_dummy_frames) { gdbarch->use_generic_dummy_frames = use_generic_dummy_frames; } int -gdbarch_call_dummy_location (gdbarch) - struct gdbarch *gdbarch; +gdbarch_call_dummy_location (struct gdbarch *gdbarch) { if (gdbarch->call_dummy_location == 0) - fatal ("gdbarch: gdbarch_call_dummy_location invalid"); + internal_error ("gdbarch: gdbarch_call_dummy_location invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n"); @@ -1465,9 +1455,8 @@ gdbarch_call_dummy_location (gdbarch) } void -set_gdbarch_call_dummy_location (gdbarch, call_dummy_location) - struct gdbarch *gdbarch; - int call_dummy_location; +set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, + int call_dummy_location) { gdbarch->call_dummy_location = call_dummy_location; } @@ -1476,7 +1465,7 @@ CORE_ADDR gdbarch_call_dummy_address (struct gdbarch *gdbarch) { if (gdbarch->call_dummy_address == 0) - fatal ("gdbarch: gdbarch_call_dummy_address invalid"); + internal_error ("gdbarch: gdbarch_call_dummy_address invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_address called\n"); @@ -1484,19 +1473,17 @@ gdbarch_call_dummy_address (struct gdbarch *gdbarch) } void -set_gdbarch_call_dummy_address (gdbarch, call_dummy_address) - struct gdbarch *gdbarch; - gdbarch_call_dummy_address_ftype call_dummy_address; +set_gdbarch_call_dummy_address (struct gdbarch *gdbarch, + gdbarch_call_dummy_address_ftype call_dummy_address) { gdbarch->call_dummy_address = call_dummy_address; } CORE_ADDR -gdbarch_call_dummy_start_offset (gdbarch) - struct gdbarch *gdbarch; +gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch) { if (gdbarch->call_dummy_start_offset == -1) - fatal ("gdbarch: gdbarch_call_dummy_start_offset invalid"); + internal_error ("gdbarch: gdbarch_call_dummy_start_offset invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_start_offset called\n"); @@ -1504,19 +1491,17 @@ gdbarch_call_dummy_start_offset (gdbarch) } void -set_gdbarch_call_dummy_start_offset (gdbarch, call_dummy_start_offset) - struct gdbarch *gdbarch; - CORE_ADDR call_dummy_start_offset; +set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch, + CORE_ADDR call_dummy_start_offset) { gdbarch->call_dummy_start_offset = call_dummy_start_offset; } CORE_ADDR -gdbarch_call_dummy_breakpoint_offset (gdbarch) - struct gdbarch *gdbarch; +gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch) { if (gdbarch->call_dummy_breakpoint_offset == -1) - fatal ("gdbarch: gdbarch_call_dummy_breakpoint_offset invalid"); + internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n"); @@ -1524,19 +1509,17 @@ gdbarch_call_dummy_breakpoint_offset (gdbarch) } void -set_gdbarch_call_dummy_breakpoint_offset (gdbarch, call_dummy_breakpoint_offset) - struct gdbarch *gdbarch; - CORE_ADDR call_dummy_breakpoint_offset; +set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, + CORE_ADDR call_dummy_breakpoint_offset) { gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset; } int -gdbarch_call_dummy_breakpoint_offset_p (gdbarch) - struct gdbarch *gdbarch; +gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch) { if (gdbarch->call_dummy_breakpoint_offset_p == -1) - fatal ("gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid"); + internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset_p called\n"); @@ -1544,19 +1527,17 @@ gdbarch_call_dummy_breakpoint_offset_p (gdbarch) } void -set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, call_dummy_breakpoint_offset_p) - struct gdbarch *gdbarch; - int call_dummy_breakpoint_offset_p; +set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch, + int call_dummy_breakpoint_offset_p) { gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p; } int -gdbarch_call_dummy_length (gdbarch) - struct gdbarch *gdbarch; +gdbarch_call_dummy_length (struct gdbarch *gdbarch) { if (gdbarch->call_dummy_length == -1) - fatal ("gdbarch: gdbarch_call_dummy_length invalid"); + internal_error ("gdbarch: gdbarch_call_dummy_length invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n"); @@ -1564,9 +1545,8 @@ gdbarch_call_dummy_length (gdbarch) } void -set_gdbarch_call_dummy_length (gdbarch, call_dummy_length) - struct gdbarch *gdbarch; - int call_dummy_length; +set_gdbarch_call_dummy_length (struct gdbarch *gdbarch, + int call_dummy_length) { gdbarch->call_dummy_length = call_dummy_length; } @@ -1575,7 +1555,7 @@ int gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address) { if (gdbarch->pc_in_call_dummy == 0) - fatal ("gdbarch: gdbarch_pc_in_call_dummy invalid"); + internal_error ("gdbarch: gdbarch_pc_in_call_dummy invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_call_dummy called\n"); @@ -1583,19 +1563,17 @@ gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, C } void -set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy) - struct gdbarch *gdbarch; - gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy; +set_gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, + gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy) { gdbarch->pc_in_call_dummy = pc_in_call_dummy; } int -gdbarch_call_dummy_p (gdbarch) - struct gdbarch *gdbarch; +gdbarch_call_dummy_p (struct gdbarch *gdbarch) { if (gdbarch->call_dummy_p == -1) - fatal ("gdbarch: gdbarch_call_dummy_p invalid"); + internal_error ("gdbarch: gdbarch_call_dummy_p invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_p called\n"); @@ -1603,16 +1581,14 @@ gdbarch_call_dummy_p (gdbarch) } void -set_gdbarch_call_dummy_p (gdbarch, call_dummy_p) - struct gdbarch *gdbarch; - int call_dummy_p; +set_gdbarch_call_dummy_p (struct gdbarch *gdbarch, + int call_dummy_p) { gdbarch->call_dummy_p = call_dummy_p; } LONGEST * -gdbarch_call_dummy_words (gdbarch) - struct gdbarch *gdbarch; +gdbarch_call_dummy_words (struct gdbarch *gdbarch) { if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ @@ -1621,16 +1597,14 @@ gdbarch_call_dummy_words (gdbarch) } void -set_gdbarch_call_dummy_words (gdbarch, call_dummy_words) - struct gdbarch *gdbarch; - LONGEST * call_dummy_words; +set_gdbarch_call_dummy_words (struct gdbarch *gdbarch, + LONGEST * call_dummy_words) { gdbarch->call_dummy_words = call_dummy_words; } int -gdbarch_sizeof_call_dummy_words (gdbarch) - struct gdbarch *gdbarch; +gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch) { if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ @@ -1639,19 +1613,17 @@ gdbarch_sizeof_call_dummy_words (gdbarch) } void -set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_call_dummy_words) - struct gdbarch *gdbarch; - int sizeof_call_dummy_words; +set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch, + int sizeof_call_dummy_words) { gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words; } int -gdbarch_call_dummy_stack_adjust_p (gdbarch) - struct gdbarch *gdbarch; +gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch) { if (gdbarch->call_dummy_stack_adjust_p == -1) - fatal ("gdbarch: gdbarch_call_dummy_stack_adjust_p invalid"); + internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust_p invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust_p called\n"); @@ -1659,19 +1631,17 @@ gdbarch_call_dummy_stack_adjust_p (gdbarch) } void -set_gdbarch_call_dummy_stack_adjust_p (gdbarch, call_dummy_stack_adjust_p) - struct gdbarch *gdbarch; - int call_dummy_stack_adjust_p; +set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch, + int call_dummy_stack_adjust_p) { gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p; } int -gdbarch_call_dummy_stack_adjust (gdbarch) - struct gdbarch *gdbarch; +gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch) { if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0) - fatal ("gdbarch: gdbarch_call_dummy_stack_adjust invalid"); + internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust called\n"); @@ -1679,9 +1649,8 @@ gdbarch_call_dummy_stack_adjust (gdbarch) } void -set_gdbarch_call_dummy_stack_adjust (gdbarch, call_dummy_stack_adjust) - struct gdbarch *gdbarch; - int call_dummy_stack_adjust; +set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch, + int call_dummy_stack_adjust) { gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust; } @@ -1690,7 +1659,7 @@ 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) { if (gdbarch->fix_call_dummy == 0) - fatal ("gdbarch: gdbarch_fix_call_dummy invalid"); + internal_error ("gdbarch: gdbarch_fix_call_dummy invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_fix_call_dummy called\n"); @@ -1698,16 +1667,14 @@ gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE } void -set_gdbarch_fix_call_dummy (gdbarch, fix_call_dummy) - struct gdbarch *gdbarch; - gdbarch_fix_call_dummy_ftype fix_call_dummy; +set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch, + gdbarch_fix_call_dummy_ftype fix_call_dummy) { gdbarch->fix_call_dummy = fix_call_dummy; } int -gdbarch_believe_pcc_promotion (gdbarch) - struct gdbarch *gdbarch; +gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch) { if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ @@ -1716,16 +1683,14 @@ gdbarch_believe_pcc_promotion (gdbarch) } void -set_gdbarch_believe_pcc_promotion (gdbarch, believe_pcc_promotion) - struct gdbarch *gdbarch; - int believe_pcc_promotion; +set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch, + int believe_pcc_promotion) { gdbarch->believe_pcc_promotion = believe_pcc_promotion; } int -gdbarch_believe_pcc_promotion_type (gdbarch) - struct gdbarch *gdbarch; +gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch) { if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ @@ -1734,9 +1699,8 @@ gdbarch_believe_pcc_promotion_type (gdbarch) } void -set_gdbarch_believe_pcc_promotion_type (gdbarch, believe_pcc_promotion_type) - struct gdbarch *gdbarch; - int believe_pcc_promotion_type; +set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch, + int believe_pcc_promotion_type) { gdbarch->believe_pcc_promotion_type = believe_pcc_promotion_type; } @@ -1745,7 +1709,7 @@ 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) { if (gdbarch->get_saved_register == 0) - fatal ("gdbarch: gdbarch_get_saved_register invalid"); + internal_error ("gdbarch: gdbarch_get_saved_register invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_get_saved_register called\n"); @@ -1753,9 +1717,8 @@ gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *opti } void -set_gdbarch_get_saved_register (gdbarch, get_saved_register) - struct gdbarch *gdbarch; - gdbarch_get_saved_register_ftype get_saved_register; +set_gdbarch_get_saved_register (struct gdbarch *gdbarch, + gdbarch_get_saved_register_ftype get_saved_register) { gdbarch->get_saved_register = get_saved_register; } @@ -1764,7 +1727,7 @@ int gdbarch_register_convertible (struct gdbarch *gdbarch, int nr) { if (gdbarch->register_convertible == 0) - fatal ("gdbarch: gdbarch_register_convertible invalid"); + internal_error ("gdbarch: gdbarch_register_convertible invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convertible called\n"); @@ -1772,9 +1735,8 @@ gdbarch_register_convertible (struct gdbarch *gdbarch, int nr) } void -set_gdbarch_register_convertible (gdbarch, register_convertible) - struct gdbarch *gdbarch; - gdbarch_register_convertible_ftype register_convertible; +set_gdbarch_register_convertible (struct gdbarch *gdbarch, + gdbarch_register_convertible_ftype register_convertible) { gdbarch->register_convertible = register_convertible; } @@ -1783,7 +1745,7 @@ void gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to) { if (gdbarch->register_convert_to_virtual == 0) - fatal ("gdbarch: gdbarch_register_convert_to_virtual invalid"); + internal_error ("gdbarch: gdbarch_register_convert_to_virtual invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_virtual called\n"); @@ -1791,9 +1753,8 @@ gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct } void -set_gdbarch_register_convert_to_virtual (gdbarch, register_convert_to_virtual) - struct gdbarch *gdbarch; - gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual; +set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, + gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual) { gdbarch->register_convert_to_virtual = register_convert_to_virtual; } @@ -1802,7 +1763,7 @@ void gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to) { if (gdbarch->register_convert_to_raw == 0) - fatal ("gdbarch: gdbarch_register_convert_to_raw invalid"); + internal_error ("gdbarch: gdbarch_register_convert_to_raw invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_raw called\n"); @@ -1810,9 +1771,8 @@ gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int } void -set_gdbarch_register_convert_to_raw (gdbarch, register_convert_to_raw) - struct gdbarch *gdbarch; - gdbarch_register_convert_to_raw_ftype register_convert_to_raw; +set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, + gdbarch_register_convert_to_raw_ftype register_convert_to_raw) { gdbarch->register_convert_to_raw = register_convert_to_raw; } @@ -1821,7 +1781,7 @@ void gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf) { if (gdbarch->extract_return_value == 0) - fatal ("gdbarch: gdbarch_extract_return_value invalid"); + internal_error ("gdbarch: gdbarch_extract_return_value invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n"); @@ -1829,9 +1789,8 @@ gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char * } void -set_gdbarch_extract_return_value (gdbarch, extract_return_value) - struct gdbarch *gdbarch; - gdbarch_extract_return_value_ftype extract_return_value; +set_gdbarch_extract_return_value (struct gdbarch *gdbarch, + gdbarch_extract_return_value_ftype extract_return_value) { gdbarch->extract_return_value = extract_return_value; } @@ -1840,7 +1799,7 @@ CORE_ADDR gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) { if (gdbarch->push_arguments == 0) - fatal ("gdbarch: gdbarch_push_arguments invalid"); + internal_error ("gdbarch: gdbarch_push_arguments invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_push_arguments called\n"); @@ -1848,9 +1807,8 @@ gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, } void -set_gdbarch_push_arguments (gdbarch, push_arguments) - struct gdbarch *gdbarch; - gdbarch_push_arguments_ftype push_arguments; +set_gdbarch_push_arguments (struct gdbarch *gdbarch, + gdbarch_push_arguments_ftype push_arguments) { gdbarch->push_arguments = push_arguments; } @@ -1859,7 +1817,7 @@ void gdbarch_push_dummy_frame (struct gdbarch *gdbarch) { if (gdbarch->push_dummy_frame == 0) - fatal ("gdbarch: gdbarch_push_dummy_frame invalid"); + internal_error ("gdbarch: gdbarch_push_dummy_frame invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_frame called\n"); @@ -1867,9 +1825,8 @@ gdbarch_push_dummy_frame (struct gdbarch *gdbarch) } void -set_gdbarch_push_dummy_frame (gdbarch, push_dummy_frame) - struct gdbarch *gdbarch; - gdbarch_push_dummy_frame_ftype push_dummy_frame; +set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch, + gdbarch_push_dummy_frame_ftype push_dummy_frame) { gdbarch->push_dummy_frame = push_dummy_frame; } @@ -1878,7 +1835,7 @@ CORE_ADDR gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp) { if (gdbarch->push_return_address == 0) - fatal ("gdbarch: gdbarch_push_return_address invalid"); + internal_error ("gdbarch: gdbarch_push_return_address invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_push_return_address called\n"); @@ -1886,9 +1843,8 @@ gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp } void -set_gdbarch_push_return_address (gdbarch, push_return_address) - struct gdbarch *gdbarch; - gdbarch_push_return_address_ftype push_return_address; +set_gdbarch_push_return_address (struct gdbarch *gdbarch, + gdbarch_push_return_address_ftype push_return_address) { gdbarch->push_return_address = push_return_address; } @@ -1897,7 +1853,7 @@ void gdbarch_pop_frame (struct gdbarch *gdbarch) { if (gdbarch->pop_frame == 0) - fatal ("gdbarch: gdbarch_pop_frame invalid"); + internal_error ("gdbarch: gdbarch_pop_frame invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_pop_frame called\n"); @@ -1905,9 +1861,8 @@ gdbarch_pop_frame (struct gdbarch *gdbarch) } void -set_gdbarch_pop_frame (gdbarch, pop_frame) - struct gdbarch *gdbarch; - gdbarch_pop_frame_ftype pop_frame; +set_gdbarch_pop_frame (struct gdbarch *gdbarch, + gdbarch_pop_frame_ftype pop_frame) { gdbarch->pop_frame = pop_frame; } @@ -1916,7 +1871,7 @@ CORE_ADDR gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, CORE_ADDR x) { if (gdbarch->d10v_make_daddr == 0) - fatal ("gdbarch: gdbarch_d10v_make_daddr invalid"); + internal_error ("gdbarch: gdbarch_d10v_make_daddr invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_make_daddr called\n"); @@ -1924,9 +1879,8 @@ gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, CORE_ADDR x) } void -set_gdbarch_d10v_make_daddr (gdbarch, d10v_make_daddr) - struct gdbarch *gdbarch; - gdbarch_d10v_make_daddr_ftype d10v_make_daddr; +set_gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, + gdbarch_d10v_make_daddr_ftype d10v_make_daddr) { gdbarch->d10v_make_daddr = d10v_make_daddr; } @@ -1935,7 +1889,7 @@ CORE_ADDR gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, CORE_ADDR x) { if (gdbarch->d10v_make_iaddr == 0) - fatal ("gdbarch: gdbarch_d10v_make_iaddr invalid"); + internal_error ("gdbarch: gdbarch_d10v_make_iaddr invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_make_iaddr called\n"); @@ -1943,9 +1897,8 @@ gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, CORE_ADDR x) } void -set_gdbarch_d10v_make_iaddr (gdbarch, d10v_make_iaddr) - struct gdbarch *gdbarch; - gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr; +set_gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, + gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr) { gdbarch->d10v_make_iaddr = d10v_make_iaddr; } @@ -1954,7 +1907,7 @@ int gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, CORE_ADDR x) { if (gdbarch->d10v_daddr_p == 0) - fatal ("gdbarch: gdbarch_d10v_daddr_p invalid"); + internal_error ("gdbarch: gdbarch_d10v_daddr_p invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_daddr_p called\n"); @@ -1962,9 +1915,8 @@ gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, CORE_ADDR x) } void -set_gdbarch_d10v_daddr_p (gdbarch, d10v_daddr_p) - struct gdbarch *gdbarch; - gdbarch_d10v_daddr_p_ftype d10v_daddr_p; +set_gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, + gdbarch_d10v_daddr_p_ftype d10v_daddr_p) { gdbarch->d10v_daddr_p = d10v_daddr_p; } @@ -1973,7 +1925,7 @@ int gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, CORE_ADDR x) { if (gdbarch->d10v_iaddr_p == 0) - fatal ("gdbarch: gdbarch_d10v_iaddr_p invalid"); + internal_error ("gdbarch: gdbarch_d10v_iaddr_p invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_iaddr_p called\n"); @@ -1981,9 +1933,8 @@ gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, CORE_ADDR x) } void -set_gdbarch_d10v_iaddr_p (gdbarch, d10v_iaddr_p) - struct gdbarch *gdbarch; - gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p; +set_gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, + gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p) { gdbarch->d10v_iaddr_p = d10v_iaddr_p; } @@ -1992,7 +1943,7 @@ CORE_ADDR gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x) { if (gdbarch->d10v_convert_daddr_to_raw == 0) - fatal ("gdbarch: gdbarch_d10v_convert_daddr_to_raw invalid"); + internal_error ("gdbarch: gdbarch_d10v_convert_daddr_to_raw invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_convert_daddr_to_raw called\n"); @@ -2000,9 +1951,8 @@ gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x) } void -set_gdbarch_d10v_convert_daddr_to_raw (gdbarch, d10v_convert_daddr_to_raw) - struct gdbarch *gdbarch; - gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw; +set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, + gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw) { gdbarch->d10v_convert_daddr_to_raw = d10v_convert_daddr_to_raw; } @@ -2011,7 +1961,7 @@ CORE_ADDR gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x) { if (gdbarch->d10v_convert_iaddr_to_raw == 0) - fatal ("gdbarch: gdbarch_d10v_convert_iaddr_to_raw invalid"); + internal_error ("gdbarch: gdbarch_d10v_convert_iaddr_to_raw invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_d10v_convert_iaddr_to_raw called\n"); @@ -2019,9 +1969,8 @@ gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x) } void -set_gdbarch_d10v_convert_iaddr_to_raw (gdbarch, d10v_convert_iaddr_to_raw) - struct gdbarch *gdbarch; - gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw; +set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, + gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw) { gdbarch->d10v_convert_iaddr_to_raw = d10v_convert_iaddr_to_raw; } @@ -2030,7 +1979,7 @@ void gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp) { if (gdbarch->store_struct_return == 0) - fatal ("gdbarch: gdbarch_store_struct_return invalid"); + internal_error ("gdbarch: gdbarch_store_struct_return invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_store_struct_return called\n"); @@ -2038,9 +1987,8 @@ gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR } void -set_gdbarch_store_struct_return (gdbarch, store_struct_return) - struct gdbarch *gdbarch; - gdbarch_store_struct_return_ftype store_struct_return; +set_gdbarch_store_struct_return (struct gdbarch *gdbarch, + gdbarch_store_struct_return_ftype store_struct_return) { gdbarch->store_struct_return = store_struct_return; } @@ -2049,7 +1997,7 @@ void gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf) { if (gdbarch->store_return_value == 0) - fatal ("gdbarch: gdbarch_store_return_value invalid"); + internal_error ("gdbarch: gdbarch_store_return_value invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n"); @@ -2057,9 +2005,8 @@ gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *va } void -set_gdbarch_store_return_value (gdbarch, store_return_value) - struct gdbarch *gdbarch; - gdbarch_store_return_value_ftype store_return_value; +set_gdbarch_store_return_value (struct gdbarch *gdbarch, + gdbarch_store_return_value_ftype store_return_value) { gdbarch->store_return_value = store_return_value; } @@ -2068,7 +2015,7 @@ CORE_ADDR gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf) { if (gdbarch->extract_struct_value_address == 0) - fatal ("gdbarch: gdbarch_extract_struct_value_address invalid"); + internal_error ("gdbarch: gdbarch_extract_struct_value_address invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n"); @@ -2076,9 +2023,8 @@ gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf) } void -set_gdbarch_extract_struct_value_address (gdbarch, extract_struct_value_address) - struct gdbarch *gdbarch; - gdbarch_extract_struct_value_address_ftype extract_struct_value_address; +set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, + gdbarch_extract_struct_value_address_ftype extract_struct_value_address) { gdbarch->extract_struct_value_address = extract_struct_value_address; } @@ -2087,7 +2033,7 @@ int gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type) { if (gdbarch->use_struct_convention == 0) - fatal ("gdbarch: gdbarch_use_struct_convention invalid"); + internal_error ("gdbarch: gdbarch_use_struct_convention invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_use_struct_convention called\n"); @@ -2095,9 +2041,8 @@ gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type * } void -set_gdbarch_use_struct_convention (gdbarch, use_struct_convention) - struct gdbarch *gdbarch; - gdbarch_use_struct_convention_ftype use_struct_convention; +set_gdbarch_use_struct_convention (struct gdbarch *gdbarch, + gdbarch_use_struct_convention_ftype use_struct_convention) { gdbarch->use_struct_convention = use_struct_convention; } @@ -2106,7 +2051,7 @@ void gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame) { if (gdbarch->frame_init_saved_regs == 0) - fatal ("gdbarch: gdbarch_frame_init_saved_regs invalid"); + internal_error ("gdbarch: gdbarch_frame_init_saved_regs invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_init_saved_regs called\n"); @@ -2114,9 +2059,8 @@ gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame } void -set_gdbarch_frame_init_saved_regs (gdbarch, frame_init_saved_regs) - struct gdbarch *gdbarch; - gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs; +set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, + gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs) { gdbarch->frame_init_saved_regs = frame_init_saved_regs; } @@ -2125,7 +2069,7 @@ void gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame) { if (gdbarch->init_extra_frame_info == 0) - fatal ("gdbarch: gdbarch_init_extra_frame_info invalid"); + internal_error ("gdbarch: gdbarch_init_extra_frame_info invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_init_extra_frame_info called\n"); @@ -2133,9 +2077,8 @@ gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct fra } void -set_gdbarch_init_extra_frame_info (gdbarch, init_extra_frame_info) - struct gdbarch *gdbarch; - gdbarch_init_extra_frame_info_ftype init_extra_frame_info; +set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, + gdbarch_init_extra_frame_info_ftype init_extra_frame_info) { gdbarch->init_extra_frame_info = init_extra_frame_info; } @@ -2144,7 +2087,7 @@ CORE_ADDR gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip) { if (gdbarch->skip_prologue == 0) - fatal ("gdbarch: gdbarch_skip_prologue invalid"); + internal_error ("gdbarch: gdbarch_skip_prologue invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n"); @@ -2152,9 +2095,8 @@ gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip) } void -set_gdbarch_skip_prologue (gdbarch, skip_prologue) - struct gdbarch *gdbarch; - gdbarch_skip_prologue_ftype skip_prologue; +set_gdbarch_skip_prologue (struct gdbarch *gdbarch, + gdbarch_skip_prologue_ftype skip_prologue) { gdbarch->skip_prologue = skip_prologue; } @@ -2163,7 +2105,7 @@ int gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs) { if (gdbarch->inner_than == 0) - fatal ("gdbarch: gdbarch_inner_than invalid"); + internal_error ("gdbarch: gdbarch_inner_than invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n"); @@ -2171,9 +2113,8 @@ gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs) } void -set_gdbarch_inner_than (gdbarch, inner_than) - struct gdbarch *gdbarch; - gdbarch_inner_than_ftype inner_than; +set_gdbarch_inner_than (struct gdbarch *gdbarch, + gdbarch_inner_than_ftype inner_than) { gdbarch->inner_than = inner_than; } @@ -2182,7 +2123,7 @@ unsigned char * gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr) { if (gdbarch->breakpoint_from_pc == 0) - fatal ("gdbarch: gdbarch_breakpoint_from_pc invalid"); + internal_error ("gdbarch: gdbarch_breakpoint_from_pc invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n"); @@ -2190,19 +2131,53 @@ gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenp } void -set_gdbarch_breakpoint_from_pc (gdbarch, breakpoint_from_pc) - struct gdbarch *gdbarch; - gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc; +set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, + gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc) { gdbarch->breakpoint_from_pc = breakpoint_from_pc; } +int +gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache) +{ + if (gdbarch->memory_insert_breakpoint == 0) + internal_error ("gdbarch: gdbarch_memory_insert_breakpoint invalid"); + if (gdbarch_debug >= 2) + /* FIXME: gdb_std??? */ + fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n"); + return gdbarch->memory_insert_breakpoint (addr, contents_cache); +} + +void +set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, + gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint) +{ + gdbarch->memory_insert_breakpoint = memory_insert_breakpoint; +} + +int +gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache) +{ + if (gdbarch->memory_remove_breakpoint == 0) + internal_error ("gdbarch: gdbarch_memory_remove_breakpoint invalid"); + if (gdbarch_debug >= 2) + /* FIXME: gdb_std??? */ + fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n"); + return gdbarch->memory_remove_breakpoint (addr, contents_cache); +} + +void +set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, + gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint) +{ + gdbarch->memory_remove_breakpoint = memory_remove_breakpoint; +} + CORE_ADDR -gdbarch_decr_pc_after_break (gdbarch) - struct gdbarch *gdbarch; +gdbarch_decr_pc_after_break (struct gdbarch *gdbarch) { if (gdbarch->decr_pc_after_break == -1) - fatal ("gdbarch: gdbarch_decr_pc_after_break invalid"); + internal_error ("gdbarch: gdbarch_decr_pc_after_break invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n"); @@ -2210,19 +2185,17 @@ gdbarch_decr_pc_after_break (gdbarch) } void -set_gdbarch_decr_pc_after_break (gdbarch, decr_pc_after_break) - struct gdbarch *gdbarch; - CORE_ADDR decr_pc_after_break; +set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch, + CORE_ADDR decr_pc_after_break) { gdbarch->decr_pc_after_break = decr_pc_after_break; } CORE_ADDR -gdbarch_function_start_offset (gdbarch) - struct gdbarch *gdbarch; +gdbarch_function_start_offset (struct gdbarch *gdbarch) { if (gdbarch->function_start_offset == -1) - fatal ("gdbarch: gdbarch_function_start_offset invalid"); + internal_error ("gdbarch: gdbarch_function_start_offset invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_function_start_offset called\n"); @@ -2230,9 +2203,8 @@ gdbarch_function_start_offset (gdbarch) } void -set_gdbarch_function_start_offset (gdbarch, function_start_offset) - struct gdbarch *gdbarch; - CORE_ADDR function_start_offset; +set_gdbarch_function_start_offset (struct gdbarch *gdbarch, + CORE_ADDR function_start_offset) { gdbarch->function_start_offset = function_start_offset; } @@ -2241,7 +2213,7 @@ void gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len) { if (gdbarch->remote_translate_xfer_address == 0) - fatal ("gdbarch: gdbarch_remote_translate_xfer_address invalid"); + internal_error ("gdbarch: gdbarch_remote_translate_xfer_address invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n"); @@ -2249,19 +2221,17 @@ gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_ad } void -set_gdbarch_remote_translate_xfer_address (gdbarch, remote_translate_xfer_address) - struct gdbarch *gdbarch; - gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address; +set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, + gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address) { gdbarch->remote_translate_xfer_address = remote_translate_xfer_address; } CORE_ADDR -gdbarch_frame_args_skip (gdbarch) - struct gdbarch *gdbarch; +gdbarch_frame_args_skip (struct gdbarch *gdbarch) { if (gdbarch->frame_args_skip == -1) - fatal ("gdbarch: gdbarch_frame_args_skip invalid"); + internal_error ("gdbarch: gdbarch_frame_args_skip invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n"); @@ -2269,9 +2239,8 @@ gdbarch_frame_args_skip (gdbarch) } void -set_gdbarch_frame_args_skip (gdbarch, frame_args_skip) - struct gdbarch *gdbarch; - CORE_ADDR frame_args_skip; +set_gdbarch_frame_args_skip (struct gdbarch *gdbarch, + CORE_ADDR frame_args_skip) { gdbarch->frame_args_skip = frame_args_skip; } @@ -2280,7 +2249,7 @@ int gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi) { if (gdbarch->frameless_function_invocation == 0) - fatal ("gdbarch: gdbarch_frameless_function_invocation invalid"); + internal_error ("gdbarch: gdbarch_frameless_function_invocation invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_frameless_function_invocation called\n"); @@ -2288,9 +2257,8 @@ gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_inf } void -set_gdbarch_frameless_function_invocation (gdbarch, frameless_function_invocation) - struct gdbarch *gdbarch; - gdbarch_frameless_function_invocation_ftype frameless_function_invocation; +set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, + gdbarch_frameless_function_invocation_ftype frameless_function_invocation) { gdbarch->frameless_function_invocation = frameless_function_invocation; } @@ -2299,7 +2267,7 @@ CORE_ADDR gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame) { if (gdbarch->frame_chain == 0) - fatal ("gdbarch: gdbarch_frame_chain invalid"); + internal_error ("gdbarch: gdbarch_frame_chain invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain called\n"); @@ -2307,9 +2275,8 @@ gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame) } void -set_gdbarch_frame_chain (gdbarch, frame_chain) - struct gdbarch *gdbarch; - gdbarch_frame_chain_ftype frame_chain; +set_gdbarch_frame_chain (struct gdbarch *gdbarch, + gdbarch_frame_chain_ftype frame_chain) { gdbarch->frame_chain = frame_chain; } @@ -2318,7 +2285,7 @@ int gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe) { if (gdbarch->frame_chain_valid == 0) - fatal ("gdbarch: gdbarch_frame_chain_valid invalid"); + internal_error ("gdbarch: gdbarch_frame_chain_valid invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain_valid called\n"); @@ -2326,9 +2293,8 @@ gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct fram } void -set_gdbarch_frame_chain_valid (gdbarch, frame_chain_valid) - struct gdbarch *gdbarch; - gdbarch_frame_chain_valid_ftype frame_chain_valid; +set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch, + gdbarch_frame_chain_valid_ftype frame_chain_valid) { gdbarch->frame_chain_valid = frame_chain_valid; } @@ -2337,7 +2303,7 @@ CORE_ADDR gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi) { if (gdbarch->frame_saved_pc == 0) - fatal ("gdbarch: gdbarch_frame_saved_pc invalid"); + internal_error ("gdbarch: gdbarch_frame_saved_pc invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_saved_pc called\n"); @@ -2345,9 +2311,8 @@ gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi) } void -set_gdbarch_frame_saved_pc (gdbarch, frame_saved_pc) - struct gdbarch *gdbarch; - gdbarch_frame_saved_pc_ftype frame_saved_pc; +set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch, + gdbarch_frame_saved_pc_ftype frame_saved_pc) { gdbarch->frame_saved_pc = frame_saved_pc; } @@ -2356,7 +2321,7 @@ CORE_ADDR gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi) { if (gdbarch->frame_args_address == 0) - fatal ("gdbarch: gdbarch_frame_args_address invalid"); + internal_error ("gdbarch: gdbarch_frame_args_address invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_address called\n"); @@ -2364,9 +2329,8 @@ gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi) } void -set_gdbarch_frame_args_address (gdbarch, frame_args_address) - struct gdbarch *gdbarch; - gdbarch_frame_args_address_ftype frame_args_address; +set_gdbarch_frame_args_address (struct gdbarch *gdbarch, + gdbarch_frame_args_address_ftype frame_args_address) { gdbarch->frame_args_address = frame_args_address; } @@ -2375,7 +2339,7 @@ CORE_ADDR gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi) { if (gdbarch->frame_locals_address == 0) - fatal ("gdbarch: gdbarch_frame_locals_address invalid"); + internal_error ("gdbarch: gdbarch_frame_locals_address invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_locals_address called\n"); @@ -2383,9 +2347,8 @@ gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi) } void -set_gdbarch_frame_locals_address (gdbarch, frame_locals_address) - struct gdbarch *gdbarch; - gdbarch_frame_locals_address_ftype frame_locals_address; +set_gdbarch_frame_locals_address (struct gdbarch *gdbarch, + gdbarch_frame_locals_address_ftype frame_locals_address) { gdbarch->frame_locals_address = frame_locals_address; } @@ -2394,7 +2357,7 @@ CORE_ADDR gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame) { if (gdbarch->saved_pc_after_call == 0) - fatal ("gdbarch: gdbarch_saved_pc_after_call invalid"); + internal_error ("gdbarch: gdbarch_saved_pc_after_call invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_saved_pc_after_call called\n"); @@ -2402,9 +2365,8 @@ gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame) } void -set_gdbarch_saved_pc_after_call (gdbarch, saved_pc_after_call) - struct gdbarch *gdbarch; - gdbarch_saved_pc_after_call_ftype saved_pc_after_call; +set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, + gdbarch_saved_pc_after_call_ftype saved_pc_after_call) { gdbarch->saved_pc_after_call = saved_pc_after_call; } @@ -2413,7 +2375,7 @@ int gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame) { if (gdbarch->frame_num_args == 0) - fatal ("gdbarch: gdbarch_frame_num_args invalid"); + internal_error ("gdbarch: gdbarch_frame_num_args invalid"); if (gdbarch_debug >= 2) /* FIXME: gdb_std??? */ fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n"); @@ -2421,9 +2383,8 @@ gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame) } void -set_gdbarch_frame_num_args (gdbarch, frame_num_args) - struct gdbarch *gdbarch; - gdbarch_frame_num_args_ftype frame_num_args; +set_gdbarch_frame_num_args (struct gdbarch *gdbarch, + gdbarch_frame_num_args_ftype frame_num_args) { gdbarch->frame_num_args = frame_num_args; } @@ -2456,8 +2417,7 @@ struct gdbarch_data_registrary gdbarch_data_registrary = }; struct gdbarch_data * -register_gdbarch_data (init) - gdbarch_data_ftype *init; +register_gdbarch_data (gdbarch_data_ftype *init) { struct gdbarch_data_registration **curr; for (curr = &gdbarch_data_registrary.registrations; @@ -2474,10 +2434,8 @@ register_gdbarch_data (init) /* Walk through all the registered users initializing each in turn. */ -static void init_gdbarch_data PARAMS ((struct gdbarch *)); static void -init_gdbarch_data (gdbarch) - struct gdbarch *gdbarch; +init_gdbarch_data (struct gdbarch *gdbarch) { struct gdbarch_data_registration *rego; gdbarch->nr_data = gdbarch_data_registrary.nr + 1; @@ -2500,7 +2458,7 @@ gdbarch_data (data) struct gdbarch_data *data; { if (data->index >= current_gdbarch->nr_data) - fatal ("gdbarch_data: request for non-existant data."); + internal_error ("gdbarch_data: request for non-existant data."); return current_gdbarch->data[data->index]; } @@ -2535,10 +2493,9 @@ struct gdbarch_swap_registrary gdbarch_swap_registrary = }; void -register_gdbarch_swap (data, sizeof_data, init) - void *data; - unsigned long sizeof_data; - gdbarch_swap_ftype *init; +register_gdbarch_swap (void *data, + unsigned long sizeof_data, + gdbarch_swap_ftype *init) { struct gdbarch_swap_registration **rego; for (rego = &gdbarch_swap_registrary.registrations; @@ -2552,10 +2509,8 @@ register_gdbarch_swap (data, sizeof_data, init) } -static void init_gdbarch_swap PARAMS ((struct gdbarch *)); static void -init_gdbarch_swap (gdbarch) - struct gdbarch *gdbarch; +init_gdbarch_swap (struct gdbarch *gdbarch) { struct gdbarch_swap_registration *rego; struct gdbarch_swap **curr = &gdbarch->swap; @@ -2577,10 +2532,8 @@ init_gdbarch_swap (gdbarch) } } -static void swapout_gdbarch_swap PARAMS ((struct gdbarch *)); static void -swapout_gdbarch_swap (gdbarch) - struct gdbarch *gdbarch; +swapout_gdbarch_swap (struct gdbarch *gdbarch) { struct gdbarch_swap *curr; for (curr = gdbarch->swap; @@ -2589,10 +2542,8 @@ swapout_gdbarch_swap (gdbarch) memcpy (curr->swap, curr->source->data, curr->source->sizeof_data); } -static void swapin_gdbarch_swap PARAMS ((struct gdbarch *)); static void -swapin_gdbarch_swap (gdbarch) - struct gdbarch *gdbarch; +swapin_gdbarch_swap (struct gdbarch *gdbarch) { struct gdbarch_swap *curr; for (curr = gdbarch->swap; @@ -2615,9 +2566,8 @@ struct gdbarch_init_registration static struct gdbarch_init_registration *gdbarch_init_registrary = NULL; void -register_gdbarch_init (bfd_architecture, init) - enum bfd_architecture bfd_architecture; - gdbarch_init_ftype *init; +register_gdbarch_init (enum bfd_architecture bfd_architecture, + gdbarch_init_ftype *init) { struct gdbarch_init_registration **curr; const struct bfd_arch_info *bfd_arch_info; @@ -2625,7 +2575,7 @@ register_gdbarch_init (bfd_architecture, init) bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0); if (bfd_arch_info == NULL) { - fatal ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture); + internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture); } /* Check that we haven't seen this architecture before */ for (curr = &gdbarch_init_registrary; @@ -2633,7 +2583,7 @@ register_gdbarch_init (bfd_architecture, init) curr = &(*curr)->next) { if (bfd_architecture == (*curr)->bfd_architecture) - fatal ("gdbarch: Duplicate registraration of architecture (%s)", + internal_error ("gdbarch: Duplicate registraration of architecture (%s)", bfd_arch_info->printable_name); } /* log it */ @@ -2655,9 +2605,8 @@ register_gdbarch_init (bfd_architecture, init) BFD_ARCH_INFO and BYTE_ORDER. */ struct gdbarch_list * -gdbarch_list_lookup_by_info (arches, info) - struct gdbarch_list *arches; - const struct gdbarch_info *info; +gdbarch_list_lookup_by_info (struct gdbarch_list *arches, + const struct gdbarch_info *info) { for (; arches != NULL; arches = arches->next) { @@ -2675,8 +2624,7 @@ gdbarch_list_lookup_by_info (arches, info) failed. */ int -gdbarch_update (info) - struct gdbarch_info info; +gdbarch_update (struct gdbarch_info info) { struct gdbarch *new_gdbarch; struct gdbarch_list **list; @@ -2853,11 +2801,8 @@ int target_byte_order_auto = 1; static struct cmd_list_element *endianlist = NULL; /* Called by ``show endian''. */ -static void show_endian PARAMS ((char *, int)); static void -show_endian (args, from_tty) - char *args; - int from_tty; +show_endian (char *args, int from_tty) { char *msg = (TARGET_BYTE_ORDER_AUTO @@ -2867,22 +2812,16 @@ show_endian (args, from_tty) } /* Called if the user enters ``set endian'' without an argument. */ -static void set_endian PARAMS ((char *, int)); static void -set_endian (args, from_tty) - char *args; - int from_tty; +set_endian (char *args, int from_tty) { printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n"); show_endian (args, from_tty); } /* Called by ``set endian big''. */ -static void set_endian_big PARAMS ((char *, int)); static void -set_endian_big (args, from_tty) - char *args; - int from_tty; +set_endian_big (char *args, int from_tty) { if (TARGET_BYTE_ORDER_SELECTABLE_P) { @@ -2904,11 +2843,8 @@ set_endian_big (args, from_tty) } /* Called by ``set endian little''. */ -static void set_endian_little PARAMS ((char *, int)); static void -set_endian_little (args, from_tty) - char *args; - int from_tty; +set_endian_little (char *args, int from_tty) { if (TARGET_BYTE_ORDER_SELECTABLE_P) { @@ -2930,11 +2866,8 @@ set_endian_little (args, from_tty) } /* Called by ``set endian auto''. */ -static void set_endian_auto PARAMS ((char *, int)); static void -set_endian_auto (args, from_tty) - char *args; - int from_tty; +set_endian_auto (char *args, int from_tty) { if (TARGET_BYTE_ORDER_SELECTABLE_P) { @@ -2948,10 +2881,8 @@ set_endian_auto (args, from_tty) } /* Set the endianness from a BFD. */ -static void set_endian_from_file PARAMS ((bfd *)); static void -set_endian_from_file (abfd) - bfd *abfd; +set_endian_from_file (bfd *abfd) { if (TARGET_BYTE_ORDER_SELECTABLE_P) { @@ -2983,17 +2914,30 @@ set_endian_from_file (abfd) /* Functions to manipulate the architecture of the target */ +enum set_arch { set_arch_auto, set_arch_manual }; + int target_architecture_auto = 1; extern const struct bfd_arch_info bfd_default_arch_struct; const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct; -int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info *ap)); +int (*target_architecture_hook) (const struct bfd_arch_info *ap); + +static void show_endian (char *, int); +static void set_endian (char *, int); +static void set_endian_big (char *, int); +static void set_endian_little (char *, int); +static void set_endian_auto (char *, int); +static void set_endian_from_file (bfd *); +static int arch_ok (const struct bfd_arch_info *arch); +static void set_arch (const struct bfd_arch_info *arch, enum set_arch type); +static void show_architecture (char *, int); +static void set_architecture (char *, int); +static void info_architecture (char *, int); +static void set_architecture_from_file (bfd *); /* Do the real work of changing the current architecture */ -static int arch_ok PARAMS ((const struct bfd_arch_info *arch)); static int -arch_ok (arch) - const struct bfd_arch_info *arch; +arch_ok (const struct bfd_arch_info *arch) { /* Should be performing the more basic check that the binary is compatible with GDB. */ @@ -3002,13 +2946,9 @@ arch_ok (arch) || target_architecture_hook (arch)); } -enum set_arch { set_arch_auto, set_arch_manual }; - -static void set_arch PARAMS ((const struct bfd_arch_info *arch, enum set_arch type)); static void -set_arch (arch, type) - const struct bfd_arch_info *arch; - enum set_arch type; +set_arch (const struct bfd_arch_info *arch, + enum set_arch type) { switch (type) { @@ -3036,11 +2976,8 @@ set_arch (arch, type) } /* Called if the user enters ``show architecture'' without an argument. */ -static void show_architecture PARAMS ((char *, int)); static void -show_architecture (args, from_tty) - char *args; - int from_tty; +show_architecture (char *args, int from_tty) { const char *arch; arch = TARGET_ARCHITECTURE->printable_name; @@ -3052,11 +2989,8 @@ show_architecture (args, from_tty) /* Called if the user enters ``set architecture'' with or without an argument. */ -static void set_architecture PARAMS ((char *, int)); static void -set_architecture (args, from_tty) - char *args; - int from_tty; +set_architecture (char *args, int from_tty) { if (args == NULL) { @@ -3093,11 +3027,8 @@ set_architecture (args, from_tty) } /* Called if the user enters ``info architecture'' without an argument. */ -static void info_architecture PARAMS ((char *, int)); static void -info_architecture (args, from_tty) - char *args; - int from_tty; +info_architecture (char *args, int from_tty) { enum bfd_architecture a; if (GDB_MULTI_ARCH) @@ -3157,14 +3088,12 @@ set_architecture_from_arch_mach (arch, mach) if (wanted != NULL) set_arch (wanted, set_arch_manual); else - fatal ("gdbarch: hardwired architecture/machine not reconized"); + internal_error ("gdbarch: hardwired architecture/machine not reconized"); } /* Set the architecture from a BFD */ -static void set_architecture_from_file PARAMS ((bfd *)); static void -set_architecture_from_file (abfd) - bfd *abfd; +set_architecture_from_file (bfd *abfd) { const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd); if (target_architecture_auto) @@ -3200,7 +3129,7 @@ generic_register_convertible_not (num) /* Disassembler */ /* Pointer to the target-dependent disassembly function. */ -int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info *)); +int (*tm_print_insn) (bfd_vma, disassemble_info *); disassemble_info tm_print_insn_info; @@ -3232,7 +3161,7 @@ int sizeof_call_dummy_words = sizeof (call_dummy_words); #endif -extern void _initialize_gdbarch PARAMS ((void)); +extern void _initialize_gdbarch (void); void _initialize_gdbarch () {