X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbarch.c;h=98afadea8e33741f19286b44d292e6b52ffe4fb0;hb=ff2e87acc74e44ce5d35a80961469fc9fbd30b46;hp=2622a806ce32ccb0a5e472d970b84c875df4880a;hpb=76860b5fb39d8868e8e77d1073f41a1f6fbb3aaf;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c index 2622a806ce..98afadea8e 100644 --- a/gdb/gdbarch.c +++ b/gdb/gdbarch.c @@ -1,7 +1,7 @@ /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */ /* Dynamic architecture support for GDB, the GNU debugger. - Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. + Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. This file is part of GDB. @@ -62,7 +62,11 @@ #include "floatformat.h" #include "gdb_assert.h" +#include "gdb_string.h" #include "gdb-events.h" +#include "reggroups.h" +#include "osabi.h" +#include "symfile.h" /* For entry_point_address. */ /* Static function declarations */ @@ -91,6 +95,7 @@ struct gdbarch /* basic architectural information */ const struct bfd_arch_info * bfd_arch_info; int byte_order; + enum gdb_osabi osabi; /* target specific vector. */ struct gdbarch_tdep *tdep; @@ -142,16 +147,13 @@ struct gdbarch int char_signed; gdbarch_read_pc_ftype *read_pc; gdbarch_write_pc_ftype *write_pc; - gdbarch_read_fp_ftype *read_fp; gdbarch_read_sp_ftype *read_sp; - gdbarch_write_sp_ftype *write_sp; gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer; - gdbarch_register_read_ftype *register_read; - gdbarch_register_write_ftype *register_write; + gdbarch_pseudo_register_read_ftype *pseudo_register_read; + gdbarch_pseudo_register_write_ftype *pseudo_register_write; int num_regs; int num_pseudo_regs; int sp_regnum; - int fp_regnum; int pc_regnum; int ps_regnum; int fp0_regnum; @@ -162,64 +164,72 @@ struct gdbarch gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum; gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum; gdbarch_register_name_ftype *register_name; - int register_size; - int register_bytes; - gdbarch_register_byte_ftype *register_byte; - gdbarch_register_raw_size_ftype *register_raw_size; - int max_register_raw_size; - gdbarch_register_virtual_size_ftype *register_virtual_size; - int max_register_virtual_size; - gdbarch_register_virtual_type_ftype *register_virtual_type; - gdbarch_do_registers_info_ftype *do_registers_info; + gdbarch_register_type_ftype *register_type; + gdbarch_deprecated_register_virtual_type_ftype *deprecated_register_virtual_type; + int deprecated_register_bytes; + gdbarch_deprecated_register_byte_ftype *deprecated_register_byte; + gdbarch_deprecated_register_raw_size_ftype *deprecated_register_raw_size; + gdbarch_deprecated_register_virtual_size_ftype *deprecated_register_virtual_size; + int deprecated_max_register_raw_size; + int deprecated_max_register_virtual_size; + gdbarch_unwind_dummy_id_ftype *unwind_dummy_id; + gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos; + int deprecated_fp_regnum; + gdbarch_deprecated_target_read_fp_ftype *deprecated_target_read_fp; + gdbarch_push_dummy_call_ftype *push_dummy_call; + gdbarch_deprecated_push_arguments_ftype *deprecated_push_arguments; + int deprecated_use_generic_dummy_frames; + gdbarch_deprecated_push_return_address_ftype *deprecated_push_return_address; + gdbarch_deprecated_dummy_write_sp_ftype *deprecated_dummy_write_sp; + int deprecated_register_size; + int call_dummy_location; + gdbarch_call_dummy_address_ftype *call_dummy_address; + CORE_ADDR deprecated_call_dummy_start_offset; + CORE_ADDR deprecated_call_dummy_breakpoint_offset; + int deprecated_call_dummy_length; + LONGEST * deprecated_call_dummy_words; + int deprecated_sizeof_call_dummy_words; + int deprecated_call_dummy_stack_adjust; + gdbarch_deprecated_fix_call_dummy_ftype *deprecated_fix_call_dummy; + gdbarch_push_dummy_code_ftype *push_dummy_code; + gdbarch_deprecated_push_dummy_frame_ftype *deprecated_push_dummy_frame; + int deprecated_extra_stack_alignment_needed; + gdbarch_deprecated_do_registers_info_ftype *deprecated_do_registers_info; + gdbarch_print_registers_info_ftype *print_registers_info; gdbarch_print_float_info_ftype *print_float_info; + gdbarch_print_vector_info_ftype *print_vector_info; gdbarch_register_sim_regno_ftype *register_sim_regno; gdbarch_register_bytes_ok_ftype *register_bytes_ok; gdbarch_cannot_fetch_register_ftype *cannot_fetch_register; gdbarch_cannot_store_register_ftype *cannot_store_register; gdbarch_get_longjmp_target_ftype *get_longjmp_target; - int use_generic_dummy_frames; - int call_dummy_location; - gdbarch_call_dummy_address_ftype *call_dummy_address; - CORE_ADDR call_dummy_start_offset; - CORE_ADDR call_dummy_breakpoint_offset; - int call_dummy_breakpoint_offset_p; - int call_dummy_length; - gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy; - int call_dummy_p; - LONGEST * call_dummy_words; - int sizeof_call_dummy_words; - int call_dummy_stack_adjust_p; - int call_dummy_stack_adjust; - gdbarch_fix_call_dummy_ftype *fix_call_dummy; - gdbarch_init_frame_pc_first_ftype *init_frame_pc_first; - gdbarch_init_frame_pc_ftype *init_frame_pc; + gdbarch_deprecated_pc_in_call_dummy_ftype *deprecated_pc_in_call_dummy; + gdbarch_deprecated_init_frame_pc_first_ftype *deprecated_init_frame_pc_first; + gdbarch_deprecated_init_frame_pc_ftype *deprecated_init_frame_pc; int believe_pcc_promotion; int believe_pcc_promotion_type; - gdbarch_coerce_float_to_double_ftype *coerce_float_to_double; - gdbarch_get_saved_register_ftype *get_saved_register; - gdbarch_register_convertible_ftype *register_convertible; - gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual; - gdbarch_register_convert_to_raw_ftype *register_convert_to_raw; + gdbarch_deprecated_get_saved_register_ftype *deprecated_get_saved_register; + gdbarch_deprecated_register_convertible_ftype *deprecated_register_convertible; + gdbarch_deprecated_register_convert_to_virtual_ftype *deprecated_register_convert_to_virtual; + gdbarch_deprecated_register_convert_to_raw_ftype *deprecated_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; gdbarch_address_to_pointer_ftype *address_to_pointer; gdbarch_integer_to_address_ftype *integer_to_address; gdbarch_return_value_on_stack_ftype *return_value_on_stack; + gdbarch_deprecated_pop_frame_ftype *deprecated_pop_frame; + gdbarch_deprecated_store_struct_return_ftype *deprecated_store_struct_return; gdbarch_extract_return_value_ftype *extract_return_value; - gdbarch_push_arguments_ftype *push_arguments; - gdbarch_push_dummy_frame_ftype *push_dummy_frame; - gdbarch_push_return_address_ftype *push_return_address; - gdbarch_pop_frame_ftype *pop_frame; - gdbarch_store_struct_return_ftype *store_struct_return; gdbarch_store_return_value_ftype *store_return_value; + gdbarch_deprecated_extract_return_value_ftype *deprecated_extract_return_value; + gdbarch_deprecated_store_return_value_ftype *deprecated_store_return_value; gdbarch_extract_struct_value_address_ftype *extract_struct_value_address; + gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address; gdbarch_use_struct_convention_ftype *use_struct_convention; - gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs; - gdbarch_init_extra_frame_info_ftype *init_extra_frame_info; + gdbarch_deprecated_frame_init_saved_regs_ftype *deprecated_frame_init_saved_regs; + gdbarch_deprecated_init_extra_frame_info_ftype *deprecated_init_extra_frame_info; gdbarch_skip_prologue_ftype *skip_prologue; gdbarch_prologue_frameless_p_ftype *prologue_frameless_p; gdbarch_inner_than_ftype *inner_than; @@ -232,17 +242,18 @@ struct gdbarch gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address; CORE_ADDR frame_args_skip; gdbarch_frameless_function_invocation_ftype *frameless_function_invocation; - gdbarch_frame_chain_ftype *frame_chain; - gdbarch_frame_chain_valid_ftype *frame_chain_valid; - gdbarch_frame_saved_pc_ftype *frame_saved_pc; + gdbarch_deprecated_frame_chain_ftype *deprecated_frame_chain; + gdbarch_deprecated_frame_chain_valid_ftype *deprecated_frame_chain_valid; + gdbarch_deprecated_frame_saved_pc_ftype *deprecated_frame_saved_pc; + gdbarch_unwind_pc_ftype *unwind_pc; + gdbarch_unwind_sp_ftype *unwind_sp; gdbarch_frame_args_address_ftype *frame_args_address; gdbarch_frame_locals_address_ftype *frame_locals_address; - gdbarch_saved_pc_after_call_ftype *saved_pc_after_call; + gdbarch_deprecated_saved_pc_after_call_ftype *deprecated_saved_pc_after_call; gdbarch_frame_num_args_ftype *frame_num_args; gdbarch_stack_align_ftype *stack_align; - int extra_stack_alignment_needed; + gdbarch_frame_align_ftype *frame_align; gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr; - gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos; int parm_boundary; const struct floatformat * float_format; const struct floatformat * double_format; @@ -254,12 +265,23 @@ 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_in_solib_return_trampoline_ftype *in_solib_return_trampoline; gdbarch_pc_in_sigtramp_ftype *pc_in_sigtramp; + gdbarch_sigtramp_start_ftype *sigtramp_start; + gdbarch_sigtramp_end_ftype *sigtramp_end; gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p; gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments; gdbarch_dwarf2_build_frame_info_ftype *dwarf2_build_frame_info; gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special; gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special; + const char * name_of_malloc; + int cannot_step_breakpoint; + int have_nonsteppable_watchpoint; + gdbarch_address_class_type_flags_ftype *address_class_type_flags; + gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name; + gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags; + gdbarch_register_reggroup_p_ftype *register_reggroup_p; + gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument; }; @@ -272,144 +294,162 @@ struct gdbarch startup_gdbarch = { 1, /* Always initialized. */ /* basic architecture information */ - &bfd_default_arch_struct, - BFD_ENDIAN_BIG, + &bfd_default_arch_struct, /* bfd_arch_info */ + BFD_ENDIAN_BIG, /* byte_order */ + GDB_OSABI_UNKNOWN, /* osabi */ /* target specific vector and its dump routine */ NULL, NULL, /*per-architecture data-pointers and swap regions */ 0, NULL, NULL, /* Multi-arch values */ - 8 * sizeof (short), - 8 * sizeof (int), - 8 * sizeof (long), - 8 * sizeof (LONGEST), - 8 * sizeof (float), - 8 * sizeof (double), - 8 * sizeof (long double), - 8 * sizeof (void*), - 8 * sizeof (void*), - 8 * sizeof (void*), - 1, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - -1, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - generic_register_size, - 0, - generic_register_size, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - generic_get_saved_register, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - generic_in_function_epilogue_p, - construct_inferior_arguments, - 0, - 0, - 0, + 8 * sizeof (short), /* short_bit */ + 8 * sizeof (int), /* int_bit */ + 8 * sizeof (long), /* long_bit */ + 8 * sizeof (LONGEST), /* long_long_bit */ + 8 * sizeof (float), /* float_bit */ + 8 * sizeof (double), /* double_bit */ + 8 * sizeof (long double), /* long_double_bit */ + 8 * sizeof (void*), /* ptr_bit */ + 8 * sizeof (void*), /* addr_bit */ + 8 * sizeof (void*), /* bfd_vma_bit */ + 1, /* char_signed */ + 0, /* read_pc */ + 0, /* write_pc */ + 0, /* read_sp */ + 0, /* virtual_frame_pointer */ + 0, /* pseudo_register_read */ + 0, /* pseudo_register_write */ + 0, /* num_regs */ + 0, /* num_pseudo_regs */ + -1, /* sp_regnum */ + -1, /* pc_regnum */ + -1, /* ps_regnum */ + 0, /* fp0_regnum */ + 0, /* npc_regnum */ + 0, /* stab_reg_to_regnum */ + 0, /* ecoff_reg_to_regnum */ + 0, /* dwarf_reg_to_regnum */ + 0, /* sdb_reg_to_regnum */ + 0, /* dwarf2_reg_to_regnum */ + 0, /* register_name */ + 0, /* register_type */ + 0, /* deprecated_register_virtual_type */ + 0, /* deprecated_register_bytes */ + generic_register_byte, /* deprecated_register_byte */ + generic_register_size, /* deprecated_register_raw_size */ + generic_register_size, /* deprecated_register_virtual_size */ + 0, /* deprecated_max_register_raw_size */ + 0, /* deprecated_max_register_virtual_size */ + 0, /* unwind_dummy_id */ + 0, /* save_dummy_frame_tos */ + -1, /* deprecated_fp_regnum */ + 0, /* deprecated_target_read_fp */ + 0, /* push_dummy_call */ + 0, /* deprecated_push_arguments */ + 0, /* deprecated_use_generic_dummy_frames */ + 0, /* deprecated_push_return_address */ + 0, /* deprecated_dummy_write_sp */ + 0, /* deprecated_register_size */ + 0, /* call_dummy_location */ + 0, /* call_dummy_address */ + 0, /* deprecated_call_dummy_start_offset */ + 0, /* deprecated_call_dummy_breakpoint_offset */ + 0, /* deprecated_call_dummy_length */ + 0, /* deprecated_call_dummy_words */ + 0, /* deprecated_sizeof_call_dummy_words */ + 0, /* deprecated_call_dummy_stack_adjust */ + 0, /* deprecated_fix_call_dummy */ + 0, /* push_dummy_code */ + 0, /* deprecated_push_dummy_frame */ + 0, /* deprecated_extra_stack_alignment_needed */ + 0, /* deprecated_do_registers_info */ + default_print_registers_info, /* print_registers_info */ + 0, /* print_float_info */ + 0, /* print_vector_info */ + 0, /* register_sim_regno */ + 0, /* register_bytes_ok */ + 0, /* cannot_fetch_register */ + 0, /* cannot_store_register */ + 0, /* get_longjmp_target */ + generic_pc_in_call_dummy, /* deprecated_pc_in_call_dummy */ + 0, /* deprecated_init_frame_pc_first */ + 0, /* deprecated_init_frame_pc */ + 0, /* believe_pcc_promotion */ + 0, /* believe_pcc_promotion_type */ + 0, /* deprecated_get_saved_register */ + 0, /* deprecated_register_convertible */ + 0, /* deprecated_register_convert_to_virtual */ + 0, /* deprecated_register_convert_to_raw */ + 0, /* convert_register_p */ + 0, /* register_to_value */ + 0, /* value_to_register */ + 0, /* pointer_to_address */ + 0, /* address_to_pointer */ + 0, /* integer_to_address */ + 0, /* return_value_on_stack */ + 0, /* deprecated_pop_frame */ + 0, /* deprecated_store_struct_return */ + 0, /* extract_return_value */ + 0, /* store_return_value */ + 0, /* deprecated_extract_return_value */ + 0, /* deprecated_store_return_value */ + 0, /* extract_struct_value_address */ + 0, /* deprecated_extract_struct_value_address */ + 0, /* use_struct_convention */ + 0, /* deprecated_frame_init_saved_regs */ + 0, /* deprecated_init_extra_frame_info */ + 0, /* skip_prologue */ + 0, /* prologue_frameless_p */ + 0, /* inner_than */ + 0, /* breakpoint_from_pc */ + 0, /* memory_insert_breakpoint */ + 0, /* memory_remove_breakpoint */ + 0, /* decr_pc_after_break */ + 0, /* prepare_to_proceed */ + 0, /* function_start_offset */ + generic_remote_translate_xfer_address, /* remote_translate_xfer_address */ + 0, /* frame_args_skip */ + 0, /* frameless_function_invocation */ + 0, /* deprecated_frame_chain */ + 0, /* deprecated_frame_chain_valid */ + 0, /* deprecated_frame_saved_pc */ + 0, /* unwind_pc */ + 0, /* unwind_sp */ + 0, /* frame_args_address */ + 0, /* frame_locals_address */ + 0, /* deprecated_saved_pc_after_call */ + 0, /* frame_num_args */ + 0, /* stack_align */ + 0, /* frame_align */ + 0, /* reg_struct_has_addr */ + 0, /* parm_boundary */ + 0, /* float_format */ + 0, /* double_format */ + 0, /* long_double_format */ + 0, /* convert_from_func_ptr_addr */ + 0, /* addr_bits_remove */ + 0, /* smash_text_address */ + 0, /* software_single_step */ + 0, /* print_insn */ + 0, /* skip_trampoline_code */ + 0, /* in_solib_call_trampoline */ + 0, /* in_solib_return_trampoline */ + 0, /* pc_in_sigtramp */ + 0, /* sigtramp_start */ + 0, /* sigtramp_end */ + generic_in_function_epilogue_p, /* in_function_epilogue_p */ + construct_inferior_arguments, /* construct_inferior_arguments */ + 0, /* dwarf2_build_frame_info */ + 0, /* elf_make_msymbol_special */ + 0, /* coff_make_msymbol_special */ + "malloc", /* name_of_malloc */ + 0, /* cannot_step_breakpoint */ + 0, /* have_nonsteppable_watchpoint */ + 0, /* address_class_type_flags */ + 0, /* address_class_type_flags_to_name */ + 0, /* address_class_name_to_type_flags */ + default_register_reggroup_p, /* register_reggroup_p */ + 0, /* fetch_pointer_argument */ /* startup_gdbarch() */ }; @@ -418,7 +458,7 @@ struct gdbarch *current_gdbarch = &startup_gdbarch; /* Do any initialization needed for a non-multiarch configuration after the _initialize_MODULE functions have been run. */ void -initialize_non_multiarch () +initialize_non_multiarch (void) { alloc_gdbarch_data (&startup_gdbarch); /* Ensure that all swap areas are zeroed so that they again think @@ -450,6 +490,7 @@ gdbarch_alloc (const struct gdbarch_info *info, current_gdbarch->bfd_arch_info = info->bfd_arch_info; current_gdbarch->byte_order = info->byte_order; + current_gdbarch->osabi = info->osabi; /* Force the explicit initialization of these. */ current_gdbarch->short_bit = 2*TARGET_CHAR_BIT; @@ -462,15 +503,10 @@ gdbarch_alloc (const struct gdbarch_info *info, current_gdbarch->ptr_bit = TARGET_INT_BIT; current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address; current_gdbarch->char_signed = -1; - current_gdbarch->read_pc = generic_target_read_pc; current_gdbarch->write_pc = generic_target_write_pc; - current_gdbarch->read_fp = generic_target_read_fp; - current_gdbarch->read_sp = generic_target_read_sp; - current_gdbarch->write_sp = generic_target_write_sp; current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer; current_gdbarch->num_regs = -1; current_gdbarch->sp_regnum = -1; - current_gdbarch->fp_regnum = -1; current_gdbarch->pc_regnum = -1; current_gdbarch->ps_regnum = -1; current_gdbarch->fp0_regnum = -1; @@ -481,40 +517,31 @@ gdbarch_alloc (const struct gdbarch_info *info, current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum; current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum; current_gdbarch->register_name = legacy_register_name; - current_gdbarch->register_size = -1; - current_gdbarch->register_bytes = -1; - current_gdbarch->register_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; + current_gdbarch->deprecated_register_byte = generic_register_byte; + current_gdbarch->deprecated_register_raw_size = generic_register_size; + current_gdbarch->deprecated_register_virtual_size = generic_register_size; + current_gdbarch->deprecated_fp_regnum = -1; + current_gdbarch->deprecated_use_generic_dummy_frames = 1; + current_gdbarch->call_dummy_location = AT_ENTRY_POINT; + current_gdbarch->call_dummy_address = entry_point_address; + current_gdbarch->deprecated_call_dummy_words = legacy_call_dummy_words; + current_gdbarch->deprecated_sizeof_call_dummy_words = legacy_sizeof_call_dummy_words; + current_gdbarch->print_registers_info = default_print_registers_info; current_gdbarch->register_sim_regno = legacy_register_sim_regno; current_gdbarch->cannot_fetch_register = cannot_register_not; current_gdbarch->cannot_store_register = cannot_register_not; - current_gdbarch->use_generic_dummy_frames = -1; - current_gdbarch->call_dummy_start_offset = -1; - current_gdbarch->call_dummy_breakpoint_offset = -1; - current_gdbarch->call_dummy_breakpoint_offset_p = -1; - current_gdbarch->call_dummy_length = -1; - current_gdbarch->call_dummy_p = -1; - current_gdbarch->call_dummy_words = legacy_call_dummy_words; - current_gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words; - current_gdbarch->call_dummy_stack_adjust_p = -1; - current_gdbarch->init_frame_pc_first = init_frame_pc_noop; - current_gdbarch->init_frame_pc = init_frame_pc_default; - current_gdbarch->coerce_float_to_double = default_coerce_float_to_double; - current_gdbarch->register_convertible = generic_register_convertible_not; + current_gdbarch->deprecated_pc_in_call_dummy = generic_pc_in_call_dummy; + current_gdbarch->deprecated_register_convertible = deprecated_register_convertible_not; current_gdbarch->convert_register_p = legacy_convert_register_p; current_gdbarch->register_to_value = legacy_register_to_value; current_gdbarch->value_to_register = legacy_value_to_register; current_gdbarch->pointer_to_address = unsigned_pointer_to_address; current_gdbarch->address_to_pointer = unsigned_address_to_pointer; current_gdbarch->return_value_on_stack = generic_return_value_on_stack_not; - current_gdbarch->push_arguments = default_push_arguments; + current_gdbarch->extract_return_value = legacy_extract_return_value; + current_gdbarch->store_return_value = legacy_store_return_value; current_gdbarch->use_struct_convention = generic_use_struct_convention; current_gdbarch->prologue_frameless_p = generic_prologue_frameless_p; - current_gdbarch->breakpoint_from_pc = legacy_breakpoint_from_pc; current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint; current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint; current_gdbarch->decr_pc_after_break = -1; @@ -523,19 +550,22 @@ 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->frame_args_address = get_frame_base; + current_gdbarch->frame_locals_address = get_frame_base; current_gdbarch->convert_from_func_ptr_addr = core_addr_identity; current_gdbarch->addr_bits_remove = core_addr_identity; current_gdbarch->smash_text_address = core_addr_identity; current_gdbarch->print_insn = legacy_print_insn; current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code; current_gdbarch->in_solib_call_trampoline = generic_in_solib_call_trampoline; + current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline; current_gdbarch->pc_in_sigtramp = legacy_pc_in_sigtramp; current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p; current_gdbarch->construct_inferior_arguments = construct_inferior_arguments; current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special; current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special; + current_gdbarch->name_of_malloc = "malloc"; + current_gdbarch->register_reggroup_p = default_register_reggroup_p; /* gdbarch_alloc() */ return current_gdbarch; @@ -590,20 +620,17 @@ verify_gdbarch (struct gdbarch *gdbarch) /* Skip verify of bfd_vma_bit, invalid_p == 0 */ if (gdbarch->char_signed == -1) gdbarch->char_signed = 1; - /* Skip verify of read_pc, invalid_p == 0 */ + /* Skip verify of read_pc, has predicate */ /* Skip verify of write_pc, invalid_p == 0 */ - /* Skip verify of read_fp, invalid_p == 0 */ - /* Skip verify of read_sp, invalid_p == 0 */ - /* Skip verify of write_sp, invalid_p == 0 */ + /* Skip verify of read_sp, has predicate */ /* Skip verify of virtual_frame_pointer, invalid_p == 0 */ - /* Skip verify of register_read, has predicate */ - /* Skip verify of register_write, has predicate */ + /* Skip verify of pseudo_register_read, has predicate */ + /* Skip verify of pseudo_register_write, has predicate */ if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && (gdbarch->num_regs == -1)) fprintf_unfiltered (log, "\n\tnum_regs"); /* Skip verify of num_pseudo_regs, invalid_p == 0 */ /* Skip verify of sp_regnum, invalid_p == 0 */ - /* Skip verify of fp_regnum, invalid_p == 0 */ /* Skip verify of pc_regnum, invalid_p == 0 */ /* Skip verify of ps_regnum, invalid_p == 0 */ /* Skip verify of fp0_regnum, invalid_p == 0 */ @@ -614,112 +641,63 @@ verify_gdbarch (struct gdbarch *gdbarch) /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */ /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */ /* Skip verify of register_name, invalid_p == 0 */ - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->register_size == -1)) - fprintf_unfiltered (log, "\n\tregister_size"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->register_bytes == -1)) - fprintf_unfiltered (log, "\n\tregister_bytes"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->register_byte == 0)) - fprintf_unfiltered (log, "\n\tregister_byte"); - /* Skip verify of register_raw_size, invalid_p == 0 */ - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->max_register_raw_size == -1)) - fprintf_unfiltered (log, "\n\tmax_register_raw_size"); - /* Skip verify of register_virtual_size, invalid_p == 0 */ - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->max_register_virtual_size == -1)) - fprintf_unfiltered (log, "\n\tmax_register_virtual_size"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->register_virtual_type == 0)) - fprintf_unfiltered (log, "\n\tregister_virtual_type"); - /* Skip verify of do_registers_info, invalid_p == 0 */ - /* Skip verify of print_float_info, invalid_p == 0 */ + /* Skip verify of register_type, has predicate */ + /* Skip verify of deprecated_register_virtual_type, has predicate */ + /* Skip verify of deprecated_register_byte, has predicate */ + /* Skip verify of deprecated_register_raw_size, invalid_p == 0 */ + /* Skip verify of deprecated_register_virtual_size, invalid_p == 0 */ + /* Skip verify of deprecated_max_register_raw_size, has predicate */ + /* Skip verify of deprecated_max_register_virtual_size, has predicate */ + /* Skip verify of unwind_dummy_id, has predicate */ + /* Skip verify of save_dummy_frame_tos, has predicate */ + /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */ + /* Skip verify of deprecated_target_read_fp, has predicate */ + /* Skip verify of push_dummy_call, has predicate */ + /* Skip verify of deprecated_push_arguments, has predicate */ + /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */ + /* Skip verify of deprecated_push_return_address, has predicate */ + /* Skip verify of deprecated_dummy_write_sp, has predicate */ + /* Skip verify of call_dummy_location, invalid_p == 0 */ + /* Skip verify of call_dummy_address, invalid_p == 0 */ + /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */ + /* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */ + /* Skip verify of deprecated_call_dummy_stack_adjust, has predicate */ + /* Skip verify of deprecated_fix_call_dummy, has predicate */ + /* Skip verify of push_dummy_code, has predicate */ + /* Skip verify of deprecated_push_dummy_frame, has predicate */ + /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */ + /* Skip verify of deprecated_do_registers_info, has predicate */ + /* Skip verify of print_registers_info, invalid_p == 0 */ + /* Skip verify of print_float_info, has predicate */ + /* Skip verify of print_vector_info, has predicate */ /* Skip verify of register_sim_regno, invalid_p == 0 */ /* Skip verify of register_bytes_ok, has predicate */ /* Skip verify of cannot_fetch_register, invalid_p == 0 */ /* Skip verify of cannot_store_register, invalid_p == 0 */ /* Skip verify of get_longjmp_target, has predicate */ - if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->use_generic_dummy_frames == -1)) - fprintf_unfiltered (log, "\n\tuse_generic_dummy_frames"); - if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->call_dummy_location == 0)) - fprintf_unfiltered (log, "\n\tcall_dummy_location"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0)) - fprintf_unfiltered (log, "\n\tcall_dummy_address"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->call_dummy_start_offset == -1)) - fprintf_unfiltered (log, "\n\tcall_dummy_start_offset"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1)) - fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset"); - if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->call_dummy_breakpoint_offset_p == -1)) - fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset_p"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->call_dummy_length == -1)) - fprintf_unfiltered (log, "\n\tcall_dummy_length"); - if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->pc_in_call_dummy == 0)) - fprintf_unfiltered (log, "\n\tpc_in_call_dummy"); - if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->call_dummy_p == -1)) - fprintf_unfiltered (log, "\n\tcall_dummy_p"); - /* Skip verify of call_dummy_words, invalid_p == 0 */ - /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */ - if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->call_dummy_stack_adjust_p == -1)) - fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust_p"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)) - fprintf_unfiltered (log, "\n\tcall_dummy_stack_adjust"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->fix_call_dummy == 0)) - fprintf_unfiltered (log, "\n\tfix_call_dummy"); - /* Skip verify of init_frame_pc_first, invalid_p == 0 */ - /* Skip verify of init_frame_pc, invalid_p == 0 */ - /* Skip verify of coerce_float_to_double, invalid_p == 0 */ - 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 deprecated_pc_in_call_dummy, has predicate */ + /* Skip verify of deprecated_init_frame_pc_first, has predicate */ + /* Skip verify of deprecated_init_frame_pc, has predicate */ + /* Skip verify of deprecated_get_saved_register, has predicate */ + /* Skip verify of deprecated_register_convertible, invalid_p == 0 */ + /* Skip verify of deprecated_register_convert_to_virtual, invalid_p == 0 */ + /* Skip verify of deprecated_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 > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->extract_return_value == 0)) - fprintf_unfiltered (log, "\n\textract_return_value"); - /* 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 > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->pop_frame == 0)) - fprintf_unfiltered (log, "\n\tpop_frame"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->store_struct_return == 0)) - fprintf_unfiltered (log, "\n\tstore_struct_return"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->store_return_value == 0)) - fprintf_unfiltered (log, "\n\tstore_return_value"); + /* Skip verify of deprecated_pop_frame, has predicate */ + /* Skip verify of deprecated_store_struct_return, has predicate */ + /* Skip verify of extract_return_value, invalid_p == 0 */ + /* Skip verify of store_return_value, invalid_p == 0 */ /* Skip verify of extract_struct_value_address, has predicate */ + /* Skip verify of deprecated_extract_struct_value_address, has predicate */ /* Skip verify of use_struct_convention, invalid_p == 0 */ - 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 */ + /* Skip verify of deprecated_frame_init_saved_regs, has predicate */ + /* Skip verify of deprecated_init_extra_frame_info, has predicate */ if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && (gdbarch->skip_prologue == 0)) fprintf_unfiltered (log, "\n\tskip_prologue"); @@ -727,7 +705,9 @@ verify_gdbarch (struct gdbarch *gdbarch) 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 */ + if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) + && (gdbarch->breakpoint_from_pc == 0)) + fprintf_unfiltered (log, "\n\tbreakpoint_from_pc"); /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */ /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */ if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) @@ -742,29 +722,18 @@ verify_gdbarch (struct gdbarch *gdbarch) && (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 > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->frame_chain == 0)) - fprintf_unfiltered (log, "\n\tframe_chain"); - /* 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 > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->frame_args_address == 0)) - fprintf_unfiltered (log, "\n\tframe_args_address"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->frame_locals_address == 0)) - fprintf_unfiltered (log, "\n\tframe_locals_address"); - 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 > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->frame_num_args == 0)) - fprintf_unfiltered (log, "\n\tframe_num_args"); + /* Skip verify of deprecated_frame_chain, has predicate */ + /* Skip verify of deprecated_frame_chain_valid, has predicate */ + /* Skip verify of deprecated_frame_saved_pc, has predicate */ + /* Skip verify of unwind_pc, has predicate */ + /* Skip verify of unwind_sp, has predicate */ + /* Skip verify of frame_args_address, invalid_p == 0 */ + /* Skip verify of frame_locals_address, invalid_p == 0 */ + /* Skip verify of deprecated_saved_pc_after_call, has predicate */ + /* Skip verify of frame_num_args, has predicate */ /* Skip verify of stack_align, has predicate */ - /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */ + /* Skip verify of frame_align, has predicate */ /* Skip verify of reg_struct_has_addr, has predicate */ - /* Skip verify of save_dummy_frame_tos, has predicate */ if (gdbarch->float_format == 0) gdbarch->float_format = default_float_format (gdbarch); if (gdbarch->double_format == 0) @@ -778,12 +747,23 @@ 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 in_solib_return_trampoline, invalid_p == 0 */ /* Skip verify of pc_in_sigtramp, invalid_p == 0 */ + /* Skip verify of sigtramp_start, has predicate */ + /* Skip verify of sigtramp_end, has predicate */ /* 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 */ /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */ /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */ + /* Skip verify of name_of_malloc, invalid_p == 0 */ + /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */ + /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */ + /* Skip verify of address_class_type_flags, has predicate */ + /* Skip verify of address_class_type_flags_to_name, has predicate */ + /* Skip verify of address_class_name_to_type_flags, has predicate */ + /* Skip verify of register_reggroup_p, invalid_p == 0 */ + /* Skip verify of fetch_pointer_argument, has predicate */ buf = ui_file_xstrdup (log, &dummy); make_cleanup (xfree, buf); if (strlen (buf) > 0) @@ -808,18 +788,74 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) fprintf_unfiltered (file, "gdbarch_dump: GDB_MULTI_ARCH = %d\n", GDB_MULTI_ARCH); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_frame_align_p() = %d\n", + gdbarch_frame_align_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: frame_align = 0x%08lx\n", + (long) current_gdbarch->frame_align); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, "gdbarch_dump: in_function_epilogue_p = 0x%08lx\n", (long) current_gdbarch->in_function_epilogue_p); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: register_read = 0x%08lx\n", - (long) current_gdbarch->register_read); + "gdbarch_dump: register_reggroup_p = 0x%08lx\n", + (long) current_gdbarch->register_reggroup_p); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n", + gdbarch_pseudo_register_read_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: pseudo_register_read = 0x%08lx\n", + (long) current_gdbarch->pseudo_register_read); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n", + gdbarch_pseudo_register_write_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: pseudo_register_write = 0x%08lx\n", + (long) current_gdbarch->pseudo_register_write); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n", + gdbarch_address_class_name_to_type_flags_p (current_gdbarch)); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: register_write = 0x%08lx\n", - (long) current_gdbarch->register_write); + "gdbarch_dump: address_class_name_to_type_flags = 0x%08lx\n", + (long) current_gdbarch->address_class_name_to_type_flags); +#ifdef ADDRESS_CLASS_TYPE_FLAGS_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "ADDRESS_CLASS_TYPE_FLAGS_P()", + XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS_P() = %d\n", + ADDRESS_CLASS_TYPE_FLAGS_P ()); +#endif +#ifdef ADDRESS_CLASS_TYPE_FLAGS + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)", + XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = <0x%08lx>\n", + (long) current_gdbarch->address_class_type_flags + /*ADDRESS_CLASS_TYPE_FLAGS ()*/); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n", + gdbarch_address_class_type_flags_to_name_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: address_class_type_flags_to_name = 0x%08lx\n", + (long) current_gdbarch->address_class_type_flags_to_name); #ifdef ADDRESS_TO_POINTER #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ @@ -830,7 +866,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: ADDRESS_TO_POINTER = 0x%08lx\n", + "gdbarch_dump: ADDRESS_TO_POINTER = <0x%08lx>\n", (long) current_gdbarch->address_to_pointer /*ADDRESS_TO_POINTER ()*/); #endif @@ -841,7 +877,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (ADDR_BITS_REMOVE (addr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: ADDR_BITS_REMOVE = 0x%08lx\n", + "gdbarch_dump: ADDR_BITS_REMOVE = <0x%08lx>\n", (long) current_gdbarch->addr_bits_remove /*ADDR_BITS_REMOVE ()*/); #endif @@ -868,7 +904,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: BREAKPOINT_FROM_PC = 0x%08lx\n", + "gdbarch_dump: BREAKPOINT_FROM_PC = <0x%08lx>\n", (long) current_gdbarch->breakpoint_from_pc /*BREAKPOINT_FROM_PC ()*/); #endif @@ -879,36 +915,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (CALL_DUMMY_ADDRESS ())); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_ADDRESS = 0x%08lx\n", + "gdbarch_dump: CALL_DUMMY_ADDRESS = <0x%08lx>\n", (long) current_gdbarch->call_dummy_address /*CALL_DUMMY_ADDRESS ()*/); #endif -#ifdef CALL_DUMMY_BREAKPOINT_OFFSET - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n", - XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET)); - if (CALL_DUMMY_BREAKPOINT_OFFSET_P) - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n", - (long) CALL_DUMMY_BREAKPOINT_OFFSET); -#endif -#ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n", - XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P)); - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %d\n", - CALL_DUMMY_BREAKPOINT_OFFSET_P); -#endif -#ifdef CALL_DUMMY_LENGTH - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n", - XSTRING (CALL_DUMMY_LENGTH)); - if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END) - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_LENGTH = %d\n", - CALL_DUMMY_LENGTH); -#endif #ifdef CALL_DUMMY_LOCATION fprintf_unfiltered (file, "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n", @@ -917,47 +927,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: CALL_DUMMY_LOCATION = %d\n", CALL_DUMMY_LOCATION); #endif -#ifdef CALL_DUMMY_P - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_P # %s\n", - XSTRING (CALL_DUMMY_P)); - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_P = %d\n", - CALL_DUMMY_P); -#endif -#ifdef CALL_DUMMY_STACK_ADJUST - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_STACK_ADJUST # %s\n", - XSTRING (CALL_DUMMY_STACK_ADJUST)); - if (CALL_DUMMY_STACK_ADJUST_P) - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n", - (long) CALL_DUMMY_STACK_ADJUST); -#endif -#ifdef CALL_DUMMY_STACK_ADJUST_P - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P # %s\n", - XSTRING (CALL_DUMMY_STACK_ADJUST_P)); - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n", - (long) CALL_DUMMY_STACK_ADJUST_P); -#endif -#ifdef CALL_DUMMY_START_OFFSET - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n", - XSTRING (CALL_DUMMY_START_OFFSET)); - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_START_OFFSET = 0x%08lx\n", - (long) CALL_DUMMY_START_OFFSET); -#endif -#ifdef CALL_DUMMY_WORDS - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_WORDS # %s\n", - XSTRING (CALL_DUMMY_WORDS)); - fprintf_unfiltered (file, - "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n", - (long) CALL_DUMMY_WORDS); -#endif #ifdef CANNOT_FETCH_REGISTER fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -965,10 +934,18 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (CANNOT_FETCH_REGISTER (regnum))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: CANNOT_FETCH_REGISTER = 0x%08lx\n", + "gdbarch_dump: CANNOT_FETCH_REGISTER = <0x%08lx>\n", (long) current_gdbarch->cannot_fetch_register /*CANNOT_FETCH_REGISTER ()*/); #endif +#ifdef CANNOT_STEP_BREAKPOINT + fprintf_unfiltered (file, + "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n", + XSTRING (CANNOT_STEP_BREAKPOINT)); + fprintf_unfiltered (file, + "gdbarch_dump: CANNOT_STEP_BREAKPOINT = %d\n", + CANNOT_STEP_BREAKPOINT); +#endif #ifdef CANNOT_STORE_REGISTER fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -976,21 +953,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (CANNOT_STORE_REGISTER (regnum))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: CANNOT_STORE_REGISTER = 0x%08lx\n", + "gdbarch_dump: CANNOT_STORE_REGISTER = <0x%08lx>\n", (long) current_gdbarch->cannot_store_register /*CANNOT_STORE_REGISTER ()*/); #endif -#ifdef COERCE_FLOAT_TO_DOUBLE - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "COERCE_FLOAT_TO_DOUBLE(formal, actual)", - XSTRING (COERCE_FLOAT_TO_DOUBLE (formal, actual))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n", - (long) current_gdbarch->coerce_float_to_double - /*COERCE_FLOAT_TO_DOUBLE ()*/); -#endif #ifdef COFF_MAKE_MSYMBOL_SPECIAL #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ @@ -1001,7 +967,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = 0x%08lx\n", + "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n", (long) current_gdbarch->coff_make_msymbol_special /*COFF_MAKE_MSYMBOL_SPECIAL ()*/); #endif @@ -1016,18 +982,18 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = 0x%08lx\n", + "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = <0x%08lx>\n", (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))); + "CONVERT_REGISTER_P(regnum, type)", + XSTRING (CONVERT_REGISTER_P (regnum, type))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: CONVERT_REGISTER_P = 0x%08lx\n", + "gdbarch_dump: CONVERT_REGISTER_P = <0x%08lx>\n", (long) current_gdbarch->convert_register_p /*CONVERT_REGISTER_P ()*/); #endif @@ -1039,389 +1005,921 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n", (long) DECR_PC_AFTER_BREAK); #endif -#ifdef DO_REGISTERS_INFO -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ +#ifdef DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "DO_REGISTERS_INFO(reg_nr, fpregs)", - XSTRING (DO_REGISTERS_INFO (reg_nr, fpregs))); + "gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET # %s\n", + XSTRING (DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET = %ld\n", + (long) DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET); #endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: DO_REGISTERS_INFO = 0x%08lx\n", - (long) current_gdbarch->do_registers_info - /*DO_REGISTERS_INFO ()*/); +#ifdef DEPRECATED_CALL_DUMMY_LENGTH + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH # %s\n", + XSTRING (DEPRECATED_CALL_DUMMY_LENGTH)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH = %d\n", + DEPRECATED_CALL_DUMMY_LENGTH); #endif -#ifdef DWARF2_BUILD_FRAME_INFO -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ +#ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "DWARF2_BUILD_FRAME_INFO(objfile)", - XSTRING (DWARF2_BUILD_FRAME_INFO (objfile))); + "DEPRECATED_CALL_DUMMY_STACK_ADJUST_P()", + XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST_P() = %d\n", + DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()); #endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = 0x%08lx\n", - (long) current_gdbarch->dwarf2_build_frame_info - /*DWARF2_BUILD_FRAME_INFO ()*/); +#ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST # %s\n", + XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST = %d\n", + DEPRECATED_CALL_DUMMY_STACK_ADJUST); #endif -#ifdef DWARF2_REG_TO_REGNUM +#ifdef DEPRECATED_CALL_DUMMY_START_OFFSET + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET # %s\n", + XSTRING (DEPRECATED_CALL_DUMMY_START_OFFSET)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET = %ld\n", + (long) DEPRECATED_CALL_DUMMY_START_OFFSET); +#endif +#ifdef DEPRECATED_CALL_DUMMY_WORDS + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS # %s\n", + XSTRING (DEPRECATED_CALL_DUMMY_WORDS)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS = 0x%08lx\n", + (long) DEPRECATED_CALL_DUMMY_WORDS); +#endif +#ifdef DEPRECATED_DO_REGISTERS_INFO_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "DWARF2_REG_TO_REGNUM(dwarf2_regnr)", - XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: DWARF2_REG_TO_REGNUM = 0x%08lx\n", - (long) current_gdbarch->dwarf2_reg_to_regnum - /*DWARF2_REG_TO_REGNUM ()*/); + "DEPRECATED_DO_REGISTERS_INFO_P()", + XSTRING (DEPRECATED_DO_REGISTERS_INFO_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO_P() = %d\n", + DEPRECATED_DO_REGISTERS_INFO_P ()); #endif -#ifdef DWARF_REG_TO_REGNUM +#ifdef DEPRECATED_DO_REGISTERS_INFO +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "DWARF_REG_TO_REGNUM(dwarf_regnr)", - XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr))); + "DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs)", + XSTRING (DEPRECATED_DO_REGISTERS_INFO (reg_nr, fpregs))); +#endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: DWARF_REG_TO_REGNUM = 0x%08lx\n", - (long) current_gdbarch->dwarf_reg_to_regnum - /*DWARF_REG_TO_REGNUM ()*/); + "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = <0x%08lx>\n", + (long) current_gdbarch->deprecated_do_registers_info + /*DEPRECATED_DO_REGISTERS_INFO ()*/); #endif -#ifdef ECOFF_REG_TO_REGNUM +#ifdef DEPRECATED_DUMMY_WRITE_SP_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "ECOFF_REG_TO_REGNUM(ecoff_regnr)", - XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: ECOFF_REG_TO_REGNUM = 0x%08lx\n", - (long) current_gdbarch->ecoff_reg_to_regnum - /*ECOFF_REG_TO_REGNUM ()*/); + "DEPRECATED_DUMMY_WRITE_SP_P()", + XSTRING (DEPRECATED_DUMMY_WRITE_SP_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP_P() = %d\n", + DEPRECATED_DUMMY_WRITE_SP_P ()); #endif -#ifdef ELF_MAKE_MSYMBOL_SPECIAL +#ifdef DEPRECATED_DUMMY_WRITE_SP #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)", - XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym, msym))); + "DEPRECATED_DUMMY_WRITE_SP(val)", + XSTRING (DEPRECATED_DUMMY_WRITE_SP (val))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = 0x%08lx\n", - (long) current_gdbarch->elf_make_msymbol_special - /*ELF_MAKE_MSYMBOL_SPECIAL ()*/); + "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP = <0x%08lx>\n", + (long) current_gdbarch->deprecated_dummy_write_sp + /*DEPRECATED_DUMMY_WRITE_SP ()*/); #endif -#ifdef EXTRACT_RETURN_VALUE +#ifdef DEPRECATED_EXTRACT_RETURN_VALUE #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "EXTRACT_RETURN_VALUE(type, regbuf, valbuf)", - XSTRING (EXTRACT_RETURN_VALUE (type, regbuf, valbuf))); + "DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf)", + XSTRING (DEPRECATED_EXTRACT_RETURN_VALUE (type, regbuf, valbuf))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: EXTRACT_RETURN_VALUE = 0x%08lx\n", - (long) current_gdbarch->extract_return_value - /*EXTRACT_RETURN_VALUE ()*/); + "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = <0x%08lx>\n", + (long) current_gdbarch->deprecated_extract_return_value + /*DEPRECATED_EXTRACT_RETURN_VALUE ()*/); #endif -#ifdef EXTRACT_STRUCT_VALUE_ADDRESS +#ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)", - XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regbuf))); + "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()", + XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n", + DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()); +#endif +#ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)", + XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n", - (long) current_gdbarch->extract_struct_value_address - /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/); + "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n", + (long) current_gdbarch->deprecated_extract_struct_value_address + /*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/); #endif -#ifdef EXTRA_STACK_ALIGNMENT_NEEDED +#ifdef DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED fprintf_unfiltered (file, - "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n", - XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED)); + "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED # %s\n", + XSTRING (DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED)); fprintf_unfiltered (file, - "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %d\n", - EXTRA_STACK_ALIGNMENT_NEEDED); + "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED = %d\n", + DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED); #endif -#ifdef FETCH_PSEUDO_REGISTER -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ +#ifdef DEPRECATED_FIX_CALL_DUMMY_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "FETCH_PSEUDO_REGISTER(regnum)", - XSTRING (FETCH_PSEUDO_REGISTER (regnum))); -#endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: FETCH_PSEUDO_REGISTER = 0x%08lx\n", - (long) current_gdbarch->fetch_pseudo_register - /*FETCH_PSEUDO_REGISTER ()*/); + "DEPRECATED_FIX_CALL_DUMMY_P()", + XSTRING (DEPRECATED_FIX_CALL_DUMMY_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY_P() = %d\n", + DEPRECATED_FIX_CALL_DUMMY_P ()); #endif -#ifdef FIX_CALL_DUMMY +#ifdef DEPRECATED_FIX_CALL_DUMMY #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)", - XSTRING (FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p))); + "DEPRECATED_FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)", + XSTRING (DEPRECATED_FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: FIX_CALL_DUMMY = 0x%08lx\n", - (long) current_gdbarch->fix_call_dummy - /*FIX_CALL_DUMMY ()*/); + "gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY = <0x%08lx>\n", + (long) current_gdbarch->deprecated_fix_call_dummy + /*DEPRECATED_FIX_CALL_DUMMY ()*/); #endif -#ifdef FP0_REGNUM +#ifdef DEPRECATED_FP_REGNUM fprintf_unfiltered (file, - "gdbarch_dump: FP0_REGNUM # %s\n", - XSTRING (FP0_REGNUM)); + "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n", + XSTRING (DEPRECATED_FP_REGNUM)); fprintf_unfiltered (file, - "gdbarch_dump: FP0_REGNUM = %d\n", - FP0_REGNUM); + "gdbarch_dump: DEPRECATED_FP_REGNUM = %d\n", + DEPRECATED_FP_REGNUM); #endif -#ifdef FP_REGNUM +#ifdef DEPRECATED_FRAME_CHAIN_P fprintf_unfiltered (file, - "gdbarch_dump: FP_REGNUM # %s\n", - XSTRING (FP_REGNUM)); + "gdbarch_dump: %s # %s\n", + "DEPRECATED_FRAME_CHAIN_P()", + XSTRING (DEPRECATED_FRAME_CHAIN_P ())); fprintf_unfiltered (file, - "gdbarch_dump: FP_REGNUM = %d\n", - FP_REGNUM); + "gdbarch_dump: DEPRECATED_FRAME_CHAIN_P() = %d\n", + DEPRECATED_FRAME_CHAIN_P ()); #endif -#ifdef FRAMELESS_FUNCTION_INVOCATION +#ifdef DEPRECATED_FRAME_CHAIN fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "FRAMELESS_FUNCTION_INVOCATION(fi)", - XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi))); + "DEPRECATED_FRAME_CHAIN(frame)", + XSTRING (DEPRECATED_FRAME_CHAIN (frame))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n", - (long) current_gdbarch->frameless_function_invocation - /*FRAMELESS_FUNCTION_INVOCATION ()*/); + "gdbarch_dump: DEPRECATED_FRAME_CHAIN = <0x%08lx>\n", + (long) current_gdbarch->deprecated_frame_chain + /*DEPRECATED_FRAME_CHAIN ()*/); #endif -#ifdef FRAME_ARGS_ADDRESS +#ifdef DEPRECATED_FRAME_CHAIN_VALID_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "FRAME_ARGS_ADDRESS(fi)", - XSTRING (FRAME_ARGS_ADDRESS (fi))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: FRAME_ARGS_ADDRESS = 0x%08lx\n", - (long) current_gdbarch->frame_args_address - /*FRAME_ARGS_ADDRESS ()*/); -#endif -#ifdef FRAME_ARGS_SKIP + "DEPRECATED_FRAME_CHAIN_VALID_P()", + XSTRING (DEPRECATED_FRAME_CHAIN_VALID_P ())); fprintf_unfiltered (file, - "gdbarch_dump: FRAME_ARGS_SKIP # %s\n", - XSTRING (FRAME_ARGS_SKIP)); - fprintf_unfiltered (file, - "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n", - (long) FRAME_ARGS_SKIP); + "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID_P() = %d\n", + DEPRECATED_FRAME_CHAIN_VALID_P ()); #endif -#ifdef FRAME_CHAIN +#ifdef DEPRECATED_FRAME_CHAIN_VALID fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "FRAME_CHAIN(frame)", - XSTRING (FRAME_CHAIN (frame))); + "DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe)", + XSTRING (DEPRECATED_FRAME_CHAIN_VALID (chain, thisframe))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: FRAME_CHAIN = 0x%08lx\n", - (long) current_gdbarch->frame_chain - /*FRAME_CHAIN ()*/); + "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID = <0x%08lx>\n", + (long) current_gdbarch->deprecated_frame_chain_valid + /*DEPRECATED_FRAME_CHAIN_VALID ()*/); #endif -#ifdef FRAME_CHAIN_VALID +#ifdef DEPRECATED_FRAME_INIT_SAVED_REGS_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "FRAME_CHAIN_VALID(chain, thisframe)", - XSTRING (FRAME_CHAIN_VALID (chain, thisframe))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: FRAME_CHAIN_VALID = 0x%08lx\n", - (long) current_gdbarch->frame_chain_valid - /*FRAME_CHAIN_VALID ()*/); + "DEPRECATED_FRAME_INIT_SAVED_REGS_P()", + XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS_P() = %d\n", + DEPRECATED_FRAME_INIT_SAVED_REGS_P ()); #endif -#ifdef FRAME_INIT_SAVED_REGS +#ifdef DEPRECATED_FRAME_INIT_SAVED_REGS #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "FRAME_INIT_SAVED_REGS(frame)", - XSTRING (FRAME_INIT_SAVED_REGS (frame))); + "DEPRECATED_FRAME_INIT_SAVED_REGS(frame)", + XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS (frame))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: FRAME_INIT_SAVED_REGS = 0x%08lx\n", - (long) current_gdbarch->frame_init_saved_regs - /*FRAME_INIT_SAVED_REGS ()*/); + "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS = <0x%08lx>\n", + (long) current_gdbarch->deprecated_frame_init_saved_regs + /*DEPRECATED_FRAME_INIT_SAVED_REGS ()*/); #endif -#ifdef FRAME_LOCALS_ADDRESS +#ifdef DEPRECATED_FRAME_SAVED_PC_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "FRAME_LOCALS_ADDRESS(fi)", - XSTRING (FRAME_LOCALS_ADDRESS (fi))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: FRAME_LOCALS_ADDRESS = 0x%08lx\n", - (long) current_gdbarch->frame_locals_address - /*FRAME_LOCALS_ADDRESS ()*/); -#endif -#ifdef FRAME_NUM_ARGS + "DEPRECATED_FRAME_SAVED_PC_P()", + XSTRING (DEPRECATED_FRAME_SAVED_PC_P ())); fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "FRAME_NUM_ARGS(frame)", - XSTRING (FRAME_NUM_ARGS (frame))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: FRAME_NUM_ARGS = 0x%08lx\n", - (long) current_gdbarch->frame_num_args - /*FRAME_NUM_ARGS ()*/); + "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC_P() = %d\n", + DEPRECATED_FRAME_SAVED_PC_P ()); #endif -#ifdef FRAME_SAVED_PC +#ifdef DEPRECATED_FRAME_SAVED_PC fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "FRAME_SAVED_PC(fi)", - XSTRING (FRAME_SAVED_PC (fi))); + "DEPRECATED_FRAME_SAVED_PC(fi)", + XSTRING (DEPRECATED_FRAME_SAVED_PC (fi))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: FRAME_SAVED_PC = 0x%08lx\n", - (long) current_gdbarch->frame_saved_pc - /*FRAME_SAVED_PC ()*/); + "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC = <0x%08lx>\n", + (long) current_gdbarch->deprecated_frame_saved_pc + /*DEPRECATED_FRAME_SAVED_PC ()*/); #endif -#ifdef FUNCTION_START_OFFSET - fprintf_unfiltered (file, - "gdbarch_dump: FUNCTION_START_OFFSET # %s\n", - XSTRING (FUNCTION_START_OFFSET)); - fprintf_unfiltered (file, - "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n", - (long) FUNCTION_START_OFFSET); -#endif -#ifdef GET_LONGJMP_TARGET +#ifdef DEPRECATED_GET_SAVED_REGISTER_P 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 ()*/); + "DEPRECATED_GET_SAVED_REGISTER_P()", + XSTRING (DEPRECATED_GET_SAVED_REGISTER_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER_P() = %d\n", + DEPRECATED_GET_SAVED_REGISTER_P ()); #endif -#ifdef GET_SAVED_REGISTER +#ifdef DEPRECATED_GET_SAVED_REGISTER #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)", - XSTRING (GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval))); + "DEPRECATED_GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)", + XSTRING (DEPRECATED_GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: GET_SAVED_REGISTER = 0x%08lx\n", - (long) current_gdbarch->get_saved_register - /*GET_SAVED_REGISTER ()*/); + "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER = <0x%08lx>\n", + (long) current_gdbarch->deprecated_get_saved_register + /*DEPRECATED_GET_SAVED_REGISTER ()*/); #endif -#ifdef INIT_EXTRA_FRAME_INFO -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ +#ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "INIT_EXTRA_FRAME_INFO(fromleaf, frame)", - XSTRING (INIT_EXTRA_FRAME_INFO (fromleaf, frame))); -#endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: INIT_EXTRA_FRAME_INFO = 0x%08lx\n", - (long) current_gdbarch->init_extra_frame_info - /*INIT_EXTRA_FRAME_INFO ()*/); + "DEPRECATED_INIT_EXTRA_FRAME_INFO_P()", + XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO_P() = %d\n", + DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()); #endif -#ifdef INIT_FRAME_PC +#ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "INIT_FRAME_PC(fromleaf, prev)", - XSTRING (INIT_FRAME_PC (fromleaf, prev))); + "DEPRECATED_INIT_EXTRA_FRAME_INFO(fromleaf, frame)", + XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf, frame))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: INIT_FRAME_PC = 0x%08lx\n", - (long) current_gdbarch->init_frame_pc - /*INIT_FRAME_PC ()*/); + "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO = <0x%08lx>\n", + (long) current_gdbarch->deprecated_init_extra_frame_info + /*DEPRECATED_INIT_EXTRA_FRAME_INFO ()*/); #endif -#ifdef INIT_FRAME_PC_FIRST -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ +#ifdef DEPRECATED_INIT_FRAME_PC_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "INIT_FRAME_PC_FIRST(fromleaf, prev)", - XSTRING (INIT_FRAME_PC_FIRST (fromleaf, prev))); -#endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: INIT_FRAME_PC_FIRST = 0x%08lx\n", - (long) current_gdbarch->init_frame_pc_first - /*INIT_FRAME_PC_FIRST ()*/); + "DEPRECATED_INIT_FRAME_PC_P()", + XSTRING (DEPRECATED_INIT_FRAME_PC_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_P() = %d\n", + DEPRECATED_INIT_FRAME_PC_P ()); #endif -#ifdef INNER_THAN +#ifdef DEPRECATED_INIT_FRAME_PC fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "INNER_THAN(lhs, rhs)", - XSTRING (INNER_THAN (lhs, rhs))); + "DEPRECATED_INIT_FRAME_PC(fromleaf, prev)", + XSTRING (DEPRECATED_INIT_FRAME_PC (fromleaf, prev))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: INNER_THAN = 0x%08lx\n", - (long) current_gdbarch->inner_than - /*INNER_THAN ()*/); + "gdbarch_dump: DEPRECATED_INIT_FRAME_PC = <0x%08lx>\n", + (long) current_gdbarch->deprecated_init_frame_pc + /*DEPRECATED_INIT_FRAME_PC ()*/); #endif -#ifdef INTEGER_TO_ADDRESS +#ifdef DEPRECATED_INIT_FRAME_PC_FIRST_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "INTEGER_TO_ADDRESS(type, buf)", - XSTRING (INTEGER_TO_ADDRESS (type, buf))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: INTEGER_TO_ADDRESS = 0x%08lx\n", - (long) current_gdbarch->integer_to_address - /*INTEGER_TO_ADDRESS ()*/); + "DEPRECATED_INIT_FRAME_PC_FIRST_P()", + XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST_P() = %d\n", + DEPRECATED_INIT_FRAME_PC_FIRST_P ()); #endif -#ifdef IN_SOLIB_CALL_TRAMPOLINE +#ifdef DEPRECATED_INIT_FRAME_PC_FIRST fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "IN_SOLIB_CALL_TRAMPOLINE(pc, name)", - XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc, name))); + "DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev)", + XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf, prev))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = 0x%08lx\n", - (long) current_gdbarch->in_solib_call_trampoline - /*IN_SOLIB_CALL_TRAMPOLINE ()*/); + "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST = <0x%08lx>\n", + (long) current_gdbarch->deprecated_init_frame_pc_first + /*DEPRECATED_INIT_FRAME_PC_FIRST ()*/); #endif -#ifdef MAX_REGISTER_RAW_SIZE +#ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE_P fprintf_unfiltered (file, - "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n", - XSTRING (MAX_REGISTER_RAW_SIZE)); + "gdbarch_dump: %s # %s\n", + "DEPRECATED_MAX_REGISTER_RAW_SIZE_P()", + XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE_P ())); fprintf_unfiltered (file, - "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %d\n", - MAX_REGISTER_RAW_SIZE); + "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE_P() = %d\n", + DEPRECATED_MAX_REGISTER_RAW_SIZE_P ()); #endif -#ifdef MAX_REGISTER_VIRTUAL_SIZE +#ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE fprintf_unfiltered (file, - "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n", - XSTRING (MAX_REGISTER_VIRTUAL_SIZE)); + "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE # %s\n", + XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE)); fprintf_unfiltered (file, - "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %d\n", - MAX_REGISTER_VIRTUAL_SIZE); + "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE = %d\n", + DEPRECATED_MAX_REGISTER_RAW_SIZE); #endif -#ifdef MEMORY_INSERT_BREAKPOINT +#ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P()", + XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P() = %d\n", + DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ()); +#endif +#ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE # %s\n", + XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE = %d\n", + DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE); +#endif +#ifdef DEPRECATED_PC_IN_CALL_DUMMY_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_PC_IN_CALL_DUMMY_P()", + XSTRING (DEPRECATED_PC_IN_CALL_DUMMY_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY_P() = %d\n", + DEPRECATED_PC_IN_CALL_DUMMY_P ()); +#endif +#ifdef DEPRECATED_PC_IN_CALL_DUMMY + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address)", + XSTRING (DEPRECATED_PC_IN_CALL_DUMMY (pc, sp, frame_address))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY = <0x%08lx>\n", + (long) current_gdbarch->deprecated_pc_in_call_dummy + /*DEPRECATED_PC_IN_CALL_DUMMY ()*/); +#endif +#ifdef DEPRECATED_POP_FRAME_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_POP_FRAME_P()", + XSTRING (DEPRECATED_POP_FRAME_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_POP_FRAME_P() = %d\n", + DEPRECATED_POP_FRAME_P ()); +#endif +#ifdef DEPRECATED_POP_FRAME +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_POP_FRAME(-)", + XSTRING (DEPRECATED_POP_FRAME (-))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_POP_FRAME = <0x%08lx>\n", + (long) current_gdbarch->deprecated_pop_frame + /*DEPRECATED_POP_FRAME ()*/); +#endif +#ifdef DEPRECATED_PUSH_ARGUMENTS_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_PUSH_ARGUMENTS_P()", + XSTRING (DEPRECATED_PUSH_ARGUMENTS_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS_P() = %d\n", + DEPRECATED_PUSH_ARGUMENTS_P ()); +#endif +#ifdef DEPRECATED_PUSH_ARGUMENTS + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)", + XSTRING (DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS = <0x%08lx>\n", + (long) current_gdbarch->deprecated_push_arguments + /*DEPRECATED_PUSH_ARGUMENTS ()*/); +#endif +#ifdef DEPRECATED_PUSH_DUMMY_FRAME_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_PUSH_DUMMY_FRAME_P()", + XSTRING (DEPRECATED_PUSH_DUMMY_FRAME_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME_P() = %d\n", + DEPRECATED_PUSH_DUMMY_FRAME_P ()); +#endif +#ifdef DEPRECATED_PUSH_DUMMY_FRAME +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_PUSH_DUMMY_FRAME(-)", + XSTRING (DEPRECATED_PUSH_DUMMY_FRAME (-))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME = <0x%08lx>\n", + (long) current_gdbarch->deprecated_push_dummy_frame + /*DEPRECATED_PUSH_DUMMY_FRAME ()*/); +#endif +#ifdef DEPRECATED_PUSH_RETURN_ADDRESS_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_PUSH_RETURN_ADDRESS_P()", + XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS_P() = %d\n", + DEPRECATED_PUSH_RETURN_ADDRESS_P ()); +#endif +#ifdef DEPRECATED_PUSH_RETURN_ADDRESS + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_PUSH_RETURN_ADDRESS(pc, sp)", + XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS (pc, sp))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS = <0x%08lx>\n", + (long) current_gdbarch->deprecated_push_return_address + /*DEPRECATED_PUSH_RETURN_ADDRESS ()*/); +#endif +#ifdef DEPRECATED_REGISTER_BYTES + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_REGISTER_BYTES # %s\n", + XSTRING (DEPRECATED_REGISTER_BYTES)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_REGISTER_BYTES = %d\n", + DEPRECATED_REGISTER_BYTES); +#endif +#ifdef DEPRECATED_REGISTER_CONVERTIBLE + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_REGISTER_CONVERTIBLE(nr)", + XSTRING (DEPRECATED_REGISTER_CONVERTIBLE (nr))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_REGISTER_CONVERTIBLE = <0x%08lx>\n", + (long) current_gdbarch->deprecated_register_convertible + /*DEPRECATED_REGISTER_CONVERTIBLE ()*/); +#endif +#ifdef DEPRECATED_REGISTER_CONVERT_TO_RAW +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_REGISTER_CONVERT_TO_RAW(type, regnum, from, to)", + XSTRING (DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_REGISTER_CONVERT_TO_RAW = <0x%08lx>\n", + (long) current_gdbarch->deprecated_register_convert_to_raw + /*DEPRECATED_REGISTER_CONVERT_TO_RAW ()*/); +#endif +#ifdef DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)", + XSTRING (DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL = <0x%08lx>\n", + (long) current_gdbarch->deprecated_register_convert_to_virtual + /*DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL ()*/); +#endif +#ifdef DEPRECATED_REGISTER_SIZE + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n", + XSTRING (DEPRECATED_REGISTER_SIZE)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_REGISTER_SIZE = %d\n", + DEPRECATED_REGISTER_SIZE); +#endif +#ifdef DEPRECATED_SAVED_PC_AFTER_CALL_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_SAVED_PC_AFTER_CALL_P()", + XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_SAVED_PC_AFTER_CALL_P() = %d\n", + DEPRECATED_SAVED_PC_AFTER_CALL_P ()); +#endif +#ifdef DEPRECATED_SAVED_PC_AFTER_CALL + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_SAVED_PC_AFTER_CALL(frame)", + XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL (frame))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_SAVED_PC_AFTER_CALL = <0x%08lx>\n", + (long) current_gdbarch->deprecated_saved_pc_after_call + /*DEPRECATED_SAVED_PC_AFTER_CALL ()*/); +#endif +#ifdef DEPRECATED_SIZEOF_CALL_DUMMY_WORDS + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS # %s\n", + XSTRING (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS = %d\n", + DEPRECATED_SIZEOF_CALL_DUMMY_WORDS); +#endif +#ifdef DEPRECATED_STORE_RETURN_VALUE +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_STORE_RETURN_VALUE(type, valbuf)", + XSTRING (DEPRECATED_STORE_RETURN_VALUE (type, valbuf))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = <0x%08lx>\n", + (long) current_gdbarch->deprecated_store_return_value + /*DEPRECATED_STORE_RETURN_VALUE ()*/); +#endif +#ifdef DEPRECATED_STORE_STRUCT_RETURN_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_STORE_STRUCT_RETURN_P()", + XSTRING (DEPRECATED_STORE_STRUCT_RETURN_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN_P() = %d\n", + DEPRECATED_STORE_STRUCT_RETURN_P ()); +#endif +#ifdef DEPRECATED_STORE_STRUCT_RETURN +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_STORE_STRUCT_RETURN(addr, sp)", + XSTRING (DEPRECATED_STORE_STRUCT_RETURN (addr, sp))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN = <0x%08lx>\n", + (long) current_gdbarch->deprecated_store_struct_return + /*DEPRECATED_STORE_STRUCT_RETURN ()*/); +#endif +#ifdef DEPRECATED_TARGET_READ_FP_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_TARGET_READ_FP_P()", + XSTRING (DEPRECATED_TARGET_READ_FP_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_TARGET_READ_FP_P() = %d\n", + DEPRECATED_TARGET_READ_FP_P ()); +#endif +#ifdef DEPRECATED_TARGET_READ_FP + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_TARGET_READ_FP()", + XSTRING (DEPRECATED_TARGET_READ_FP ())); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_TARGET_READ_FP = <0x%08lx>\n", + (long) current_gdbarch->deprecated_target_read_fp + /*DEPRECATED_TARGET_READ_FP ()*/); +#endif +#ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n", + XSTRING (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES = %d\n", + DEPRECATED_USE_GENERIC_DUMMY_FRAMES); +#endif +#ifdef DWARF2_BUILD_FRAME_INFO_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DWARF2_BUILD_FRAME_INFO_P()", + XSTRING (DWARF2_BUILD_FRAME_INFO_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DWARF2_BUILD_FRAME_INFO_P() = %d\n", + DWARF2_BUILD_FRAME_INFO_P ()); +#endif +#ifdef DWARF2_BUILD_FRAME_INFO +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DWARF2_BUILD_FRAME_INFO(objfile)", + XSTRING (DWARF2_BUILD_FRAME_INFO (objfile))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = <0x%08lx>\n", + (long) current_gdbarch->dwarf2_build_frame_info + /*DWARF2_BUILD_FRAME_INFO ()*/); +#endif +#ifdef DWARF2_REG_TO_REGNUM + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DWARF2_REG_TO_REGNUM(dwarf2_regnr)", + XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DWARF2_REG_TO_REGNUM = <0x%08lx>\n", + (long) current_gdbarch->dwarf2_reg_to_regnum + /*DWARF2_REG_TO_REGNUM ()*/); +#endif +#ifdef DWARF_REG_TO_REGNUM + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DWARF_REG_TO_REGNUM(dwarf_regnr)", + XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DWARF_REG_TO_REGNUM = <0x%08lx>\n", + (long) current_gdbarch->dwarf_reg_to_regnum + /*DWARF_REG_TO_REGNUM ()*/); +#endif +#ifdef ECOFF_REG_TO_REGNUM + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "ECOFF_REG_TO_REGNUM(ecoff_regnr)", + XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: ECOFF_REG_TO_REGNUM = <0x%08lx>\n", + (long) current_gdbarch->ecoff_reg_to_regnum + /*ECOFF_REG_TO_REGNUM ()*/); +#endif +#ifdef ELF_MAKE_MSYMBOL_SPECIAL +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)", + XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym, msym))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n", + (long) current_gdbarch->elf_make_msymbol_special + /*ELF_MAKE_MSYMBOL_SPECIAL ()*/); +#endif +#ifdef EXTRACT_RETURN_VALUE +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "EXTRACT_RETURN_VALUE(type, regcache, valbuf)", + XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: EXTRACT_RETURN_VALUE = <0x%08lx>\n", + (long) current_gdbarch->extract_return_value + /*EXTRACT_RETURN_VALUE ()*/); +#endif +#ifdef EXTRACT_STRUCT_VALUE_ADDRESS_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "EXTRACT_STRUCT_VALUE_ADDRESS_P()", + XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n", + EXTRACT_STRUCT_VALUE_ADDRESS_P ()); +#endif +#ifdef EXTRACT_STRUCT_VALUE_ADDRESS + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "EXTRACT_STRUCT_VALUE_ADDRESS(regcache)", + XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n", + (long) current_gdbarch->extract_struct_value_address + /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/); +#endif +#ifdef FETCH_POINTER_ARGUMENT_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "FETCH_POINTER_ARGUMENT_P()", + XSTRING (FETCH_POINTER_ARGUMENT_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: FETCH_POINTER_ARGUMENT_P() = %d\n", + FETCH_POINTER_ARGUMENT_P ()); +#endif +#ifdef FETCH_POINTER_ARGUMENT + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "FETCH_POINTER_ARGUMENT(frame, argi, type)", + XSTRING (FETCH_POINTER_ARGUMENT (frame, argi, type))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: FETCH_POINTER_ARGUMENT = <0x%08lx>\n", + (long) current_gdbarch->fetch_pointer_argument + /*FETCH_POINTER_ARGUMENT ()*/); +#endif +#ifdef FP0_REGNUM + fprintf_unfiltered (file, + "gdbarch_dump: FP0_REGNUM # %s\n", + XSTRING (FP0_REGNUM)); + fprintf_unfiltered (file, + "gdbarch_dump: FP0_REGNUM = %d\n", + FP0_REGNUM); +#endif +#ifdef FRAMELESS_FUNCTION_INVOCATION + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "FRAMELESS_FUNCTION_INVOCATION(fi)", + XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n", + (long) current_gdbarch->frameless_function_invocation + /*FRAMELESS_FUNCTION_INVOCATION ()*/); +#endif +#ifdef FRAME_ARGS_ADDRESS + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "FRAME_ARGS_ADDRESS(fi)", + XSTRING (FRAME_ARGS_ADDRESS (fi))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: FRAME_ARGS_ADDRESS = <0x%08lx>\n", + (long) current_gdbarch->frame_args_address + /*FRAME_ARGS_ADDRESS ()*/); +#endif +#ifdef FRAME_ARGS_SKIP + fprintf_unfiltered (file, + "gdbarch_dump: FRAME_ARGS_SKIP # %s\n", + XSTRING (FRAME_ARGS_SKIP)); + fprintf_unfiltered (file, + "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n", + (long) FRAME_ARGS_SKIP); +#endif +#ifdef FRAME_LOCALS_ADDRESS + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "FRAME_LOCALS_ADDRESS(fi)", + XSTRING (FRAME_LOCALS_ADDRESS (fi))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: FRAME_LOCALS_ADDRESS = <0x%08lx>\n", + (long) current_gdbarch->frame_locals_address + /*FRAME_LOCALS_ADDRESS ()*/); +#endif +#ifdef FRAME_NUM_ARGS_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "FRAME_NUM_ARGS_P()", + XSTRING (FRAME_NUM_ARGS_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: FRAME_NUM_ARGS_P() = %d\n", + FRAME_NUM_ARGS_P ()); +#endif +#ifdef FRAME_NUM_ARGS + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "FRAME_NUM_ARGS(frame)", + XSTRING (FRAME_NUM_ARGS (frame))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: FRAME_NUM_ARGS = <0x%08lx>\n", + (long) current_gdbarch->frame_num_args + /*FRAME_NUM_ARGS ()*/); +#endif +#ifdef FUNCTION_START_OFFSET + fprintf_unfiltered (file, + "gdbarch_dump: FUNCTION_START_OFFSET # %s\n", + XSTRING (FUNCTION_START_OFFSET)); + fprintf_unfiltered (file, + "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n", + (long) FUNCTION_START_OFFSET); +#endif +#ifdef GET_LONGJMP_TARGET_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "GET_LONGJMP_TARGET_P()", + XSTRING (GET_LONGJMP_TARGET_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: GET_LONGJMP_TARGET_P() = %d\n", + GET_LONGJMP_TARGET_P ()); +#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 HAVE_NONSTEPPABLE_WATCHPOINT + fprintf_unfiltered (file, + "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n", + XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT)); + fprintf_unfiltered (file, + "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n", + HAVE_NONSTEPPABLE_WATCHPOINT); +#endif +#ifdef INNER_THAN + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "INNER_THAN(lhs, rhs)", + XSTRING (INNER_THAN (lhs, rhs))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: INNER_THAN = <0x%08lx>\n", + (long) current_gdbarch->inner_than + /*INNER_THAN ()*/); +#endif +#ifdef INTEGER_TO_ADDRESS_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "INTEGER_TO_ADDRESS_P()", + XSTRING (INTEGER_TO_ADDRESS_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: INTEGER_TO_ADDRESS_P() = %d\n", + INTEGER_TO_ADDRESS_P ()); +#endif +#ifdef INTEGER_TO_ADDRESS + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "INTEGER_TO_ADDRESS(type, buf)", + XSTRING (INTEGER_TO_ADDRESS (type, buf))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: INTEGER_TO_ADDRESS = <0x%08lx>\n", + (long) current_gdbarch->integer_to_address + /*INTEGER_TO_ADDRESS ()*/); +#endif +#ifdef IN_SOLIB_CALL_TRAMPOLINE + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "IN_SOLIB_CALL_TRAMPOLINE(pc, name)", + XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc, name))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = <0x%08lx>\n", + (long) current_gdbarch->in_solib_call_trampoline + /*IN_SOLIB_CALL_TRAMPOLINE ()*/); +#endif +#ifdef IN_SOLIB_RETURN_TRAMPOLINE + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)", + XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = <0x%08lx>\n", + (long) current_gdbarch->in_solib_return_trampoline + /*IN_SOLIB_RETURN_TRAMPOLINE ()*/); +#endif +#ifdef MEMORY_INSERT_BREAKPOINT fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)", XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n", + "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = <0x%08lx>\n", (long) current_gdbarch->memory_insert_breakpoint /*MEMORY_INSERT_BREAKPOINT ()*/); #endif @@ -1432,10 +1930,18 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n", + "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = <0x%08lx>\n", (long) current_gdbarch->memory_remove_breakpoint /*MEMORY_REMOVE_BREAKPOINT ()*/); #endif +#ifdef NAME_OF_MALLOC + fprintf_unfiltered (file, + "gdbarch_dump: NAME_OF_MALLOC # %s\n", + XSTRING (NAME_OF_MALLOC)); + fprintf_unfiltered (file, + "gdbarch_dump: NAME_OF_MALLOC = %s\n", + NAME_OF_MALLOC); +#endif #ifdef NPC_REGNUM fprintf_unfiltered (file, "gdbarch_dump: NPC_REGNUM # %s\n", @@ -1468,17 +1974,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: PARM_BOUNDARY = %d\n", PARM_BOUNDARY); #endif -#ifdef PC_IN_CALL_DUMMY - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "PC_IN_CALL_DUMMY(pc, sp, frame_address)", - XSTRING (PC_IN_CALL_DUMMY (pc, sp, frame_address))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: PC_IN_CALL_DUMMY = 0x%08lx\n", - (long) current_gdbarch->pc_in_call_dummy - /*PC_IN_CALL_DUMMY ()*/); -#endif #ifdef PC_IN_SIGTRAMP fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1486,7 +1981,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (PC_IN_SIGTRAMP (pc, name))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: PC_IN_SIGTRAMP = 0x%08lx\n", + "gdbarch_dump: PC_IN_SIGTRAMP = <0x%08lx>\n", (long) current_gdbarch->pc_in_sigtramp /*PC_IN_SIGTRAMP ()*/); #endif @@ -1505,24 +2000,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (POINTER_TO_ADDRESS (type, buf))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: POINTER_TO_ADDRESS = 0x%08lx\n", + "gdbarch_dump: POINTER_TO_ADDRESS = <0x%08lx>\n", (long) current_gdbarch->pointer_to_address /*POINTER_TO_ADDRESS ()*/); #endif -#ifdef POP_FRAME -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "POP_FRAME(-)", - XSTRING (POP_FRAME (-))); -#endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: POP_FRAME = 0x%08lx\n", - (long) current_gdbarch->pop_frame - /*POP_FRAME ()*/); -#endif #ifdef PREPARE_TO_PROCEED fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1530,24 +2011,30 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (PREPARE_TO_PROCEED (select_it))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: PREPARE_TO_PROCEED = 0x%08lx\n", + "gdbarch_dump: PREPARE_TO_PROCEED = <0x%08lx>\n", (long) current_gdbarch->prepare_to_proceed /*PREPARE_TO_PROCEED ()*/); -#endif -#ifdef PRINT_FLOAT_INFO -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "PRINT_FLOAT_INFO()", - XSTRING (PRINT_FLOAT_INFO ())); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: PRINT_FLOAT_INFO = 0x%08lx\n", - (long) current_gdbarch->print_float_info - /*PRINT_FLOAT_INFO ()*/); -#endif + "gdbarch_dump: gdbarch_print_float_info_p() = %d\n", + gdbarch_print_float_info_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: print_float_info = 0x%08lx\n", + (long) current_gdbarch->print_float_info); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: print_registers_info = 0x%08lx\n", + (long) current_gdbarch->print_registers_info); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n", + gdbarch_print_vector_info_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: print_vector_info = 0x%08lx\n", + (long) current_gdbarch->print_vector_info); #ifdef PROLOGUE_FRAMELESS_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1555,7 +2042,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (PROLOGUE_FRAMELESS_P (ip))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: PROLOGUE_FRAMELESS_P = 0x%08lx\n", + "gdbarch_dump: PROLOGUE_FRAMELESS_P = <0x%08lx>\n", (long) current_gdbarch->prologue_frameless_p /*PROLOGUE_FRAMELESS_P ()*/); #endif @@ -1567,41 +2054,30 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: PS_REGNUM = %d\n", PS_REGNUM); #endif -#ifdef PUSH_ARGUMENTS - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)", - XSTRING (PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: PUSH_ARGUMENTS = 0x%08lx\n", - (long) current_gdbarch->push_arguments - /*PUSH_ARGUMENTS ()*/); -#endif -#ifdef PUSH_DUMMY_FRAME -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "PUSH_DUMMY_FRAME(-)", - XSTRING (PUSH_DUMMY_FRAME (-))); -#endif + "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n", + gdbarch_push_dummy_call_p (current_gdbarch)); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: PUSH_DUMMY_FRAME = 0x%08lx\n", - (long) current_gdbarch->push_dummy_frame - /*PUSH_DUMMY_FRAME ()*/); -#endif -#ifdef PUSH_RETURN_ADDRESS - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "PUSH_RETURN_ADDRESS(pc, sp)", - XSTRING (PUSH_RETURN_ADDRESS (pc, sp))); + "gdbarch_dump: push_dummy_call = 0x%08lx\n", + (long) current_gdbarch->push_dummy_call); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n", + gdbarch_push_dummy_code_p (current_gdbarch)); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: PUSH_RETURN_ADDRESS = 0x%08lx\n", - (long) current_gdbarch->push_return_address - /*PUSH_RETURN_ADDRESS ()*/); + "gdbarch_dump: push_dummy_code = 0x%08lx\n", + (long) current_gdbarch->push_dummy_code); +#ifdef REGISTER_BYTE_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "REGISTER_BYTE_P()", + XSTRING (REGISTER_BYTE_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: REGISTER_BYTE_P() = %d\n", + REGISTER_BYTE_P ()); #endif #ifdef REGISTER_BYTE fprintf_unfiltered (file, @@ -1610,17 +2086,18 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (REGISTER_BYTE (reg_nr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_BYTE = 0x%08lx\n", - (long) current_gdbarch->register_byte + "gdbarch_dump: REGISTER_BYTE = <0x%08lx>\n", + (long) current_gdbarch->deprecated_register_byte /*REGISTER_BYTE ()*/); #endif -#ifdef REGISTER_BYTES +#ifdef REGISTER_BYTES_OK_P fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_BYTES # %s\n", - XSTRING (REGISTER_BYTES)); + "gdbarch_dump: %s # %s\n", + "REGISTER_BYTES_OK_P()", + XSTRING (REGISTER_BYTES_OK_P ())); fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_BYTES = %d\n", - REGISTER_BYTES); + "gdbarch_dump: REGISTER_BYTES_OK_P() = %d\n", + REGISTER_BYTES_OK_P ()); #endif #ifdef REGISTER_BYTES_OK fprintf_unfiltered (file, @@ -1629,49 +2106,10 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (REGISTER_BYTES_OK (nr_bytes))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_BYTES_OK = 0x%08lx\n", + "gdbarch_dump: REGISTER_BYTES_OK = <0x%08lx>\n", (long) current_gdbarch->register_bytes_ok /*REGISTER_BYTES_OK ()*/); #endif -#ifdef REGISTER_CONVERTIBLE - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "REGISTER_CONVERTIBLE(nr)", - XSTRING (REGISTER_CONVERTIBLE (nr))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_CONVERTIBLE = 0x%08lx\n", - (long) current_gdbarch->register_convertible - /*REGISTER_CONVERTIBLE ()*/); -#endif -#ifdef REGISTER_CONVERT_TO_RAW -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)", - XSTRING (REGISTER_CONVERT_TO_RAW (type, regnum, from, to))); -#endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_CONVERT_TO_RAW = 0x%08lx\n", - (long) current_gdbarch->register_convert_to_raw - /*REGISTER_CONVERT_TO_RAW ()*/); -#endif -#ifdef REGISTER_CONVERT_TO_VIRTUAL -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)", - XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to))); -#endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n", - (long) current_gdbarch->register_convert_to_virtual - /*REGISTER_CONVERT_TO_VIRTUAL ()*/); -#endif #ifdef REGISTER_NAME fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1679,7 +2117,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (REGISTER_NAME (regnr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_NAME = 0x%08lx\n", + "gdbarch_dump: REGISTER_NAME = <0x%08lx>\n", (long) current_gdbarch->register_name /*REGISTER_NAME ()*/); #endif @@ -1690,8 +2128,8 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (REGISTER_RAW_SIZE (reg_nr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_RAW_SIZE = 0x%08lx\n", - (long) current_gdbarch->register_raw_size + "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n", + (long) current_gdbarch->deprecated_register_raw_size /*REGISTER_RAW_SIZE ()*/); #endif #ifdef REGISTER_SIM_REGNO @@ -1701,32 +2139,32 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (REGISTER_SIM_REGNO (reg_nr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_SIM_REGNO = 0x%08lx\n", + "gdbarch_dump: REGISTER_SIM_REGNO = <0x%08lx>\n", (long) current_gdbarch->register_sim_regno /*REGISTER_SIM_REGNO ()*/); #endif -#ifdef REGISTER_SIZE - fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_SIZE # %s\n", - XSTRING (REGISTER_SIZE)); - fprintf_unfiltered (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))); + "REGISTER_TO_VALUE(frame, regnum, type, buf)", + XSTRING (REGISTER_TO_VALUE (frame, regnum, type, buf))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_TO_VALUE = 0x%08lx\n", + "gdbarch_dump: REGISTER_TO_VALUE = <0x%08lx>\n", (long) current_gdbarch->register_to_value /*REGISTER_TO_VALUE ()*/); #endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_register_type_p() = %d\n", + gdbarch_register_type_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: register_type = 0x%08lx\n", + (long) current_gdbarch->register_type); #ifdef REGISTER_VIRTUAL_SIZE fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1734,10 +2172,19 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_VIRTUAL_SIZE = 0x%08lx\n", - (long) current_gdbarch->register_virtual_size + "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n", + (long) current_gdbarch->deprecated_register_virtual_size /*REGISTER_VIRTUAL_SIZE ()*/); #endif +#ifdef REGISTER_VIRTUAL_TYPE_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "REGISTER_VIRTUAL_TYPE_P()", + XSTRING (REGISTER_VIRTUAL_TYPE_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: REGISTER_VIRTUAL_TYPE_P() = %d\n", + REGISTER_VIRTUAL_TYPE_P ()); +#endif #ifdef REGISTER_VIRTUAL_TYPE fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1745,10 +2192,19 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_VIRTUAL_TYPE = 0x%08lx\n", - (long) current_gdbarch->register_virtual_type + "gdbarch_dump: REGISTER_VIRTUAL_TYPE = <0x%08lx>\n", + (long) current_gdbarch->deprecated_register_virtual_type /*REGISTER_VIRTUAL_TYPE ()*/); #endif +#ifdef REG_STRUCT_HAS_ADDR_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "REG_STRUCT_HAS_ADDR_P()", + XSTRING (REG_STRUCT_HAS_ADDR_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: REG_STRUCT_HAS_ADDR_P() = %d\n", + REG_STRUCT_HAS_ADDR_P ()); +#endif #ifdef REG_STRUCT_HAS_ADDR fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1756,24 +2212,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (REG_STRUCT_HAS_ADDR (gcc_p, type))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REG_STRUCT_HAS_ADDR = 0x%08lx\n", + "gdbarch_dump: REG_STRUCT_HAS_ADDR = <0x%08lx>\n", (long) current_gdbarch->reg_struct_has_addr /*REG_STRUCT_HAS_ADDR ()*/); -#endif -#ifdef REMOTE_TRANSLATE_XFER_ADDRESS -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)", - XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr, gdb_len, rem_addr, rem_len))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n", - (long) current_gdbarch->remote_translate_xfer_address - /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/); -#endif + "gdbarch_dump: remote_translate_xfer_address = 0x%08lx\n", + (long) current_gdbarch->remote_translate_xfer_address); #ifdef RETURN_VALUE_ON_STACK fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1781,20 +2227,18 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (RETURN_VALUE_ON_STACK (type))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: RETURN_VALUE_ON_STACK = 0x%08lx\n", + "gdbarch_dump: RETURN_VALUE_ON_STACK = <0x%08lx>\n", (long) current_gdbarch->return_value_on_stack /*RETURN_VALUE_ON_STACK ()*/); #endif -#ifdef SAVED_PC_AFTER_CALL +#ifdef SAVE_DUMMY_FRAME_TOS_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "SAVED_PC_AFTER_CALL(frame)", - XSTRING (SAVED_PC_AFTER_CALL (frame))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: SAVED_PC_AFTER_CALL = 0x%08lx\n", - (long) current_gdbarch->saved_pc_after_call - /*SAVED_PC_AFTER_CALL ()*/); + "SAVE_DUMMY_FRAME_TOS_P()", + XSTRING (SAVE_DUMMY_FRAME_TOS_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: SAVE_DUMMY_FRAME_TOS_P() = %d\n", + SAVE_DUMMY_FRAME_TOS_P ()); #endif #ifdef SAVE_DUMMY_FRAME_TOS #if GDB_MULTI_ARCH @@ -1806,7 +2250,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = 0x%08lx\n", + "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = <0x%08lx>\n", (long) current_gdbarch->save_dummy_frame_tos /*SAVE_DUMMY_FRAME_TOS ()*/); #endif @@ -1817,17 +2261,49 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (SDB_REG_TO_REGNUM (sdb_regnr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: SDB_REG_TO_REGNUM = 0x%08lx\n", + "gdbarch_dump: SDB_REG_TO_REGNUM = <0x%08lx>\n", (long) current_gdbarch->sdb_reg_to_regnum /*SDB_REG_TO_REGNUM ()*/); #endif -#ifdef SIZEOF_CALL_DUMMY_WORDS +#ifdef SIGTRAMP_END_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "SIGTRAMP_END_P()", + XSTRING (SIGTRAMP_END_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: SIGTRAMP_END_P() = %d\n", + SIGTRAMP_END_P ()); +#endif +#ifdef SIGTRAMP_END + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "SIGTRAMP_END(pc)", + XSTRING (SIGTRAMP_END (pc))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: SIGTRAMP_END = <0x%08lx>\n", + (long) current_gdbarch->sigtramp_end + /*SIGTRAMP_END ()*/); +#endif +#ifdef SIGTRAMP_START_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "SIGTRAMP_START_P()", + XSTRING (SIGTRAMP_START_P ())); fprintf_unfiltered (file, - "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n", - XSTRING (SIZEOF_CALL_DUMMY_WORDS)); + "gdbarch_dump: SIGTRAMP_START_P() = %d\n", + SIGTRAMP_START_P ()); +#endif +#ifdef SIGTRAMP_START fprintf_unfiltered (file, - "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n", - (long) SIZEOF_CALL_DUMMY_WORDS); + "gdbarch_dump: %s # %s\n", + "SIGTRAMP_START(pc)", + XSTRING (SIGTRAMP_START (pc))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: SIGTRAMP_START = <0x%08lx>\n", + (long) current_gdbarch->sigtramp_start + /*SIGTRAMP_START ()*/); #endif #ifdef SKIP_PROLOGUE fprintf_unfiltered (file, @@ -1836,7 +2312,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (SKIP_PROLOGUE (ip))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: SKIP_PROLOGUE = 0x%08lx\n", + "gdbarch_dump: SKIP_PROLOGUE = <0x%08lx>\n", (long) current_gdbarch->skip_prologue /*SKIP_PROLOGUE ()*/); #endif @@ -1847,7 +2323,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (SKIP_TRAMPOLINE_CODE (pc))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: SKIP_TRAMPOLINE_CODE = 0x%08lx\n", + "gdbarch_dump: SKIP_TRAMPOLINE_CODE = <0x%08lx>\n", (long) current_gdbarch->skip_trampoline_code /*SKIP_TRAMPOLINE_CODE ()*/); #endif @@ -1858,10 +2334,19 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (SMASH_TEXT_ADDRESS (addr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: SMASH_TEXT_ADDRESS = 0x%08lx\n", + "gdbarch_dump: SMASH_TEXT_ADDRESS = <0x%08lx>\n", (long) current_gdbarch->smash_text_address /*SMASH_TEXT_ADDRESS ()*/); #endif +#ifdef SOFTWARE_SINGLE_STEP_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "SOFTWARE_SINGLE_STEP_P()", + XSTRING (SOFTWARE_SINGLE_STEP_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: SOFTWARE_SINGLE_STEP_P() = %d\n", + SOFTWARE_SINGLE_STEP_P ()); +#endif #ifdef SOFTWARE_SINGLE_STEP #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ @@ -1872,7 +2357,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: SOFTWARE_SINGLE_STEP = 0x%08lx\n", + "gdbarch_dump: SOFTWARE_SINGLE_STEP = <0x%08lx>\n", (long) current_gdbarch->software_single_step /*SOFTWARE_SINGLE_STEP ()*/); #endif @@ -1891,10 +2376,19 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (STAB_REG_TO_REGNUM (stab_regnr))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: STAB_REG_TO_REGNUM = 0x%08lx\n", + "gdbarch_dump: STAB_REG_TO_REGNUM = <0x%08lx>\n", (long) current_gdbarch->stab_reg_to_regnum /*STAB_REG_TO_REGNUM ()*/); #endif +#ifdef STACK_ALIGN_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "STACK_ALIGN_P()", + XSTRING (STACK_ALIGN_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: STACK_ALIGN_P() = %d\n", + STACK_ALIGN_P ()); +#endif #ifdef STACK_ALIGN fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1902,52 +2396,24 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (STACK_ALIGN (sp))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: STACK_ALIGN = 0x%08lx\n", + "gdbarch_dump: STACK_ALIGN = <0x%08lx>\n", (long) current_gdbarch->stack_align /*STACK_ALIGN ()*/); #endif -#ifdef STORE_PSEUDO_REGISTER -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "STORE_PSEUDO_REGISTER(regnum)", - XSTRING (STORE_PSEUDO_REGISTER (regnum))); -#endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: STORE_PSEUDO_REGISTER = 0x%08lx\n", - (long) current_gdbarch->store_pseudo_register - /*STORE_PSEUDO_REGISTER ()*/); -#endif #ifdef STORE_RETURN_VALUE #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "STORE_RETURN_VALUE(type, valbuf)", - XSTRING (STORE_RETURN_VALUE (type, valbuf))); + "STORE_RETURN_VALUE(type, regcache, valbuf)", + XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: STORE_RETURN_VALUE = 0x%08lx\n", + "gdbarch_dump: STORE_RETURN_VALUE = <0x%08lx>\n", (long) current_gdbarch->store_return_value /*STORE_RETURN_VALUE ()*/); #endif -#ifdef STORE_STRUCT_RETURN -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "STORE_STRUCT_RETURN(addr, sp)", - XSTRING (STORE_STRUCT_RETURN (addr, sp))); -#endif - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: STORE_STRUCT_RETURN = 0x%08lx\n", - (long) current_gdbarch->store_struct_return - /*STORE_STRUCT_RETURN ()*/); -#endif #ifdef TARGET_ADDR_BIT fprintf_unfiltered (file, "gdbarch_dump: TARGET_ADDR_BIT # %s\n", @@ -2002,8 +2468,8 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n", XSTRING (TARGET_DOUBLE_FORMAT)); fprintf_unfiltered (file, - "gdbarch_dump: TARGET_DOUBLE_FORMAT = %ld\n", - (long) TARGET_DOUBLE_FORMAT); + "gdbarch_dump: TARGET_DOUBLE_FORMAT = %s\n", + (TARGET_DOUBLE_FORMAT)->name); #endif #ifdef TARGET_FLOAT_BIT fprintf_unfiltered (file, @@ -2018,8 +2484,8 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n", XSTRING (TARGET_FLOAT_FORMAT)); fprintf_unfiltered (file, - "gdbarch_dump: TARGET_FLOAT_FORMAT = %ld\n", - (long) TARGET_FLOAT_FORMAT); + "gdbarch_dump: TARGET_FLOAT_FORMAT = %s\n", + (TARGET_FLOAT_FORMAT)->name); #endif #ifdef TARGET_INT_BIT fprintf_unfiltered (file, @@ -2050,8 +2516,8 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n", XSTRING (TARGET_LONG_DOUBLE_FORMAT)); fprintf_unfiltered (file, - "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %ld\n", - (long) TARGET_LONG_DOUBLE_FORMAT); + "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %s\n", + (TARGET_LONG_DOUBLE_FORMAT)->name); #endif #ifdef TARGET_LONG_LONG_BIT fprintf_unfiltered (file, @@ -2061,6 +2527,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: TARGET_LONG_LONG_BIT = %d\n", TARGET_LONG_LONG_BIT); #endif +#ifdef TARGET_OSABI + fprintf_unfiltered (file, + "gdbarch_dump: TARGET_OSABI # %s\n", + XSTRING (TARGET_OSABI)); + fprintf_unfiltered (file, + "gdbarch_dump: TARGET_OSABI = %ld\n", + (long) TARGET_OSABI); +#endif #ifdef TARGET_PRINT_INSN fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -2068,7 +2542,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (TARGET_PRINT_INSN (vma, info))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: TARGET_PRINT_INSN = 0x%08lx\n", + "gdbarch_dump: TARGET_PRINT_INSN = <0x%08lx>\n", (long) current_gdbarch->print_insn /*TARGET_PRINT_INSN ()*/); #endif @@ -2080,16 +2554,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: TARGET_PTR_BIT = %d\n", TARGET_PTR_BIT); #endif -#ifdef TARGET_READ_FP +#ifdef TARGET_READ_PC_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "TARGET_READ_FP()", - XSTRING (TARGET_READ_FP ())); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: TARGET_READ_FP = 0x%08lx\n", - (long) current_gdbarch->read_fp - /*TARGET_READ_FP ()*/); + "TARGET_READ_PC_P()", + XSTRING (TARGET_READ_PC_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: TARGET_READ_PC_P() = %d\n", + TARGET_READ_PC_P ()); #endif #ifdef TARGET_READ_PC fprintf_unfiltered (file, @@ -2098,10 +2570,19 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (TARGET_READ_PC (ptid))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: TARGET_READ_PC = 0x%08lx\n", + "gdbarch_dump: TARGET_READ_PC = <0x%08lx>\n", (long) current_gdbarch->read_pc /*TARGET_READ_PC ()*/); #endif +#ifdef TARGET_READ_SP_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "TARGET_READ_SP_P()", + XSTRING (TARGET_READ_SP_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: TARGET_READ_SP_P() = %d\n", + TARGET_READ_SP_P ()); +#endif #ifdef TARGET_READ_SP fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -2109,7 +2590,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (TARGET_READ_SP ())); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: TARGET_READ_SP = 0x%08lx\n", + "gdbarch_dump: TARGET_READ_SP = <0x%08lx>\n", (long) current_gdbarch->read_sp /*TARGET_READ_SP ()*/); #endif @@ -2131,7 +2612,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = 0x%08lx\n", + "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = <0x%08lx>\n", (long) current_gdbarch->virtual_frame_pointer /*TARGET_VIRTUAL_FRAME_POINTER ()*/); #endif @@ -2145,32 +2626,34 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: TARGET_WRITE_PC = 0x%08lx\n", + "gdbarch_dump: TARGET_WRITE_PC = <0x%08lx>\n", (long) current_gdbarch->write_pc /*TARGET_WRITE_PC ()*/); -#endif -#ifdef TARGET_WRITE_SP -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "TARGET_WRITE_SP(val)", - XSTRING (TARGET_WRITE_SP (val))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: TARGET_WRITE_SP = 0x%08lx\n", - (long) current_gdbarch->write_sp - /*TARGET_WRITE_SP ()*/); -#endif -#ifdef USE_GENERIC_DUMMY_FRAMES - fprintf_unfiltered (file, - "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES # %s\n", - XSTRING (USE_GENERIC_DUMMY_FRAMES)); - fprintf_unfiltered (file, - "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES = %d\n", - USE_GENERIC_DUMMY_FRAMES); -#endif + "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n", + gdbarch_unwind_dummy_id_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: unwind_dummy_id = 0x%08lx\n", + (long) current_gdbarch->unwind_dummy_id); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n", + gdbarch_unwind_pc_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: unwind_pc = 0x%08lx\n", + (long) current_gdbarch->unwind_pc); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: gdbarch_unwind_sp_p() = %d\n", + gdbarch_unwind_sp_p (current_gdbarch)); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: unwind_sp = 0x%08lx\n", + (long) current_gdbarch->unwind_sp); #ifdef USE_STRUCT_CONVENTION fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -2178,7 +2661,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) XSTRING (USE_STRUCT_CONVENTION (gcc_p, value_type))); if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: USE_STRUCT_CONVENTION = 0x%08lx\n", + "gdbarch_dump: USE_STRUCT_CONVENTION = <0x%08lx>\n", (long) current_gdbarch->use_struct_convention /*USE_STRUCT_CONVENTION ()*/); #endif @@ -2187,12 +2670,12 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) /* 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))); + "VALUE_TO_REGISTER(frame, regnum, type, buf)", + XSTRING (VALUE_TO_REGISTER (frame, regnum, type, buf))); #endif if (GDB_MULTI_ARCH) fprintf_unfiltered (file, - "gdbarch_dump: VALUE_TO_REGISTER = 0x%08lx\n", + "gdbarch_dump: VALUE_TO_REGISTER = <0x%08lx>\n", (long) current_gdbarch->value_to_register /*VALUE_TO_REGISTER ()*/); #endif @@ -2223,8 +2706,17 @@ 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; + fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n"); + return gdbarch->byte_order; +} + +enum gdb_osabi +gdbarch_osabi (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n"); + return gdbarch->osabi; } int @@ -2418,6 +2910,13 @@ set_gdbarch_char_signed (struct gdbarch *gdbarch, gdbarch->char_signed = char_signed; } +int +gdbarch_read_pc_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->read_pc != 0; +} + CORE_ADDR gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid) { @@ -2456,23 +2955,11 @@ set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch->write_pc = write_pc; } -CORE_ADDR -gdbarch_read_fp (struct gdbarch *gdbarch) +int +gdbarch_read_sp_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->read_fp == 0) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_read_fp invalid"); - if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_read_fp called\n"); - return gdbarch->read_fp (); -} - -void -set_gdbarch_read_fp (struct gdbarch *gdbarch, - gdbarch_read_fp_ftype read_fp) -{ - gdbarch->read_fp = read_fp; + return gdbarch->read_sp != 0; } CORE_ADDR @@ -2494,25 +2981,6 @@ set_gdbarch_read_sp (struct gdbarch *gdbarch, gdbarch->read_sp = read_sp; } -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"); - if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_write_sp called\n"); - gdbarch->write_sp (val); -} - -void -set_gdbarch_write_sp (struct gdbarch *gdbarch, - gdbarch_write_sp_ftype write_sp) -{ - gdbarch->write_sp = write_sp; -} - void gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset) { @@ -2533,55 +3001,55 @@ set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, } int -gdbarch_register_read_p (struct gdbarch *gdbarch) +gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - return gdbarch->register_read != 0; + return gdbarch->pseudo_register_read != 0; } void -gdbarch_register_read (struct gdbarch *gdbarch, int regnum, char *buf) +gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, void *buf) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_read == 0) + if (gdbarch->pseudo_register_read == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_read invalid"); + "gdbarch: gdbarch_pseudo_register_read invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_read called\n"); - gdbarch->register_read (gdbarch, regnum, buf); + fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n"); + gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf); } void -set_gdbarch_register_read (struct gdbarch *gdbarch, - gdbarch_register_read_ftype register_read) +set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch, + gdbarch_pseudo_register_read_ftype pseudo_register_read) { - gdbarch->register_read = register_read; + gdbarch->pseudo_register_read = pseudo_register_read; } int -gdbarch_register_write_p (struct gdbarch *gdbarch) +gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - return gdbarch->register_write != 0; + return gdbarch->pseudo_register_write != 0; } void -gdbarch_register_write (struct gdbarch *gdbarch, int regnum, char *buf) +gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const void *buf) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_write == 0) + if (gdbarch->pseudo_register_write == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_write invalid"); + "gdbarch: gdbarch_pseudo_register_write invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_write called\n"); - gdbarch->register_write (gdbarch, regnum, buf); + fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n"); + gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf); } void -set_gdbarch_register_write (struct gdbarch *gdbarch, - gdbarch_register_write_ftype register_write) +set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch, + gdbarch_pseudo_register_write_ftype pseudo_register_write) { - gdbarch->register_write = register_write; + gdbarch->pseudo_register_write = pseudo_register_write; } int @@ -2637,23 +3105,6 @@ set_gdbarch_sp_regnum (struct gdbarch *gdbarch, gdbarch->sp_regnum = sp_regnum; } -int -gdbarch_fp_regnum (struct gdbarch *gdbarch) -{ - 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; -} - -void -set_gdbarch_fp_regnum (struct gdbarch *gdbarch, - int fp_regnum) -{ - gdbarch->fp_regnum = fp_regnum; -} - int gdbarch_pc_regnum (struct gdbarch *gdbarch) { @@ -2817,7 +3268,7 @@ set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum; } -char * +const char * gdbarch_register_name (struct gdbarch *gdbarch, int regnr) { gdb_assert (gdbarch != NULL); @@ -2837,602 +3288,935 @@ set_gdbarch_register_name (struct gdbarch *gdbarch, } int -gdbarch_register_size (struct gdbarch *gdbarch) +gdbarch_register_type_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->register_type != 0; +} + +struct type * +gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_size == -1) + if (gdbarch->register_type == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_size invalid"); + "gdbarch: gdbarch_register_type invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n"); - return gdbarch->register_size; + fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n"); + return gdbarch->register_type (gdbarch, reg_nr); } void -set_gdbarch_register_size (struct gdbarch *gdbarch, - int register_size) +set_gdbarch_register_type (struct gdbarch *gdbarch, + gdbarch_register_type_ftype register_type) { - gdbarch->register_size = register_size; + gdbarch->register_type = register_type; } int -gdbarch_register_bytes (struct gdbarch *gdbarch) +gdbarch_deprecated_register_virtual_type_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_register_virtual_type != 0; +} + +struct type * +gdbarch_deprecated_register_virtual_type (struct gdbarch *gdbarch, int reg_nr) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_bytes == -1) + if (gdbarch->deprecated_register_virtual_type == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_bytes invalid"); + "gdbarch: gdbarch_deprecated_register_virtual_type invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_virtual_type called\n"); + return gdbarch->deprecated_register_virtual_type (reg_nr); +} + +void +set_gdbarch_deprecated_register_virtual_type (struct gdbarch *gdbarch, + gdbarch_deprecated_register_virtual_type_ftype deprecated_register_virtual_type) +{ + gdbarch->deprecated_register_virtual_type = deprecated_register_virtual_type; +} + +int +gdbarch_deprecated_register_bytes (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes called\n"); - return gdbarch->register_bytes; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_bytes called\n"); + return gdbarch->deprecated_register_bytes; } void -set_gdbarch_register_bytes (struct gdbarch *gdbarch, - int register_bytes) +set_gdbarch_deprecated_register_bytes (struct gdbarch *gdbarch, + int deprecated_register_bytes) +{ + gdbarch->deprecated_register_bytes = deprecated_register_bytes; +} + +int +gdbarch_deprecated_register_byte_p (struct gdbarch *gdbarch) { - gdbarch->register_bytes = register_bytes; + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_register_byte != generic_register_byte; } int -gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr) +gdbarch_deprecated_register_byte (struct gdbarch *gdbarch, int reg_nr) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_byte == 0) + if (gdbarch->deprecated_register_byte == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_byte invalid"); + "gdbarch: gdbarch_deprecated_register_byte invalid"); + /* Ignore predicate (gdbarch->deprecated_register_byte != generic_register_byte). */ if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_byte called\n"); - return gdbarch->register_byte (reg_nr); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_byte called\n"); + return gdbarch->deprecated_register_byte (reg_nr); } void -set_gdbarch_register_byte (struct gdbarch *gdbarch, - gdbarch_register_byte_ftype register_byte) +set_gdbarch_deprecated_register_byte (struct gdbarch *gdbarch, + gdbarch_deprecated_register_byte_ftype deprecated_register_byte) { - gdbarch->register_byte = register_byte; + gdbarch->deprecated_register_byte = deprecated_register_byte; } int -gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr) +gdbarch_deprecated_register_raw_size (struct gdbarch *gdbarch, int reg_nr) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_raw_size == 0) + if (gdbarch->deprecated_register_raw_size == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_raw_size invalid"); + "gdbarch: gdbarch_deprecated_register_raw_size invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_raw_size called\n"); - return gdbarch->register_raw_size (reg_nr); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_raw_size called\n"); + return gdbarch->deprecated_register_raw_size (reg_nr); } void -set_gdbarch_register_raw_size (struct gdbarch *gdbarch, - gdbarch_register_raw_size_ftype register_raw_size) +set_gdbarch_deprecated_register_raw_size (struct gdbarch *gdbarch, + gdbarch_deprecated_register_raw_size_ftype deprecated_register_raw_size) { - gdbarch->register_raw_size = register_raw_size; + gdbarch->deprecated_register_raw_size = deprecated_register_raw_size; } int -gdbarch_max_register_raw_size (struct gdbarch *gdbarch) +gdbarch_deprecated_register_virtual_size (struct gdbarch *gdbarch, int reg_nr) { gdb_assert (gdbarch != NULL); - if (gdbarch->max_register_raw_size == -1) + if (gdbarch->deprecated_register_virtual_size == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_max_register_raw_size invalid"); + "gdbarch: gdbarch_deprecated_register_virtual_size invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_virtual_size called\n"); + return gdbarch->deprecated_register_virtual_size (reg_nr); +} + +void +set_gdbarch_deprecated_register_virtual_size (struct gdbarch *gdbarch, + gdbarch_deprecated_register_virtual_size_ftype deprecated_register_virtual_size) +{ + gdbarch->deprecated_register_virtual_size = deprecated_register_virtual_size; +} + +int +gdbarch_deprecated_max_register_raw_size_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_max_register_raw_size != 0; +} + +int +gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_max_register_raw_size called\n"); + return gdbarch->deprecated_max_register_raw_size; +} + +void +set_gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarch, + int deprecated_max_register_raw_size) +{ + gdbarch->deprecated_max_register_raw_size = deprecated_max_register_raw_size; +} + +int +gdbarch_deprecated_max_register_virtual_size_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_max_register_virtual_size != 0; +} + +int +gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_raw_size called\n"); - return gdbarch->max_register_raw_size; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_max_register_virtual_size called\n"); + return gdbarch->deprecated_max_register_virtual_size; } void -set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch, - int max_register_raw_size) +set_gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch, + int deprecated_max_register_virtual_size) { - gdbarch->max_register_raw_size = max_register_raw_size; + gdbarch->deprecated_max_register_virtual_size = deprecated_max_register_virtual_size; } int -gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr) +gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->unwind_dummy_id != 0; +} + +struct frame_id +gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_virtual_size == 0) + if (gdbarch->unwind_dummy_id == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_virtual_size invalid"); + "gdbarch: gdbarch_unwind_dummy_id invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_size called\n"); - return gdbarch->register_virtual_size (reg_nr); + fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n"); + return gdbarch->unwind_dummy_id (gdbarch, info); } void -set_gdbarch_register_virtual_size (struct gdbarch *gdbarch, - gdbarch_register_virtual_size_ftype register_virtual_size) +set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, + gdbarch_unwind_dummy_id_ftype unwind_dummy_id) { - gdbarch->register_virtual_size = register_virtual_size; + gdbarch->unwind_dummy_id = unwind_dummy_id; } int -gdbarch_max_register_virtual_size (struct gdbarch *gdbarch) +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->max_register_virtual_size == -1) + if (gdbarch->save_dummy_frame_tos == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_max_register_virtual_size invalid"); + "gdbarch: gdbarch_save_dummy_frame_tos invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_virtual_size called\n"); - return gdbarch->max_register_virtual_size; + fprintf_unfiltered (gdb_stdlog, "gdbarch_save_dummy_frame_tos called\n"); + gdbarch->save_dummy_frame_tos (sp); } void -set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch, - int max_register_virtual_size) +set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, + gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos) { - gdbarch->max_register_virtual_size = max_register_virtual_size; + gdbarch->save_dummy_frame_tos = save_dummy_frame_tos; } -struct type * -gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr) +int +gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */ + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n"); + return gdbarch->deprecated_fp_regnum; +} + +void +set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch, + int deprecated_fp_regnum) +{ + gdbarch->deprecated_fp_regnum = deprecated_fp_regnum; +} + +int +gdbarch_deprecated_target_read_fp_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_target_read_fp != 0; +} + +CORE_ADDR +gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_virtual_type == 0) + if (gdbarch->deprecated_target_read_fp == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_virtual_type invalid"); + "gdbarch: gdbarch_deprecated_target_read_fp invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_type called\n"); - return gdbarch->register_virtual_type (reg_nr); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_target_read_fp called\n"); + return gdbarch->deprecated_target_read_fp (); } void -set_gdbarch_register_virtual_type (struct gdbarch *gdbarch, - gdbarch_register_virtual_type_ftype register_virtual_type) +set_gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch, + gdbarch_deprecated_target_read_fp_ftype deprecated_target_read_fp) { - gdbarch->register_virtual_type = register_virtual_type; + gdbarch->deprecated_target_read_fp = deprecated_target_read_fp; +} + +int +gdbarch_push_dummy_call_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->push_dummy_call != 0; +} + +CORE_ADDR +gdbarch_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->push_dummy_call == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_push_dummy_call invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n"); + return gdbarch->push_dummy_call (gdbarch, func_addr, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr); } void -gdbarch_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs) +set_gdbarch_push_dummy_call (struct gdbarch *gdbarch, + gdbarch_push_dummy_call_ftype push_dummy_call) +{ + gdbarch->push_dummy_call = push_dummy_call; +} + +int +gdbarch_deprecated_push_arguments_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->do_registers_info == 0) + return gdbarch->deprecated_push_arguments != 0; +} + +CORE_ADDR +gdbarch_deprecated_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->deprecated_push_arguments == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_do_registers_info invalid"); + "gdbarch: gdbarch_deprecated_push_arguments invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_do_registers_info called\n"); - gdbarch->do_registers_info (reg_nr, fpregs); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_arguments called\n"); + return gdbarch->deprecated_push_arguments (nargs, args, sp, struct_return, struct_addr); } void -set_gdbarch_do_registers_info (struct gdbarch *gdbarch, - gdbarch_do_registers_info_ftype do_registers_info) +set_gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch, + gdbarch_deprecated_push_arguments_ftype deprecated_push_arguments) +{ + gdbarch->deprecated_push_arguments = deprecated_push_arguments; +} + +int +gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch) { - gdbarch->do_registers_info = do_registers_info; + gdb_assert (gdbarch != NULL); + /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */ + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_generic_dummy_frames called\n"); + return gdbarch->deprecated_use_generic_dummy_frames; } void -gdbarch_print_float_info (struct gdbarch *gdbarch) +set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch, + int deprecated_use_generic_dummy_frames) +{ + gdbarch->deprecated_use_generic_dummy_frames = deprecated_use_generic_dummy_frames; +} + +int +gdbarch_deprecated_push_return_address_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->print_float_info == 0) + return gdbarch->deprecated_push_return_address != 0; +} + +CORE_ADDR +gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->deprecated_push_return_address == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_print_float_info invalid"); + "gdbarch: gdbarch_deprecated_push_return_address invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n"); - gdbarch->print_float_info (); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_return_address called\n"); + return gdbarch->deprecated_push_return_address (pc, sp); } void -set_gdbarch_print_float_info (struct gdbarch *gdbarch, - gdbarch_print_float_info_ftype print_float_info) +set_gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch, + gdbarch_deprecated_push_return_address_ftype deprecated_push_return_address) { - gdbarch->print_float_info = print_float_info; + gdbarch->deprecated_push_return_address = deprecated_push_return_address; } int -gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr) +gdbarch_deprecated_dummy_write_sp_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_sim_regno == 0) + return gdbarch->deprecated_dummy_write_sp != 0; +} + +void +gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch, CORE_ADDR val) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->deprecated_dummy_write_sp == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_sim_regno invalid"); + "gdbarch: gdbarch_deprecated_dummy_write_sp invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n"); - return gdbarch->register_sim_regno (reg_nr); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_dummy_write_sp called\n"); + gdbarch->deprecated_dummy_write_sp (val); } void -set_gdbarch_register_sim_regno (struct gdbarch *gdbarch, - gdbarch_register_sim_regno_ftype register_sim_regno) +set_gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch, + gdbarch_deprecated_dummy_write_sp_ftype deprecated_dummy_write_sp) { - gdbarch->register_sim_regno = register_sim_regno; + gdbarch->deprecated_dummy_write_sp = deprecated_dummy_write_sp; } int -gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch) +gdbarch_deprecated_register_size (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - return gdbarch->register_bytes_ok != 0; + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n"); + return gdbarch->deprecated_register_size; +} + +void +set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch, + int deprecated_register_size) +{ + gdbarch->deprecated_register_size = deprecated_register_size; } int -gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes) +gdbarch_call_dummy_location (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_bytes_ok == 0) + /* Skip verify of call_dummy_location, invalid_p == 0 */ + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n"); + return gdbarch->call_dummy_location; +} + +void +set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, + int call_dummy_location) +{ + gdbarch->call_dummy_location = call_dummy_location; +} + +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_register_bytes_ok invalid"); + "gdbarch: gdbarch_call_dummy_address invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n"); - return gdbarch->register_bytes_ok (nr_bytes); + fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_address called\n"); + return gdbarch->call_dummy_address (); } void -set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch, - gdbarch_register_bytes_ok_ftype register_bytes_ok) +set_gdbarch_call_dummy_address (struct gdbarch *gdbarch, + gdbarch_call_dummy_address_ftype call_dummy_address) { - gdbarch->register_bytes_ok = register_bytes_ok; + gdbarch->call_dummy_address = call_dummy_address; +} + +CORE_ADDR +gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_start_offset called\n"); + return gdbarch->deprecated_call_dummy_start_offset; +} + +void +set_gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch, + CORE_ADDR deprecated_call_dummy_start_offset) +{ + gdbarch->deprecated_call_dummy_start_offset = deprecated_call_dummy_start_offset; +} + +CORE_ADDR +gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_breakpoint_offset called\n"); + return gdbarch->deprecated_call_dummy_breakpoint_offset; +} + +void +set_gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, + CORE_ADDR deprecated_call_dummy_breakpoint_offset) +{ + gdbarch->deprecated_call_dummy_breakpoint_offset = deprecated_call_dummy_breakpoint_offset; } int -gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum) +gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->cannot_fetch_register == 0) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_cannot_fetch_register invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n"); - return gdbarch->cannot_fetch_register (regnum); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_length called\n"); + return gdbarch->deprecated_call_dummy_length; +} + +void +set_gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch, + int deprecated_call_dummy_length) +{ + gdbarch->deprecated_call_dummy_length = deprecated_call_dummy_length; +} + +LONGEST * +gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */ + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_words called\n"); + return gdbarch->deprecated_call_dummy_words; } void -set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, - gdbarch_cannot_fetch_register_ftype cannot_fetch_register) +set_gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch, + LONGEST * deprecated_call_dummy_words) { - gdbarch->cannot_fetch_register = cannot_fetch_register; + gdbarch->deprecated_call_dummy_words = deprecated_call_dummy_words; } int -gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum) +gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->cannot_store_register == 0) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_cannot_store_register invalid"); + /* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */ if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n"); - return gdbarch->cannot_store_register (regnum); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_sizeof_call_dummy_words called\n"); + return gdbarch->deprecated_sizeof_call_dummy_words; } void -set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, - gdbarch_cannot_store_register_ftype cannot_store_register) +set_gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch, + int deprecated_sizeof_call_dummy_words) { - gdbarch->cannot_store_register = cannot_store_register; + gdbarch->deprecated_sizeof_call_dummy_words = deprecated_sizeof_call_dummy_words; } int -gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch) +gdbarch_deprecated_call_dummy_stack_adjust_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - return gdbarch->get_longjmp_target != 0; + return gdbarch->deprecated_call_dummy_stack_adjust != 0; } int -gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc) +gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch) { 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); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_stack_adjust called\n"); + return gdbarch->deprecated_call_dummy_stack_adjust; } void -set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, - gdbarch_get_longjmp_target_ftype get_longjmp_target) +set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch, + int deprecated_call_dummy_stack_adjust) { - gdbarch->get_longjmp_target = get_longjmp_target; + gdbarch->deprecated_call_dummy_stack_adjust = deprecated_call_dummy_stack_adjust; } int -gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch) +gdbarch_deprecated_fix_call_dummy_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_fix_call_dummy != 0; +} + +void +gdbarch_deprecated_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->use_generic_dummy_frames == -1) + if (gdbarch->deprecated_fix_call_dummy == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_use_generic_dummy_frames invalid"); + "gdbarch: gdbarch_deprecated_fix_call_dummy invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_use_generic_dummy_frames called\n"); - return gdbarch->use_generic_dummy_frames; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fix_call_dummy called\n"); + gdbarch->deprecated_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p); } void -set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch, - int use_generic_dummy_frames) +set_gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch, + gdbarch_deprecated_fix_call_dummy_ftype deprecated_fix_call_dummy) { - gdbarch->use_generic_dummy_frames = use_generic_dummy_frames; + gdbarch->deprecated_fix_call_dummy = deprecated_fix_call_dummy; } int -gdbarch_call_dummy_location (struct gdbarch *gdbarch) +gdbarch_push_dummy_code_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->push_dummy_code != 0; +} + +CORE_ADDR +gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_location == 0) + if (gdbarch->push_dummy_code == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_location invalid"); + "gdbarch: gdbarch_push_dummy_code invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n"); - return gdbarch->call_dummy_location; + fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n"); + return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr); } void -set_gdbarch_call_dummy_location (struct gdbarch *gdbarch, - int call_dummy_location) +set_gdbarch_push_dummy_code (struct gdbarch *gdbarch, + gdbarch_push_dummy_code_ftype push_dummy_code) { - gdbarch->call_dummy_location = call_dummy_location; + gdbarch->push_dummy_code = push_dummy_code; } -CORE_ADDR -gdbarch_call_dummy_address (struct gdbarch *gdbarch) +int +gdbarch_deprecated_push_dummy_frame_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_address == 0) + return gdbarch->deprecated_push_dummy_frame != 0; +} + +void +gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->deprecated_push_dummy_frame == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_address invalid"); + "gdbarch: gdbarch_deprecated_push_dummy_frame invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_address called\n"); - return gdbarch->call_dummy_address (); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_dummy_frame called\n"); + gdbarch->deprecated_push_dummy_frame (); } void -set_gdbarch_call_dummy_address (struct gdbarch *gdbarch, - gdbarch_call_dummy_address_ftype call_dummy_address) +set_gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch, + gdbarch_deprecated_push_dummy_frame_ftype deprecated_push_dummy_frame) { - gdbarch->call_dummy_address = call_dummy_address; + gdbarch->deprecated_push_dummy_frame = deprecated_push_dummy_frame; } -CORE_ADDR -gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch) +int +gdbarch_deprecated_extra_stack_alignment_needed (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"); + /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */ if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_start_offset called\n"); - return gdbarch->call_dummy_start_offset; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extra_stack_alignment_needed called\n"); + return gdbarch->deprecated_extra_stack_alignment_needed; } void -set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch, - CORE_ADDR call_dummy_start_offset) +set_gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch, + int deprecated_extra_stack_alignment_needed) { - gdbarch->call_dummy_start_offset = call_dummy_start_offset; + gdbarch->deprecated_extra_stack_alignment_needed = deprecated_extra_stack_alignment_needed; } -CORE_ADDR -gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch) +int +gdbarch_deprecated_do_registers_info_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_do_registers_info != 0; +} + +void +gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1) + if (gdbarch->deprecated_do_registers_info == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_breakpoint_offset invalid"); + "gdbarch: gdbarch_deprecated_do_registers_info invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n"); - return gdbarch->call_dummy_breakpoint_offset; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_do_registers_info called\n"); + gdbarch->deprecated_do_registers_info (reg_nr, fpregs); } void -set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, - CORE_ADDR call_dummy_breakpoint_offset) +set_gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch, + gdbarch_deprecated_do_registers_info_ftype deprecated_do_registers_info) { - gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset; + gdbarch->deprecated_do_registers_info = deprecated_do_registers_info; } -int -gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch) +void +gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_breakpoint_offset_p == -1) + if (gdbarch->print_registers_info == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid"); + "gdbarch: gdbarch_print_registers_info invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset_p called\n"); - return gdbarch->call_dummy_breakpoint_offset_p; + fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n"); + gdbarch->print_registers_info (gdbarch, file, frame, regnum, all); } void -set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch, - int call_dummy_breakpoint_offset_p) +set_gdbarch_print_registers_info (struct gdbarch *gdbarch, + gdbarch_print_registers_info_ftype print_registers_info) { - gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p; + gdbarch->print_registers_info = print_registers_info; } int -gdbarch_call_dummy_length (struct gdbarch *gdbarch) +gdbarch_print_float_info_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->print_float_info != 0; +} + +void +gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_length == -1) + if (gdbarch->print_float_info == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_length invalid"); + "gdbarch: gdbarch_print_float_info invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n"); - return gdbarch->call_dummy_length; + fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n"); + gdbarch->print_float_info (gdbarch, file, frame, args); } void -set_gdbarch_call_dummy_length (struct gdbarch *gdbarch, - int call_dummy_length) +set_gdbarch_print_float_info (struct gdbarch *gdbarch, + gdbarch_print_float_info_ftype print_float_info) { - gdbarch->call_dummy_length = call_dummy_length; + gdbarch->print_float_info = print_float_info; } int -gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address) +gdbarch_print_vector_info_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->print_vector_info != 0; +} + +void +gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args) { gdb_assert (gdbarch != NULL); - if (gdbarch->pc_in_call_dummy == 0) + if (gdbarch->print_vector_info == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_pc_in_call_dummy invalid"); + "gdbarch: gdbarch_print_vector_info invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_call_dummy called\n"); - return gdbarch->pc_in_call_dummy (pc, sp, frame_address); + fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n"); + gdbarch->print_vector_info (gdbarch, file, frame, args); } void -set_gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, - gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy) +set_gdbarch_print_vector_info (struct gdbarch *gdbarch, + gdbarch_print_vector_info_ftype print_vector_info) { - gdbarch->pc_in_call_dummy = pc_in_call_dummy; + gdbarch->print_vector_info = print_vector_info; } int -gdbarch_call_dummy_p (struct gdbarch *gdbarch) +gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_p == -1) + if (gdbarch->register_sim_regno == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_p invalid"); + "gdbarch: gdbarch_register_sim_regno invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_p called\n"); - return gdbarch->call_dummy_p; + fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n"); + return gdbarch->register_sim_regno (reg_nr); } void -set_gdbarch_call_dummy_p (struct gdbarch *gdbarch, - int call_dummy_p) +set_gdbarch_register_sim_regno (struct gdbarch *gdbarch, + gdbarch_register_sim_regno_ftype register_sim_regno) { - gdbarch->call_dummy_p = call_dummy_p; + gdbarch->register_sim_regno = register_sim_regno; } -LONGEST * -gdbarch_call_dummy_words (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); - /* Skip verify of call_dummy_words, invalid_p == 0 */ + if (gdbarch->register_bytes_ok == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_register_bytes_ok invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n"); - return gdbarch->call_dummy_words; + fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n"); + return gdbarch->register_bytes_ok (nr_bytes); } void -set_gdbarch_call_dummy_words (struct gdbarch *gdbarch, - LONGEST * call_dummy_words) +set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch, + gdbarch_register_bytes_ok_ftype register_bytes_ok) { - gdbarch->call_dummy_words = call_dummy_words; + gdbarch->register_bytes_ok = register_bytes_ok; } int -gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch) +gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum) { gdb_assert (gdbarch != NULL); - /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */ + if (gdbarch->cannot_fetch_register == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_cannot_fetch_register invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n"); - return gdbarch->sizeof_call_dummy_words; + fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n"); + return gdbarch->cannot_fetch_register (regnum); } void -set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch, - int sizeof_call_dummy_words) +set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, + gdbarch_cannot_fetch_register_ftype cannot_fetch_register) { - gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words; + gdbarch->cannot_fetch_register = cannot_fetch_register; } int -gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch) +gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_stack_adjust_p == -1) + if (gdbarch->cannot_store_register == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_stack_adjust_p invalid"); + "gdbarch: gdbarch_cannot_store_register invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust_p called\n"); - return gdbarch->call_dummy_stack_adjust_p; + fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n"); + return gdbarch->cannot_store_register (regnum); } void -set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch, - int call_dummy_stack_adjust_p) +set_gdbarch_cannot_store_register (struct gdbarch *gdbarch, + gdbarch_cannot_store_register_ftype cannot_store_register) +{ + gdbarch->cannot_store_register = cannot_store_register; +} + +int +gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch) { - gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p; + gdb_assert (gdbarch != NULL); + return gdbarch->get_longjmp_target != 0; } int -gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch) +gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0) + if (gdbarch->get_longjmp_target == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_stack_adjust invalid"); + "gdbarch: gdbarch_get_longjmp_target invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust called\n"); - return gdbarch->call_dummy_stack_adjust; + fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n"); + return gdbarch->get_longjmp_target (pc); } void -set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch, - int call_dummy_stack_adjust) +set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch, + gdbarch_get_longjmp_target_ftype get_longjmp_target) { - gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust; + gdbarch->get_longjmp_target = get_longjmp_target; } -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) +int +gdbarch_deprecated_pc_in_call_dummy_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->fix_call_dummy == 0) + return gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy; +} + +int +gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->deprecated_pc_in_call_dummy == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_fix_call_dummy invalid"); + "gdbarch: gdbarch_deprecated_pc_in_call_dummy invalid"); + /* Ignore predicate (gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy). */ if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_fix_call_dummy called\n"); - gdbarch->fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pc_in_call_dummy called\n"); + return gdbarch->deprecated_pc_in_call_dummy (pc, sp, frame_address); } void -set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch, - gdbarch_fix_call_dummy_ftype fix_call_dummy) +set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, + gdbarch_deprecated_pc_in_call_dummy_ftype deprecated_pc_in_call_dummy) { - gdbarch->fix_call_dummy = fix_call_dummy; + gdbarch->deprecated_pc_in_call_dummy = deprecated_pc_in_call_dummy; } -void -gdbarch_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev) +int +gdbarch_deprecated_init_frame_pc_first_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_init_frame_pc_first != 0; +} + +CORE_ADDR +gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev) { gdb_assert (gdbarch != NULL); - if (gdbarch->init_frame_pc_first == 0) + if (gdbarch->deprecated_init_frame_pc_first == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_init_frame_pc_first invalid"); + "gdbarch: gdbarch_deprecated_init_frame_pc_first invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_init_frame_pc_first called\n"); - gdbarch->init_frame_pc_first (fromleaf, prev); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc_first called\n"); + return gdbarch->deprecated_init_frame_pc_first (fromleaf, prev); } void -set_gdbarch_init_frame_pc_first (struct gdbarch *gdbarch, - gdbarch_init_frame_pc_first_ftype init_frame_pc_first) +set_gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, + gdbarch_deprecated_init_frame_pc_first_ftype deprecated_init_frame_pc_first) { - gdbarch->init_frame_pc_first = init_frame_pc_first; + gdbarch->deprecated_init_frame_pc_first = deprecated_init_frame_pc_first; } -void -gdbarch_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev) +int +gdbarch_deprecated_init_frame_pc_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_init_frame_pc != 0; +} + +CORE_ADDR +gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev) { gdb_assert (gdbarch != NULL); - if (gdbarch->init_frame_pc == 0) + if (gdbarch->deprecated_init_frame_pc == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_init_frame_pc invalid"); + "gdbarch: gdbarch_deprecated_init_frame_pc invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_init_frame_pc called\n"); - gdbarch->init_frame_pc (fromleaf, prev); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc called\n"); + return gdbarch->deprecated_init_frame_pc (fromleaf, prev); } void -set_gdbarch_init_frame_pc (struct gdbarch *gdbarch, - gdbarch_init_frame_pc_ftype init_frame_pc) +set_gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch, + gdbarch_deprecated_init_frame_pc_ftype deprecated_init_frame_pc) { - gdbarch->init_frame_pc = init_frame_pc; + gdbarch->deprecated_init_frame_pc = deprecated_init_frame_pc; } int @@ -3468,102 +4252,90 @@ set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch, } int -gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, struct type *formal, struct type *actual) +gdbarch_deprecated_get_saved_register_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->coerce_float_to_double == 0) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_coerce_float_to_double invalid"); - if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_coerce_float_to_double called\n"); - return gdbarch->coerce_float_to_double (formal, actual); -} - -void -set_gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, - gdbarch_coerce_float_to_double_ftype coerce_float_to_double) -{ - gdbarch->coerce_float_to_double = coerce_float_to_double; + return gdbarch->deprecated_get_saved_register != 0; } 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) +gdbarch_deprecated_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) + if (gdbarch->deprecated_get_saved_register == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_get_saved_register invalid"); + "gdbarch: gdbarch_deprecated_get_saved_register invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_get_saved_register called\n"); - gdbarch->get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_get_saved_register called\n"); + gdbarch->deprecated_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval); } void -set_gdbarch_get_saved_register (struct gdbarch *gdbarch, - gdbarch_get_saved_register_ftype get_saved_register) +set_gdbarch_deprecated_get_saved_register (struct gdbarch *gdbarch, + gdbarch_deprecated_get_saved_register_ftype deprecated_get_saved_register) { - gdbarch->get_saved_register = get_saved_register; + gdbarch->deprecated_get_saved_register = deprecated_get_saved_register; } int -gdbarch_register_convertible (struct gdbarch *gdbarch, int nr) +gdbarch_deprecated_register_convertible (struct gdbarch *gdbarch, int nr) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_convertible == 0) + if (gdbarch->deprecated_register_convertible == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_convertible invalid"); + "gdbarch: gdbarch_deprecated_register_convertible invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convertible called\n"); - return gdbarch->register_convertible (nr); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_convertible called\n"); + return gdbarch->deprecated_register_convertible (nr); } void -set_gdbarch_register_convertible (struct gdbarch *gdbarch, - gdbarch_register_convertible_ftype register_convertible) +set_gdbarch_deprecated_register_convertible (struct gdbarch *gdbarch, + gdbarch_deprecated_register_convertible_ftype deprecated_register_convertible) { - gdbarch->register_convertible = register_convertible; + gdbarch->deprecated_register_convertible = deprecated_register_convertible; } void -gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to) +gdbarch_deprecated_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) + if (gdbarch->deprecated_register_convert_to_virtual == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_convert_to_virtual invalid"); + "gdbarch: gdbarch_deprecated_register_convert_to_virtual invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_virtual called\n"); - gdbarch->register_convert_to_virtual (regnum, type, from, to); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_convert_to_virtual called\n"); + gdbarch->deprecated_register_convert_to_virtual (regnum, type, from, to); } void -set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, - gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual) +set_gdbarch_deprecated_register_convert_to_virtual (struct gdbarch *gdbarch, + gdbarch_deprecated_register_convert_to_virtual_ftype deprecated_register_convert_to_virtual) { - gdbarch->register_convert_to_virtual = register_convert_to_virtual; + gdbarch->deprecated_register_convert_to_virtual = deprecated_register_convert_to_virtual; } void -gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to) +gdbarch_deprecated_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, const char *from, char *to) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_convert_to_raw == 0) + if (gdbarch->deprecated_register_convert_to_raw == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_convert_to_raw invalid"); + "gdbarch: gdbarch_deprecated_register_convert_to_raw invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_raw called\n"); - gdbarch->register_convert_to_raw (type, regnum, from, to); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_convert_to_raw called\n"); + gdbarch->deprecated_register_convert_to_raw (type, regnum, from, to); } void -set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, - gdbarch_register_convert_to_raw_ftype register_convert_to_raw) +set_gdbarch_deprecated_register_convert_to_raw (struct gdbarch *gdbarch, + gdbarch_deprecated_register_convert_to_raw_ftype deprecated_register_convert_to_raw) { - gdbarch->register_convert_to_raw = register_convert_to_raw; + gdbarch->deprecated_register_convert_to_raw = deprecated_register_convert_to_raw; } int -gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum) +gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type) { gdb_assert (gdbarch != NULL); if (gdbarch->convert_register_p == 0) @@ -3571,7 +4343,7 @@ gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum) "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); + return gdbarch->convert_register_p (regnum, type); } void @@ -3582,7 +4354,7 @@ set_gdbarch_convert_register_p (struct gdbarch *gdbarch, } void -gdbarch_register_to_value (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to) +gdbarch_register_to_value (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, void *buf) { gdb_assert (gdbarch != NULL); if (gdbarch->register_to_value == 0) @@ -3590,7 +4362,7 @@ gdbarch_register_to_value (struct gdbarch *gdbarch, int regnum, struct type *typ "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); + gdbarch->register_to_value (frame, regnum, type, buf); } void @@ -3601,7 +4373,7 @@ set_gdbarch_register_to_value (struct gdbarch *gdbarch, } void -gdbarch_value_to_register (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to) +gdbarch_value_to_register (struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const void *buf) { gdb_assert (gdbarch != NULL); if (gdbarch->value_to_register == 0) @@ -3609,7 +4381,7 @@ gdbarch_value_to_register (struct gdbarch *gdbarch, struct type *type, int regnu "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); + gdbarch->value_to_register (frame, regnum, type, buf); } void @@ -3619,60 +4391,8 @@ set_gdbarch_value_to_register (struct gdbarch *gdbarch, 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"); - if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pseudo_register called\n"); - gdbarch->fetch_pseudo_register (regnum); -} - -void -set_gdbarch_fetch_pseudo_register (struct gdbarch *gdbarch, - gdbarch_fetch_pseudo_register_ftype fetch_pseudo_register) -{ - gdbarch->fetch_pseudo_register = fetch_pseudo_register; -} - -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"); - if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_store_pseudo_register called\n"); - gdbarch->store_pseudo_register (regnum); -} - -void -set_gdbarch_store_pseudo_register (struct gdbarch *gdbarch, - gdbarch_store_pseudo_register_ftype store_pseudo_register) -{ - gdbarch->store_pseudo_register = store_pseudo_register; -} - CORE_ADDR -gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf) +gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const void *buf) { gdb_assert (gdbarch != NULL); if (gdbarch->pointer_to_address == 0) @@ -3754,170 +4474,184 @@ set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch, gdbarch->return_value_on_stack = return_value_on_stack; } +int +gdbarch_deprecated_pop_frame_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_pop_frame != 0; +} + void -gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf) +gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->extract_return_value == 0) + if (gdbarch->deprecated_pop_frame == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_extract_return_value invalid"); + "gdbarch: gdbarch_deprecated_pop_frame invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n"); - gdbarch->extract_return_value (type, regbuf, valbuf); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pop_frame called\n"); + gdbarch->deprecated_pop_frame (); } void -set_gdbarch_extract_return_value (struct gdbarch *gdbarch, - gdbarch_extract_return_value_ftype extract_return_value) +set_gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch, + gdbarch_deprecated_pop_frame_ftype deprecated_pop_frame) { - gdbarch->extract_return_value = extract_return_value; + gdbarch->deprecated_pop_frame = deprecated_pop_frame; } -CORE_ADDR -gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) +int +gdbarch_deprecated_store_struct_return_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_store_struct_return != 0; +} + +void +gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp) { gdb_assert (gdbarch != NULL); - if (gdbarch->push_arguments == 0) + if (gdbarch->deprecated_store_struct_return == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_push_arguments invalid"); + "gdbarch: gdbarch_deprecated_store_struct_return invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_push_arguments called\n"); - return gdbarch->push_arguments (nargs, args, sp, struct_return, struct_addr); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_struct_return called\n"); + gdbarch->deprecated_store_struct_return (addr, sp); } void -set_gdbarch_push_arguments (struct gdbarch *gdbarch, - gdbarch_push_arguments_ftype push_arguments) +set_gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, + gdbarch_deprecated_store_struct_return_ftype deprecated_store_struct_return) { - gdbarch->push_arguments = push_arguments; + gdbarch->deprecated_store_struct_return = deprecated_store_struct_return; } void -gdbarch_push_dummy_frame (struct gdbarch *gdbarch) +gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, void *valbuf) { gdb_assert (gdbarch != NULL); - if (gdbarch->push_dummy_frame == 0) + if (gdbarch->extract_return_value == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_push_dummy_frame invalid"); + "gdbarch: gdbarch_extract_return_value invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_frame called\n"); - gdbarch->push_dummy_frame (); + fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n"); + gdbarch->extract_return_value (type, regcache, valbuf); } void -set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch, - gdbarch_push_dummy_frame_ftype push_dummy_frame) -{ - gdbarch->push_dummy_frame = push_dummy_frame; -} - -int -gdbarch_push_return_address_p (struct gdbarch *gdbarch) +set_gdbarch_extract_return_value (struct gdbarch *gdbarch, + gdbarch_extract_return_value_ftype extract_return_value) { - gdb_assert (gdbarch != NULL); - return gdbarch->push_return_address != 0; + gdbarch->extract_return_value = extract_return_value; } -CORE_ADDR -gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp) +void +gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const void *valbuf) { gdb_assert (gdbarch != NULL); - if (gdbarch->push_return_address == 0) + if (gdbarch->store_return_value == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_push_return_address invalid"); + "gdbarch: gdbarch_store_return_value invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_push_return_address called\n"); - return gdbarch->push_return_address (pc, sp); + fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n"); + gdbarch->store_return_value (type, regcache, valbuf); } void -set_gdbarch_push_return_address (struct gdbarch *gdbarch, - gdbarch_push_return_address_ftype push_return_address) +set_gdbarch_store_return_value (struct gdbarch *gdbarch, + gdbarch_store_return_value_ftype store_return_value) { - gdbarch->push_return_address = push_return_address; + gdbarch->store_return_value = store_return_value; } void -gdbarch_pop_frame (struct gdbarch *gdbarch) +gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf) { gdb_assert (gdbarch != NULL); - if (gdbarch->pop_frame == 0) + if (gdbarch->deprecated_extract_return_value == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_pop_frame invalid"); + "gdbarch: gdbarch_deprecated_extract_return_value invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_pop_frame called\n"); - gdbarch->pop_frame (); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_return_value called\n"); + gdbarch->deprecated_extract_return_value (type, regbuf, valbuf); } void -set_gdbarch_pop_frame (struct gdbarch *gdbarch, - gdbarch_pop_frame_ftype pop_frame) +set_gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch, + gdbarch_deprecated_extract_return_value_ftype deprecated_extract_return_value) { - gdbarch->pop_frame = pop_frame; + gdbarch->deprecated_extract_return_value = deprecated_extract_return_value; } void -gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp) +gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf) { gdb_assert (gdbarch != NULL); - if (gdbarch->store_struct_return == 0) + if (gdbarch->deprecated_store_return_value == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_store_struct_return invalid"); + "gdbarch: gdbarch_deprecated_store_return_value invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_store_struct_return called\n"); - gdbarch->store_struct_return (addr, sp); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_return_value called\n"); + gdbarch->deprecated_store_return_value (type, valbuf); } void -set_gdbarch_store_struct_return (struct gdbarch *gdbarch, - gdbarch_store_struct_return_ftype store_struct_return) +set_gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch, + gdbarch_deprecated_store_return_value_ftype deprecated_store_return_value) { - gdbarch->store_struct_return = store_struct_return; + gdbarch->deprecated_store_return_value = deprecated_store_return_value; } -void -gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf) +int +gdbarch_extract_struct_value_address_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->store_return_value == 0) + return gdbarch->extract_struct_value_address != 0; +} + +CORE_ADDR +gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->extract_struct_value_address == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_store_return_value invalid"); + "gdbarch: gdbarch_extract_struct_value_address invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n"); - gdbarch->store_return_value (type, valbuf); + fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n"); + return gdbarch->extract_struct_value_address (regcache); } void -set_gdbarch_store_return_value (struct gdbarch *gdbarch, - gdbarch_store_return_value_ftype store_return_value) +set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, + gdbarch_extract_struct_value_address_ftype extract_struct_value_address) { - gdbarch->store_return_value = store_return_value; + gdbarch->extract_struct_value_address = extract_struct_value_address; } int -gdbarch_extract_struct_value_address_p (struct gdbarch *gdbarch) +gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - return gdbarch->extract_struct_value_address != 0; + return gdbarch->deprecated_extract_struct_value_address != 0; } CORE_ADDR -gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf) +gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf) { gdb_assert (gdbarch != NULL); - if (gdbarch->extract_struct_value_address == 0) + if (gdbarch->deprecated_extract_struct_value_address == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_extract_struct_value_address invalid"); + "gdbarch: gdbarch_deprecated_extract_struct_value_address invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n"); - return gdbarch->extract_struct_value_address (regbuf); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n"); + return gdbarch->deprecated_extract_struct_value_address (regbuf); } void -set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, - gdbarch_extract_struct_value_address_ftype extract_struct_value_address) +set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, + gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address) { - gdbarch->extract_struct_value_address = extract_struct_value_address; + gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address; } int @@ -3939,49 +4673,56 @@ set_gdbarch_use_struct_convention (struct gdbarch *gdbarch, gdbarch->use_struct_convention = use_struct_convention; } +int +gdbarch_deprecated_frame_init_saved_regs_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_frame_init_saved_regs != 0; +} + void -gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame) +gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame) { gdb_assert (gdbarch != NULL); - if (gdbarch->frame_init_saved_regs == 0) + if (gdbarch->deprecated_frame_init_saved_regs == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_frame_init_saved_regs invalid"); + "gdbarch: gdbarch_deprecated_frame_init_saved_regs invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_init_saved_regs called\n"); - gdbarch->frame_init_saved_regs (frame); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_init_saved_regs called\n"); + gdbarch->deprecated_frame_init_saved_regs (frame); } void -set_gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, - gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs) +set_gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch, + gdbarch_deprecated_frame_init_saved_regs_ftype deprecated_frame_init_saved_regs) { - gdbarch->frame_init_saved_regs = frame_init_saved_regs; + gdbarch->deprecated_frame_init_saved_regs = deprecated_frame_init_saved_regs; } int -gdbarch_init_extra_frame_info_p (struct gdbarch *gdbarch) +gdbarch_deprecated_init_extra_frame_info_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - return gdbarch->init_extra_frame_info != 0; + return gdbarch->deprecated_init_extra_frame_info != 0; } void -gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame) +gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame) { gdb_assert (gdbarch != NULL); - if (gdbarch->init_extra_frame_info == 0) + if (gdbarch->deprecated_init_extra_frame_info == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_init_extra_frame_info invalid"); + "gdbarch: gdbarch_deprecated_init_extra_frame_info invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_init_extra_frame_info called\n"); - gdbarch->init_extra_frame_info (fromleaf, frame); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_extra_frame_info called\n"); + gdbarch->deprecated_init_extra_frame_info (fromleaf, frame); } void -set_gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, - gdbarch_init_extra_frame_info_ftype init_extra_frame_info) +set_gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch, + gdbarch_deprecated_init_extra_frame_info_ftype deprecated_init_extra_frame_info) { - gdbarch->init_extra_frame_info = init_extra_frame_info; + gdbarch->deprecated_init_extra_frame_info = deprecated_init_extra_frame_info; } CORE_ADDR @@ -4156,7 +4897,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) +gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, struct regcache *regcache, 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) @@ -4164,7 +4905,7 @@ gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_ad "gdbarch: gdbarch_remote_translate_xfer_address invalid"); if (gdbarch_debug >= 2) fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n"); - gdbarch->remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len); + gdbarch->remote_translate_xfer_address (gdbarch, regcache, gdb_addr, gdb_len, rem_addr, rem_len); } void @@ -4212,61 +4953,134 @@ set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, gdbarch->frameless_function_invocation = frameless_function_invocation; } +int +gdbarch_deprecated_frame_chain_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_frame_chain != 0; +} + +CORE_ADDR +gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->deprecated_frame_chain == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_deprecated_frame_chain invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain called\n"); + return gdbarch->deprecated_frame_chain (frame); +} + +void +set_gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch, + gdbarch_deprecated_frame_chain_ftype deprecated_frame_chain) +{ + gdbarch->deprecated_frame_chain = deprecated_frame_chain; +} + +int +gdbarch_deprecated_frame_chain_valid_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_frame_chain_valid != 0; +} + +int +gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->deprecated_frame_chain_valid == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_deprecated_frame_chain_valid invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain_valid called\n"); + return gdbarch->deprecated_frame_chain_valid (chain, thisframe); +} + +void +set_gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch, + gdbarch_deprecated_frame_chain_valid_ftype deprecated_frame_chain_valid) +{ + gdbarch->deprecated_frame_chain_valid = deprecated_frame_chain_valid; +} + +int +gdbarch_deprecated_frame_saved_pc_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_frame_saved_pc != 0; +} + CORE_ADDR -gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame) +gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi) { gdb_assert (gdbarch != NULL); - if (gdbarch->frame_chain == 0) + if (gdbarch->deprecated_frame_saved_pc == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_frame_chain invalid"); + "gdbarch: gdbarch_deprecated_frame_saved_pc invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain called\n"); - return gdbarch->frame_chain (frame); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_saved_pc called\n"); + return gdbarch->deprecated_frame_saved_pc (fi); } void -set_gdbarch_frame_chain (struct gdbarch *gdbarch, - gdbarch_frame_chain_ftype frame_chain) +set_gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch, + gdbarch_deprecated_frame_saved_pc_ftype deprecated_frame_saved_pc) { - gdbarch->frame_chain = frame_chain; + gdbarch->deprecated_frame_saved_pc = deprecated_frame_saved_pc; } int -gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe) +gdbarch_unwind_pc_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->unwind_pc != 0; +} + +CORE_ADDR +gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) { gdb_assert (gdbarch != NULL); - if (gdbarch->frame_chain_valid == 0) + if (gdbarch->unwind_pc == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_frame_chain_valid invalid"); + "gdbarch: gdbarch_unwind_pc invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain_valid called\n"); - return gdbarch->frame_chain_valid (chain, thisframe); + fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n"); + return gdbarch->unwind_pc (gdbarch, next_frame); } void -set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch, - gdbarch_frame_chain_valid_ftype frame_chain_valid) +set_gdbarch_unwind_pc (struct gdbarch *gdbarch, + gdbarch_unwind_pc_ftype unwind_pc) +{ + gdbarch->unwind_pc = unwind_pc; +} + +int +gdbarch_unwind_sp_p (struct gdbarch *gdbarch) { - gdbarch->frame_chain_valid = frame_chain_valid; + gdb_assert (gdbarch != NULL); + return gdbarch->unwind_sp != 0; } CORE_ADDR -gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi) +gdbarch_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) { gdb_assert (gdbarch != NULL); - if (gdbarch->frame_saved_pc == 0) + if (gdbarch->unwind_sp == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_frame_saved_pc invalid"); + "gdbarch: gdbarch_unwind_sp invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_saved_pc called\n"); - return gdbarch->frame_saved_pc (fi); + fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_sp called\n"); + return gdbarch->unwind_sp (gdbarch, next_frame); } void -set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch, - gdbarch_frame_saved_pc_ftype frame_saved_pc) +set_gdbarch_unwind_sp (struct gdbarch *gdbarch, + gdbarch_unwind_sp_ftype unwind_sp) { - gdbarch->frame_saved_pc = frame_saved_pc; + gdbarch->unwind_sp = unwind_sp; } CORE_ADDR @@ -4307,23 +5121,37 @@ set_gdbarch_frame_locals_address (struct gdbarch *gdbarch, gdbarch->frame_locals_address = frame_locals_address; } +int +gdbarch_deprecated_saved_pc_after_call_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_saved_pc_after_call != 0; +} + CORE_ADDR -gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame) +gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame) { gdb_assert (gdbarch != NULL); - if (gdbarch->saved_pc_after_call == 0) + if (gdbarch->deprecated_saved_pc_after_call == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_saved_pc_after_call invalid"); + "gdbarch: gdbarch_deprecated_saved_pc_after_call invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_saved_pc_after_call called\n"); - return gdbarch->saved_pc_after_call (frame); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_saved_pc_after_call called\n"); + return gdbarch->deprecated_saved_pc_after_call (frame); } void -set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, - gdbarch_saved_pc_after_call_ftype saved_pc_after_call) +set_gdbarch_deprecated_saved_pc_after_call (struct gdbarch *gdbarch, + gdbarch_deprecated_saved_pc_after_call_ftype deprecated_saved_pc_after_call) +{ + gdbarch->deprecated_saved_pc_after_call = deprecated_saved_pc_after_call; +} + +int +gdbarch_frame_num_args_p (struct gdbarch *gdbarch) { - gdbarch->saved_pc_after_call = saved_pc_after_call; + gdb_assert (gdbarch != NULL); + return gdbarch->frame_num_args != 0; } int @@ -4372,20 +5200,29 @@ set_gdbarch_stack_align (struct gdbarch *gdbarch, } int -gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch) +gdbarch_frame_align_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->frame_align != 0; +} + +CORE_ADDR +gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address) { gdb_assert (gdbarch != NULL); - /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */ + if (gdbarch->frame_align == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_frame_align invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_extra_stack_alignment_needed called\n"); - return gdbarch->extra_stack_alignment_needed; + fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n"); + return gdbarch->frame_align (gdbarch, address); } void -set_gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch, - int extra_stack_alignment_needed) +set_gdbarch_frame_align (struct gdbarch *gdbarch, + gdbarch_frame_align_ftype frame_align) { - gdbarch->extra_stack_alignment_needed = extra_stack_alignment_needed; + gdbarch->frame_align = frame_align; } int @@ -4414,32 +5251,6 @@ set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, gdbarch->reg_struct_has_addr = reg_struct_has_addr; } -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"); - if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_save_dummy_frame_tos called\n"); - gdbarch->save_dummy_frame_tos (sp); -} - -void -set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, - gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos) -{ - gdbarch->save_dummy_frame_tos = save_dummy_frame_tos; -} - int gdbarch_parm_boundary (struct gdbarch *gdbarch) { @@ -4644,6 +5455,25 @@ set_gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, gdbarch->in_solib_call_trampoline = in_solib_call_trampoline; } +int +gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->in_solib_return_trampoline == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_in_solib_return_trampoline invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n"); + return gdbarch->in_solib_return_trampoline (pc, name); +} + +void +set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, + gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline) +{ + gdbarch->in_solib_return_trampoline = in_solib_return_trampoline; +} + int gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, char *name) { @@ -4663,6 +5493,58 @@ set_gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch, gdbarch->pc_in_sigtramp = pc_in_sigtramp; } +int +gdbarch_sigtramp_start_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->sigtramp_start != 0; +} + +CORE_ADDR +gdbarch_sigtramp_start (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->sigtramp_start == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_sigtramp_start invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_sigtramp_start called\n"); + return gdbarch->sigtramp_start (pc); +} + +void +set_gdbarch_sigtramp_start (struct gdbarch *gdbarch, + gdbarch_sigtramp_start_ftype sigtramp_start) +{ + gdbarch->sigtramp_start = sigtramp_start; +} + +int +gdbarch_sigtramp_end_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->sigtramp_end != 0; +} + +CORE_ADDR +gdbarch_sigtramp_end (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->sigtramp_end == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_sigtramp_end invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_sigtramp_end called\n"); + return gdbarch->sigtramp_end (pc); +} + +void +set_gdbarch_sigtramp_end (struct gdbarch *gdbarch, + gdbarch_sigtramp_end_ftype sigtramp_end) +{ + gdbarch->sigtramp_end = sigtramp_end; +} + int gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr) { @@ -4765,6 +5647,180 @@ set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, gdbarch->coff_make_msymbol_special = coff_make_msymbol_special; } +const char * +gdbarch_name_of_malloc (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + /* Skip verify of name_of_malloc, invalid_p == 0 */ + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n"); + return gdbarch->name_of_malloc; +} + +void +set_gdbarch_name_of_malloc (struct gdbarch *gdbarch, + const char * name_of_malloc) +{ + gdbarch->name_of_malloc = name_of_malloc; +} + +int +gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */ + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n"); + return gdbarch->cannot_step_breakpoint; +} + +void +set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch, + int cannot_step_breakpoint) +{ + gdbarch->cannot_step_breakpoint = cannot_step_breakpoint; +} + +int +gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */ + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n"); + return gdbarch->have_nonsteppable_watchpoint; +} + +void +set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch, + int have_nonsteppable_watchpoint) +{ + gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint; +} + +int +gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->address_class_type_flags != 0; +} + +int +gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->address_class_type_flags == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_address_class_type_flags invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n"); + return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class); +} + +void +set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch, + gdbarch_address_class_type_flags_ftype address_class_type_flags) +{ + gdbarch->address_class_type_flags = address_class_type_flags; +} + +int +gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->address_class_type_flags_to_name != 0; +} + +const char * +gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->address_class_type_flags_to_name == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_address_class_type_flags_to_name invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n"); + return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags); +} + +void +set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, + gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name) +{ + gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name; +} + +int +gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->address_class_name_to_type_flags != 0; +} + +int +gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->address_class_name_to_type_flags == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_address_class_name_to_type_flags invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n"); + return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr); +} + +void +set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, + gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags) +{ + gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags; +} + +int +gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->register_reggroup_p == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_register_reggroup_p invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n"); + return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup); +} + +void +set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, + gdbarch_register_reggroup_p_ftype register_reggroup_p) +{ + gdbarch->register_reggroup_p = register_reggroup_p; +} + +int +gdbarch_fetch_pointer_argument_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->fetch_pointer_argument != 0; +} + +CORE_ADDR +gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, struct frame_info *frame, int argi, struct type *type) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->fetch_pointer_argument == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_fetch_pointer_argument invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_fetch_pointer_argument called\n"); + return gdbarch->fetch_pointer_argument (frame, argi, type); +} + +void +set_gdbarch_fetch_pointer_argument (struct gdbarch *gdbarch, + gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument) +{ + gdbarch->fetch_pointer_argument = fetch_pointer_argument; +} + /* Keep a registry of per-architecture data-pointers required by GDB modules. */ @@ -5112,6 +6168,8 @@ gdbarch_list_lookup_by_info (struct gdbarch_list *arches, continue; if (info->byte_order != arches->gdbarch->byte_order) continue; + if (info->osabi != arches->gdbarch->osabi) + continue; return arches; } return NULL; @@ -5157,6 +6215,12 @@ gdbarch_update_p (struct gdbarch_info info) if (info.byte_order == BFD_ENDIAN_UNKNOWN) info.byte_order = TARGET_BYTE_ORDER; + /* ``(gdb) set osabi ...'' is handled by gdbarch_lookup_osabi. */ + if (info.osabi == GDB_OSABI_UNINITIALIZED) + info.osabi = gdbarch_lookup_osabi (info.abfd); + if (info.osabi == GDB_OSABI_UNINITIALIZED) + info.osabi = current_gdbarch->osabi; + /* Must have found some sort of architecture. */ gdb_assert (info.bfd_arch_info != NULL); @@ -5173,6 +6237,9 @@ gdbarch_update_p (struct gdbarch_info info) (info.byte_order == BFD_ENDIAN_BIG ? "big" : info.byte_order == BFD_ENDIAN_LITTLE ? "little" : "default")); + fprintf_unfiltered (gdb_stdlog, + "gdbarch_update: info.osabi %d (%s)\n", + info.osabi, gdbarch_osabi_name (info.osabi)); fprintf_unfiltered (gdb_stdlog, "gdbarch_update: info.abfd 0x%lx\n", (long) info.abfd); @@ -5312,9 +6379,7 @@ gdbarch_update_p (struct gdbarch_info info) /* Disassembler */ /* Pointer to the target-dependent disassembly function. */ -int (*tm_print_insn) (bfd_vma, disassemble_info *); -disassemble_info tm_print_insn_info; - +int (*deprecated_tm_print_insn) (bfd_vma, disassemble_info *); extern void _initialize_gdbarch (void); @@ -5323,12 +6388,6 @@ _initialize_gdbarch (void) { struct cmd_list_element *c; - INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered); - tm_print_insn_info.flavour = bfd_target_unknown_flavour; - tm_print_insn_info.read_memory_func = dis_asm_read_memory; - tm_print_insn_info.memory_error_func = dis_asm_memory_error; - tm_print_insn_info.print_address_func = dis_asm_print_address; - add_show_from_set (add_set_cmd ("arch", class_maintenance, var_zinteger,