X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbarch.c;h=03d6b99733537f66e77a737b5047ed2fca74aa2c;hb=4c0122c8affb3323f1d4734edbeece0175b89690;hp=9519bb3cf62950a1e0a54c7df2a7d110d859beea;hpb=66140c26166febde29e6e7f2001674a930967545;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c index 9519bb3cf6..03d6b99733 100644 --- a/gdb/gdbarch.c +++ b/gdb/gdbarch.c @@ -66,6 +66,7 @@ #include "gdb-events.h" #include "reggroups.h" #include "osabi.h" +#include "symfile.h" /* For entry_point_address. */ /* Static function declarations */ @@ -146,16 +147,16 @@ struct gdbarch int char_signed; gdbarch_read_pc_ftype *read_pc; gdbarch_write_pc_ftype *write_pc; - gdbarch_read_fp_ftype *read_fp; + gdbarch_deprecated_target_read_fp_ftype *deprecated_target_read_fp; gdbarch_read_sp_ftype *read_sp; - gdbarch_write_sp_ftype *write_sp; + gdbarch_deprecated_dummy_write_sp_ftype *deprecated_dummy_write_sp; gdbarch_virtual_frame_pointer_ftype *virtual_frame_pointer; gdbarch_pseudo_register_read_ftype *pseudo_register_read; gdbarch_pseudo_register_write_ftype *pseudo_register_write; int num_regs; int num_pseudo_regs; int sp_regnum; - int fp_regnum; + int deprecated_fp_regnum; int pc_regnum; int ps_regnum; int fp0_regnum; @@ -166,14 +167,15 @@ 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; + int deprecated_register_size; + 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_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; @@ -186,25 +188,23 @@ struct gdbarch int deprecated_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; + CORE_ADDR deprecated_call_dummy_start_offset; + CORE_ADDR deprecated_call_dummy_breakpoint_offset; + int deprecated_call_dummy_length; gdbarch_deprecated_pc_in_call_dummy_ftype *deprecated_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; + 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_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_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; @@ -212,11 +212,12 @@ struct gdbarch gdbarch_address_to_pointer_ftype *address_to_pointer; gdbarch_integer_to_address_ftype *integer_to_address; gdbarch_return_value_on_stack_ftype *return_value_on_stack; - gdbarch_push_arguments_ftype *push_arguments; - gdbarch_push_dummy_frame_ftype *push_dummy_frame; - gdbarch_push_return_address_ftype *push_return_address; - gdbarch_pop_frame_ftype *pop_frame; - gdbarch_store_struct_return_ftype *store_struct_return; + gdbarch_deprecated_push_arguments_ftype *deprecated_push_arguments; + gdbarch_push_dummy_call_ftype *push_dummy_call; + gdbarch_deprecated_push_dummy_frame_ftype *deprecated_push_dummy_frame; + gdbarch_deprecated_push_return_address_ftype *deprecated_push_return_address; + 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_store_return_value_ftype *store_return_value; gdbarch_deprecated_extract_return_value_ftype *deprecated_extract_return_value; @@ -224,8 +225,8 @@ struct gdbarch 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; @@ -238,18 +239,21 @@ 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; gdbarch_frame_align_ftype *frame_align; - int extra_stack_alignment_needed; + int deprecated_extra_stack_alignment_needed; gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr; gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos; + gdbarch_unwind_dummy_id_ftype *unwind_dummy_id; int parm_boundary; const struct floatformat * float_format; const struct floatformat * double_format; @@ -277,6 +281,7 @@ struct gdbarch 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; }; @@ -289,158 +294,162 @@ struct gdbarch startup_gdbarch = { 1, /* Always initialized. */ /* basic architecture information */ - &bfd_default_arch_struct, - BFD_ENDIAN_BIG, - GDB_OSABI_UNKNOWN, + &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, - generic_register_byte, - generic_register_size, - 0, - generic_register_size, - 0, - 0, - 0, - default_print_registers_info, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - generic_pc_in_call_dummy, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - generic_in_function_epilogue_p, - construct_inferior_arguments, - 0, - 0, - 0, - "malloc", - 0, - 0, - 0, - 0, - 0, - default_register_reggroup_p, + 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, /* deprecated_target_read_fp */ + 0, /* read_sp */ + 0, /* deprecated_dummy_write_sp */ + 0, /* virtual_frame_pointer */ + 0, /* pseudo_register_read */ + 0, /* pseudo_register_write */ + 0, /* num_regs */ + 0, /* num_pseudo_regs */ + -1, /* sp_regnum */ + -1, /* deprecated_fp_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, /* deprecated_register_size */ + 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, /* 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 */ + 0, /* deprecated_use_generic_dummy_frames */ + 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 */ + generic_pc_in_call_dummy, /* deprecated_pc_in_call_dummy */ + 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_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_push_arguments */ + 0, /* push_dummy_call */ + 0, /* deprecated_push_dummy_frame */ + 0, /* deprecated_push_return_address */ + 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, /* deprecated_extra_stack_alignment_needed */ + 0, /* reg_struct_has_addr */ + 0, /* save_dummy_frame_tos */ + 0, /* unwind_dummy_id */ + 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() */ }; @@ -494,15 +503,11 @@ 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->deprecated_fp_regnum = -1; current_gdbarch->pc_regnum = -1; current_gdbarch->ps_regnum = -1; current_gdbarch->fp0_regnum = -1; @@ -513,41 +518,30 @@ 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_byte = generic_register_byte; - current_gdbarch->register_raw_size = generic_register_size; - current_gdbarch->max_register_raw_size = -1; - current_gdbarch->register_virtual_size = generic_register_size; - current_gdbarch->max_register_virtual_size = -1; + current_gdbarch->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->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->deprecated_use_generic_dummy_frames = 1; current_gdbarch->call_dummy_location = AT_ENTRY_POINT; - 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_address = entry_point_address; current_gdbarch->deprecated_pc_in_call_dummy = generic_pc_in_call_dummy; - 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->register_convertible = generic_register_convertible_not; + current_gdbarch->deprecated_call_dummy_words = legacy_call_dummy_words; + current_gdbarch->deprecated_sizeof_call_dummy_words = legacy_sizeof_call_dummy_words; + 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; @@ -558,7 +552,6 @@ gdbarch_alloc (const struct gdbarch_info *info, current_gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not; current_gdbarch->frame_args_address = get_frame_base; current_gdbarch->frame_locals_address = get_frame_base; - current_gdbarch->extra_stack_alignment_needed = 1; current_gdbarch->convert_from_func_ptr_addr = core_addr_identity; current_gdbarch->addr_bits_remove = core_addr_identity; current_gdbarch->smash_text_address = core_addr_identity; @@ -627,11 +620,11 @@ 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 deprecated_target_read_fp, has predicate */ + /* Skip verify of read_sp, has predicate */ + /* Skip verify of deprecated_dummy_write_sp, has predicate */ /* Skip verify of virtual_frame_pointer, invalid_p == 0 */ /* Skip verify of pseudo_register_read, has predicate */ /* Skip verify of pseudo_register_write, has predicate */ @@ -640,7 +633,7 @@ verify_gdbarch (struct gdbarch *gdbarch) 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 deprecated_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 */ @@ -651,24 +644,13 @@ 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"); - /* Skip verify of register_byte, invalid_p == 0 */ - /* Skip verify of register_raw_size, invalid_p == 0 */ - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->max_register_raw_size == -1)) - fprintf_unfiltered (log, "\n\tmax_register_raw_size"); - /* Skip verify of register_virtual_size, invalid_p == 0 */ - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->max_register_virtual_size == -1)) - fprintf_unfiltered (log, "\n\tmax_register_virtual_size"); - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->register_virtual_type == 0)) - fprintf_unfiltered (log, "\n\tregister_virtual_type"); + /* Skip verify of 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 deprecated_do_registers_info, has predicate */ /* Skip verify of print_registers_info, invalid_p == 0 */ /* Skip verify of print_float_info, has predicate */ @@ -680,42 +662,19 @@ verify_gdbarch (struct gdbarch *gdbarch) /* Skip verify of get_longjmp_target, has predicate */ /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */ /* Skip verify of call_dummy_location, invalid_p == 0 */ - 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"); + /* Skip verify of call_dummy_address, invalid_p == 0 */ /* Skip verify of deprecated_pc_in_call_dummy, has predicate */ - 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 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_init_frame_pc_first, has predicate */ /* Skip verify of deprecated_init_frame_pc, has predicate */ - /* Skip verify of get_saved_register, has predicate */ - /* 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_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 */ @@ -723,26 +682,19 @@ verify_gdbarch (struct gdbarch *gdbarch) /* 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 */ - /* 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"); + /* Skip verify of deprecated_push_arguments, has predicate */ + /* Skip verify of push_dummy_call, has predicate */ + /* Skip verify of deprecated_push_dummy_frame, has predicate */ + /* Skip verify of deprecated_push_return_address, has predicate */ + /* 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"); @@ -750,7 +702,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) @@ -765,26 +719,21 @@ 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, has predicate */ - if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) - && (gdbarch->frame_saved_pc == 0)) - fprintf_unfiltered (log, "\n\tframe_saved_pc"); + /* 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 */ - 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_saved_pc_after_call, has predicate */ + /* Skip verify of frame_num_args, has predicate */ /* Skip verify of stack_align, has predicate */ /* Skip verify of frame_align, has predicate */ - /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */ + /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */ /* Skip verify of reg_struct_has_addr, has predicate */ /* Skip verify of save_dummy_frame_tos, has predicate */ + /* Skip verify of unwind_dummy_id, has predicate */ if (gdbarch->float_format == 0) gdbarch->float_format = default_float_format (gdbarch); if (gdbarch->double_format == 0) @@ -814,6 +763,7 @@ verify_gdbarch (struct gdbarch *gdbarch) /* 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) @@ -969,32 +919,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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", @@ -1003,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", @@ -1122,6 +1005,55 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n", (long) DECR_PC_AFTER_BREAK); #endif +#ifdef DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET + fprintf_unfiltered (file, + "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 +#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 DEPRECATED_CALL_DUMMY_STACK_ADJUST_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "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 +#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 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", @@ -1145,6 +1077,29 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->deprecated_do_registers_info /*DEPRECATED_DO_REGISTERS_INFO ()*/); #endif +#ifdef DEPRECATED_DUMMY_WRITE_SP_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "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 DEPRECATED_DUMMY_WRITE_SP +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_DUMMY_WRITE_SP(val)", + XSTRING (DEPRECATED_DUMMY_WRITE_SP (val))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP = <0x%08lx>\n", + (long) current_gdbarch->deprecated_dummy_write_sp + /*DEPRECATED_DUMMY_WRITE_SP ()*/); +#endif #ifdef DEPRECATED_EXTRACT_RETURN_VALUE #if GDB_MULTI_ARCH /* Macro might contain `[{}]' when not multi-arch */ @@ -1179,6 +1134,174 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->deprecated_extract_struct_value_address /*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/); #endif +#ifdef DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED # %s\n", + XSTRING (DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED = %d\n", + DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED); +#endif +#ifdef DEPRECATED_FIX_CALL_DUMMY_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "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 DEPRECATED_FIX_CALL_DUMMY +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "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: DEPRECATED_FIX_CALL_DUMMY = <0x%08lx>\n", + (long) current_gdbarch->deprecated_fix_call_dummy + /*DEPRECATED_FIX_CALL_DUMMY ()*/); +#endif +#ifdef DEPRECATED_FP_REGNUM + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n", + XSTRING (DEPRECATED_FP_REGNUM)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FP_REGNUM = %d\n", + DEPRECATED_FP_REGNUM); +#endif +#ifdef DEPRECATED_FRAME_CHAIN_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_FRAME_CHAIN_P()", + XSTRING (DEPRECATED_FRAME_CHAIN_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FRAME_CHAIN_P() = %d\n", + DEPRECATED_FRAME_CHAIN_P ()); +#endif +#ifdef DEPRECATED_FRAME_CHAIN + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_FRAME_CHAIN(frame)", + XSTRING (DEPRECATED_FRAME_CHAIN (frame))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FRAME_CHAIN = <0x%08lx>\n", + (long) current_gdbarch->deprecated_frame_chain + /*DEPRECATED_FRAME_CHAIN ()*/); +#endif +#ifdef DEPRECATED_FRAME_CHAIN_VALID_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_FRAME_CHAIN_VALID_P()", + XSTRING (DEPRECATED_FRAME_CHAIN_VALID_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID_P() = %d\n", + DEPRECATED_FRAME_CHAIN_VALID_P ()); +#endif +#ifdef DEPRECATED_FRAME_CHAIN_VALID + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe)", + XSTRING (DEPRECATED_FRAME_CHAIN_VALID (chain, thisframe))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID = <0x%08lx>\n", + (long) current_gdbarch->deprecated_frame_chain_valid + /*DEPRECATED_FRAME_CHAIN_VALID ()*/); +#endif +#ifdef DEPRECATED_FRAME_INIT_SAVED_REGS_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "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 DEPRECATED_FRAME_INIT_SAVED_REGS +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_FRAME_INIT_SAVED_REGS(frame)", + XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS (frame))); +#endif + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "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 DEPRECATED_FRAME_SAVED_PC_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_FRAME_SAVED_PC_P()", + XSTRING (DEPRECATED_FRAME_SAVED_PC_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC_P() = %d\n", + DEPRECATED_FRAME_SAVED_PC_P ()); +#endif +#ifdef DEPRECATED_FRAME_SAVED_PC + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_FRAME_SAVED_PC(fi)", + XSTRING (DEPRECATED_FRAME_SAVED_PC (fi))); + if (GDB_MULTI_ARCH) + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC = <0x%08lx>\n", + (long) current_gdbarch->deprecated_frame_saved_pc + /*DEPRECATED_FRAME_SAVED_PC ()*/); +#endif +#ifdef DEPRECATED_GET_SAVED_REGISTER_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "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 DEPRECATED_GET_SAVED_REGISTER +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "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: DEPRECATED_GET_SAVED_REGISTER = <0x%08lx>\n", + (long) current_gdbarch->deprecated_get_saved_register + /*DEPRECATED_GET_SAVED_REGISTER ()*/); +#endif +#ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "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 DEPRECATED_INIT_EXTRA_FRAME_INFO +#if GDB_MULTI_ARCH + /* Macro might contain `[{}]' when not multi-arch */ + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "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: DEPRECATED_INIT_EXTRA_FRAME_INFO = <0x%08lx>\n", + (long) current_gdbarch->deprecated_init_extra_frame_info + /*DEPRECATED_INIT_EXTRA_FRAME_INFO ()*/); +#endif #ifdef DEPRECATED_INIT_FRAME_PC_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1219,6 +1342,40 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->deprecated_init_frame_pc_first /*DEPRECATED_INIT_FRAME_PC_FIRST ()*/); #endif +#ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "DEPRECATED_MAX_REGISTER_RAW_SIZE_P()", + XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE_P() = %d\n", + DEPRECATED_MAX_REGISTER_RAW_SIZE_P ()); +#endif +#ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE # %s\n", + XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE)); + fprintf_unfiltered (file, + "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE = %d\n", + DEPRECATED_MAX_REGISTER_RAW_SIZE); +#endif +#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", @@ -1239,6 +1396,175 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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 */ @@ -1253,6 +1579,49 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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", @@ -1365,27 +1734,25 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->extract_struct_value_address /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/); #endif -#ifdef EXTRA_STACK_ALIGNMENT_NEEDED +#ifdef FETCH_POINTER_ARGUMENT_P fprintf_unfiltered (file, - "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n", - XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED)); + "gdbarch_dump: %s # %s\n", + "FETCH_POINTER_ARGUMENT_P()", + XSTRING (FETCH_POINTER_ARGUMENT_P ())); fprintf_unfiltered (file, - "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %d\n", - EXTRA_STACK_ALIGNMENT_NEEDED); + "gdbarch_dump: FETCH_POINTER_ARGUMENT_P() = %d\n", + FETCH_POINTER_ARGUMENT_P ()); #endif -#ifdef FIX_CALL_DUMMY -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ +#ifdef FETCH_POINTER_ARGUMENT 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))); -#endif + "FETCH_POINTER_ARGUMENT(frame, argi, type)", + XSTRING (FETCH_POINTER_ARGUMENT (frame, argi, type))); 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: FETCH_POINTER_ARGUMENT = <0x%08lx>\n", + (long) current_gdbarch->fetch_pointer_argument + /*FETCH_POINTER_ARGUMENT ()*/); #endif #ifdef FP0_REGNUM fprintf_unfiltered (file, @@ -1395,14 +1762,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: FP0_REGNUM = %d\n", FP0_REGNUM); #endif -#ifdef FP_REGNUM - fprintf_unfiltered (file, - "gdbarch_dump: FP_REGNUM # %s\n", - XSTRING (FP_REGNUM)); - fprintf_unfiltered (file, - "gdbarch_dump: FP_REGNUM = %d\n", - FP_REGNUM); -#endif #ifdef FRAMELESS_FUNCTION_INVOCATION fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1433,51 +1792,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n", (long) FRAME_ARGS_SKIP); #endif -#ifdef FRAME_CHAIN - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "FRAME_CHAIN(frame)", - XSTRING (FRAME_CHAIN (frame))); - if (GDB_MULTI_ARCH) - fprintf_unfiltered (file, - "gdbarch_dump: FRAME_CHAIN = <0x%08lx>\n", - (long) current_gdbarch->frame_chain - /*FRAME_CHAIN ()*/); -#endif -#ifdef FRAME_CHAIN_VALID_P - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "FRAME_CHAIN_VALID_P()", - XSTRING (FRAME_CHAIN_VALID_P ())); - fprintf_unfiltered (file, - "gdbarch_dump: FRAME_CHAIN_VALID_P() = %d\n", - FRAME_CHAIN_VALID_P ()); -#endif -#ifdef FRAME_CHAIN_VALID - 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 ()*/); -#endif -#ifdef 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))); -#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 ()*/); -#endif #ifdef FRAME_LOCALS_ADDRESS fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1489,6 +1803,15 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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", @@ -1500,17 +1823,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->frame_num_args /*FRAME_NUM_ARGS ()*/); #endif -#ifdef FRAME_SAVED_PC - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "FRAME_SAVED_PC(fi)", - XSTRING (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 ()*/); -#endif #ifdef FUNCTION_START_OFFSET fprintf_unfiltered (file, "gdbarch_dump: FUNCTION_START_OFFSET # %s\n", @@ -1539,29 +1851,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->get_longjmp_target /*GET_LONGJMP_TARGET ()*/); #endif -#ifdef GET_SAVED_REGISTER_P - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "GET_SAVED_REGISTER_P()", - XSTRING (GET_SAVED_REGISTER_P ())); - fprintf_unfiltered (file, - "gdbarch_dump: GET_SAVED_REGISTER_P() = %d\n", - GET_SAVED_REGISTER_P ()); -#endif -#ifdef 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))); -#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 ()*/); -#endif #ifdef HAVE_NONSTEPPABLE_WATCHPOINT fprintf_unfiltered (file, "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n", @@ -1570,29 +1859,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n", HAVE_NONSTEPPABLE_WATCHPOINT); #endif -#ifdef INIT_EXTRA_FRAME_INFO_P - fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "INIT_EXTRA_FRAME_INFO_P()", - XSTRING (INIT_EXTRA_FRAME_INFO_P ())); - fprintf_unfiltered (file, - "gdbarch_dump: INIT_EXTRA_FRAME_INFO_P() = %d\n", - INIT_EXTRA_FRAME_INFO_P ()); -#endif -#ifdef INIT_EXTRA_FRAME_INFO -#if GDB_MULTI_ARCH - /* Macro might contain `[{}]' when not multi-arch */ - 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 ()*/); -#endif #ifdef INNER_THAN fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1646,22 +1912,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->in_solib_return_trampoline /*IN_SOLIB_RETURN_TRAMPOLINE ()*/); #endif -#ifdef MAX_REGISTER_RAW_SIZE - fprintf_unfiltered (file, - "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n", - XSTRING (MAX_REGISTER_RAW_SIZE)); - fprintf_unfiltered (file, - "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %d\n", - MAX_REGISTER_RAW_SIZE); -#endif -#ifdef MAX_REGISTER_VIRTUAL_SIZE - fprintf_unfiltered (file, - "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n", - XSTRING (MAX_REGISTER_VIRTUAL_SIZE)); - fprintf_unfiltered (file, - "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %d\n", - MAX_REGISTER_VIRTUAL_SIZE); -#endif #ifdef MEMORY_INSERT_BREAKPOINT fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1754,20 +2004,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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", @@ -1818,50 +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_P + "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_dummy_code = 0x%08lx\n", + (long) current_gdbarch->push_dummy_code); +#ifdef REGISTER_BYTE_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "PUSH_RETURN_ADDRESS_P()", - XSTRING (PUSH_RETURN_ADDRESS_P ())); - fprintf_unfiltered (file, - "gdbarch_dump: PUSH_RETURN_ADDRESS_P() = %d\n", - PUSH_RETURN_ADDRESS_P ()); -#endif -#ifdef PUSH_RETURN_ADDRESS + "REGISTER_BYTE_P()", + XSTRING (REGISTER_BYTE_P ())); fprintf_unfiltered (file, - "gdbarch_dump: %s # %s\n", - "PUSH_RETURN_ADDRESS(pc, sp)", - XSTRING (PUSH_RETURN_ADDRESS (pc, sp))); - 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: REGISTER_BYTE_P() = %d\n", + REGISTER_BYTE_P ()); #endif #ifdef REGISTER_BYTE fprintf_unfiltered (file, @@ -1871,17 +2087,9 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) if (GDB_MULTI_ARCH) fprintf_unfiltered (file, "gdbarch_dump: REGISTER_BYTE = <0x%08lx>\n", - (long) current_gdbarch->register_byte + (long) current_gdbarch->deprecated_register_byte /*REGISTER_BYTE ()*/); #endif -#ifdef REGISTER_BYTES - fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_BYTES # %s\n", - XSTRING (REGISTER_BYTES)); - fprintf_unfiltered (file, - "gdbarch_dump: REGISTER_BYTES = %d\n", - REGISTER_BYTES); -#endif #ifdef REGISTER_BYTES_OK_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -1902,45 +2110,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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", @@ -1960,7 +2129,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) if (GDB_MULTI_ARCH) fprintf_unfiltered (file, "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n", - (long) current_gdbarch->register_raw_size + (long) current_gdbarch->deprecated_register_raw_size /*REGISTER_RAW_SIZE ()*/); #endif #ifdef REGISTER_SIM_REGNO @@ -1974,14 +2143,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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 */ @@ -1996,6 +2157,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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", @@ -2004,9 +2173,18 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) if (GDB_MULTI_ARCH) fprintf_unfiltered (file, "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n", - (long) current_gdbarch->register_virtual_size + (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", @@ -2015,7 +2193,7 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) if (GDB_MULTI_ARCH) fprintf_unfiltered (file, "gdbarch_dump: REGISTER_VIRTUAL_TYPE = <0x%08lx>\n", - (long) current_gdbarch->register_virtual_type + (long) current_gdbarch->deprecated_register_virtual_type /*REGISTER_VIRTUAL_TYPE ()*/); #endif #ifdef REG_STRUCT_HAS_ADDR_P @@ -2037,21 +2215,11 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "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", @@ -2063,17 +2231,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (long) current_gdbarch->return_value_on_stack /*RETURN_VALUE_ON_STACK ()*/); #endif -#ifdef SAVED_PC_AFTER_CALL - 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 ()*/); -#endif #ifdef SAVE_DUMMY_FRAME_TOS_P fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -2145,16 +2302,8 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) if (GDB_MULTI_ARCH) fprintf_unfiltered (file, "gdbarch_dump: SIGTRAMP_START = <0x%08lx>\n", - (long) current_gdbarch->sigtramp_start - /*SIGTRAMP_START ()*/); -#endif -#ifdef SIZEOF_CALL_DUMMY_WORDS - fprintf_unfiltered (file, - "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n", - XSTRING (SIZEOF_CALL_DUMMY_WORDS)); - fprintf_unfiltered (file, - "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n", - (long) SIZEOF_CALL_DUMMY_WORDS); + (long) current_gdbarch->sigtramp_start + /*SIGTRAMP_START ()*/); #endif #ifdef SKIP_PROLOGUE fprintf_unfiltered (file, @@ -2265,20 +2414,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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", @@ -2419,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, @@ -2441,6 +2574,15 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) (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", @@ -2487,21 +2629,31 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) "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 + "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", @@ -2758,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) { @@ -2796,23 +2955,37 @@ set_gdbarch_write_pc (struct gdbarch *gdbarch, gdbarch->write_pc = write_pc; } +int +gdbarch_deprecated_target_read_fp_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_target_read_fp != 0; +} + CORE_ADDR -gdbarch_read_fp (struct gdbarch *gdbarch) +gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->read_fp == 0) + if (gdbarch->deprecated_target_read_fp == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_read_fp invalid"); + "gdbarch: gdbarch_deprecated_target_read_fp invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_read_fp called\n"); - return gdbarch->read_fp (); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_target_read_fp called\n"); + return gdbarch->deprecated_target_read_fp (); } void -set_gdbarch_read_fp (struct gdbarch *gdbarch, - gdbarch_read_fp_ftype read_fp) +set_gdbarch_deprecated_target_read_fp (struct gdbarch *gdbarch, + gdbarch_deprecated_target_read_fp_ftype deprecated_target_read_fp) +{ + gdbarch->deprecated_target_read_fp = deprecated_target_read_fp; +} + +int +gdbarch_read_sp_p (struct gdbarch *gdbarch) { - gdbarch->read_fp = read_fp; + gdb_assert (gdbarch != NULL); + return gdbarch->read_sp != 0; } CORE_ADDR @@ -2834,23 +3007,30 @@ set_gdbarch_read_sp (struct gdbarch *gdbarch, gdbarch->read_sp = read_sp; } +int +gdbarch_deprecated_dummy_write_sp_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_dummy_write_sp != 0; +} + void -gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val) +gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch, CORE_ADDR val) { gdb_assert (gdbarch != NULL); - if (gdbarch->write_sp == 0) + if (gdbarch->deprecated_dummy_write_sp == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_write_sp invalid"); + "gdbarch: gdbarch_deprecated_dummy_write_sp invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_write_sp called\n"); - gdbarch->write_sp (val); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_dummy_write_sp called\n"); + gdbarch->deprecated_dummy_write_sp (val); } void -set_gdbarch_write_sp (struct gdbarch *gdbarch, - gdbarch_write_sp_ftype write_sp) +set_gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch, + gdbarch_deprecated_dummy_write_sp_ftype deprecated_dummy_write_sp) { - gdbarch->write_sp = write_sp; + gdbarch->deprecated_dummy_write_sp = deprecated_dummy_write_sp; } void @@ -2978,20 +3158,20 @@ set_gdbarch_sp_regnum (struct gdbarch *gdbarch, } int -gdbarch_fp_regnum (struct gdbarch *gdbarch) +gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - /* Skip verify of fp_regnum, invalid_p == 0 */ + /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */ if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_fp_regnum called\n"); - return gdbarch->fp_regnum; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fp_regnum called\n"); + return gdbarch->deprecated_fp_regnum; } void -set_gdbarch_fp_regnum (struct gdbarch *gdbarch, - int fp_regnum) +set_gdbarch_deprecated_fp_regnum (struct gdbarch *gdbarch, + int deprecated_fp_regnum) { - gdbarch->fp_regnum = fp_regnum; + gdbarch->deprecated_fp_regnum = deprecated_fp_regnum; } int @@ -3177,155 +3357,198 @@ set_gdbarch_register_name (struct gdbarch *gdbarch, } int -gdbarch_register_size (struct gdbarch *gdbarch) +gdbarch_deprecated_register_size (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_size == -1) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_size invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n"); - return gdbarch->register_size; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n"); + return gdbarch->deprecated_register_size; } void -set_gdbarch_register_size (struct gdbarch *gdbarch, - int register_size) +set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch, + int deprecated_register_size) { - gdbarch->register_size = register_size; + gdbarch->deprecated_register_size = deprecated_register_size; } int -gdbarch_register_bytes (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_bytes == -1) + if (gdbarch->register_type == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_bytes invalid"); + "gdbarch: gdbarch_register_type invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes called\n"); - return gdbarch->register_bytes; + fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n"); + return gdbarch->register_type (gdbarch, reg_nr); } void -set_gdbarch_register_bytes (struct gdbarch *gdbarch, - int register_bytes) +set_gdbarch_register_type (struct gdbarch *gdbarch, + gdbarch_register_type_ftype register_type) { - gdbarch->register_bytes = register_bytes; + gdbarch->register_type = register_type; } int -gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr) +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_byte == 0) + if (gdbarch->deprecated_register_virtual_type == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_byte invalid"); + "gdbarch: gdbarch_deprecated_register_virtual_type invalid"); 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_virtual_type called\n"); + return gdbarch->deprecated_register_virtual_type (reg_nr); } void -set_gdbarch_register_byte (struct gdbarch *gdbarch, - gdbarch_register_byte_ftype register_byte) +set_gdbarch_deprecated_register_virtual_type (struct gdbarch *gdbarch, + gdbarch_deprecated_register_virtual_type_ftype deprecated_register_virtual_type) { - gdbarch->register_byte = register_byte; + gdbarch->deprecated_register_virtual_type = deprecated_register_virtual_type; } int -gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr) +gdbarch_deprecated_register_bytes (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->register_raw_size == 0) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_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_bytes called\n"); + return gdbarch->deprecated_register_bytes; } void -set_gdbarch_register_raw_size (struct gdbarch *gdbarch, - gdbarch_register_raw_size_ftype register_raw_size) +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_raw_size = register_raw_size; + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_register_byte != generic_register_byte; } int -gdbarch_max_register_raw_size (struct gdbarch *gdbarch) +gdbarch_deprecated_register_byte (struct gdbarch *gdbarch, int reg_nr) { gdb_assert (gdbarch != NULL); - if (gdbarch->max_register_raw_size == -1) + if (gdbarch->deprecated_register_byte == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_max_register_raw_size 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_max_register_raw_size called\n"); - return gdbarch->max_register_raw_size; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_byte called\n"); + return gdbarch->deprecated_register_byte (reg_nr); } void -set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch, - int max_register_raw_size) +set_gdbarch_deprecated_register_byte (struct gdbarch *gdbarch, + gdbarch_deprecated_register_byte_ftype deprecated_register_byte) { - gdbarch->max_register_raw_size = max_register_raw_size; + gdbarch->deprecated_register_byte = deprecated_register_byte; } int -gdbarch_register_virtual_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_virtual_size == 0) + if (gdbarch->deprecated_register_raw_size == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_virtual_size invalid"); + "gdbarch: gdbarch_deprecated_register_raw_size 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_deprecated_register_raw_size called\n"); + return gdbarch->deprecated_register_raw_size (reg_nr); } void -set_gdbarch_register_virtual_size (struct gdbarch *gdbarch, - gdbarch_register_virtual_size_ftype register_virtual_size) +set_gdbarch_deprecated_register_raw_size (struct gdbarch *gdbarch, + gdbarch_deprecated_register_raw_size_ftype deprecated_register_raw_size) { - gdbarch->register_virtual_size = register_virtual_size; + gdbarch->deprecated_register_raw_size = deprecated_register_raw_size; } int -gdbarch_max_register_virtual_size (struct gdbarch *gdbarch) +gdbarch_deprecated_register_virtual_size (struct gdbarch *gdbarch, int reg_nr) { gdb_assert (gdbarch != NULL); - if (gdbarch->max_register_virtual_size == -1) + if (gdbarch->deprecated_register_virtual_size == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_max_register_virtual_size invalid"); + "gdbarch: gdbarch_deprecated_register_virtual_size 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_deprecated_register_virtual_size called\n"); + return gdbarch->deprecated_register_virtual_size (reg_nr); } void -set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch, - int max_register_virtual_size) +set_gdbarch_deprecated_register_virtual_size (struct gdbarch *gdbarch, + gdbarch_deprecated_register_virtual_size_ftype deprecated_register_virtual_size) { - gdbarch->max_register_virtual_size = max_register_virtual_size; + gdbarch->deprecated_register_virtual_size = deprecated_register_virtual_size; } -struct type * -gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr) +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->register_virtual_type == 0) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_register_virtual_type 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_max_register_virtual_size called\n"); + return gdbarch->deprecated_max_register_virtual_size; } void -set_gdbarch_register_virtual_type (struct gdbarch *gdbarch, - gdbarch_register_virtual_type_ftype register_virtual_type) +set_gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch, + int deprecated_max_register_virtual_size) { - gdbarch->register_virtual_type = register_virtual_type; + gdbarch->deprecated_max_register_virtual_size = deprecated_max_register_virtual_size; } int @@ -3588,79 +3811,51 @@ set_gdbarch_call_dummy_address (struct gdbarch *gdbarch, } CORE_ADDR -gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch) +gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_start_offset == -1) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_start_offset invalid"); 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_call_dummy_start_offset called\n"); + return gdbarch->deprecated_call_dummy_start_offset; } void -set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch, - CORE_ADDR call_dummy_start_offset) +set_gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch, + CORE_ADDR deprecated_call_dummy_start_offset) { - gdbarch->call_dummy_start_offset = call_dummy_start_offset; + gdbarch->deprecated_call_dummy_start_offset = deprecated_call_dummy_start_offset; } CORE_ADDR -gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch) -{ - gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_breakpoint_offset invalid"); - if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n"); - return gdbarch->call_dummy_breakpoint_offset; -} - -void -set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, - CORE_ADDR call_dummy_breakpoint_offset) -{ - gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset; -} - -int -gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch) +gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_breakpoint_offset_p == -1) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid"); 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_deprecated_call_dummy_breakpoint_offset called\n"); + return gdbarch->deprecated_call_dummy_breakpoint_offset; } void -set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch, - int call_dummy_breakpoint_offset_p) +set_gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, + CORE_ADDR deprecated_call_dummy_breakpoint_offset) { - gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p; + gdbarch->deprecated_call_dummy_breakpoint_offset = deprecated_call_dummy_breakpoint_offset; } int -gdbarch_call_dummy_length (struct gdbarch *gdbarch) +gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_length == -1) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_length invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n"); - return gdbarch->call_dummy_length; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_length called\n"); + return gdbarch->deprecated_call_dummy_length; } void -set_gdbarch_call_dummy_length (struct gdbarch *gdbarch, - int call_dummy_length) +set_gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch, + int deprecated_call_dummy_length) { - gdbarch->call_dummy_length = call_dummy_length; + gdbarch->deprecated_call_dummy_length = deprecated_call_dummy_length; } int @@ -3690,114 +3885,113 @@ set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, gdbarch->deprecated_pc_in_call_dummy = deprecated_pc_in_call_dummy; } -int -gdbarch_call_dummy_p (struct gdbarch *gdbarch) +LONGEST * +gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_p == -1) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_p invalid"); + /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */ if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_p called\n"); - return gdbarch->call_dummy_p; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_words called\n"); + return gdbarch->deprecated_call_dummy_words; } void -set_gdbarch_call_dummy_p (struct gdbarch *gdbarch, - int call_dummy_p) +set_gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch, + LONGEST * deprecated_call_dummy_words) { - gdbarch->call_dummy_p = call_dummy_p; + gdbarch->deprecated_call_dummy_words = deprecated_call_dummy_words; } -LONGEST * -gdbarch_call_dummy_words (struct gdbarch *gdbarch) +int +gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - /* Skip verify of call_dummy_words, invalid_p == 0 */ + /* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */ if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n"); - return gdbarch->call_dummy_words; + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_sizeof_call_dummy_words called\n"); + return gdbarch->deprecated_sizeof_call_dummy_words; } void -set_gdbarch_call_dummy_words (struct gdbarch *gdbarch, - LONGEST * call_dummy_words) +set_gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch, + int deprecated_sizeof_call_dummy_words) { - gdbarch->call_dummy_words = call_dummy_words; + gdbarch->deprecated_sizeof_call_dummy_words = deprecated_sizeof_call_dummy_words; } int -gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch) +gdbarch_deprecated_call_dummy_stack_adjust_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */ - if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n"); - return gdbarch->sizeof_call_dummy_words; -} - -void -set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch, - int sizeof_call_dummy_words) -{ - gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words; + return gdbarch->deprecated_call_dummy_stack_adjust != 0; } int -gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch) +gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->call_dummy_stack_adjust_p == -1) - internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_stack_adjust_p invalid"); 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_deprecated_call_dummy_stack_adjust called\n"); + return gdbarch->deprecated_call_dummy_stack_adjust; } void -set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch, - int call_dummy_stack_adjust_p) +set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch, + int deprecated_call_dummy_stack_adjust) { - gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p; + gdbarch->deprecated_call_dummy_stack_adjust = deprecated_call_dummy_stack_adjust; } int -gdbarch_call_dummy_stack_adjust (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->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0) + if (gdbarch->deprecated_fix_call_dummy == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_call_dummy_stack_adjust invalid"); + "gdbarch: gdbarch_deprecated_fix_call_dummy 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_deprecated_fix_call_dummy called\n"); + gdbarch->deprecated_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p); } void -set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch, - int call_dummy_stack_adjust) +set_gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch, + gdbarch_deprecated_fix_call_dummy_ftype deprecated_fix_call_dummy) { - gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust; + gdbarch->deprecated_fix_call_dummy = deprecated_fix_call_dummy; } -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_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->fix_call_dummy == 0) + if (gdbarch->push_dummy_code == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_fix_call_dummy invalid"); + "gdbarch: gdbarch_push_dummy_code invalid"); 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_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_fix_call_dummy (struct gdbarch *gdbarch, - gdbarch_fix_call_dummy_ftype fix_call_dummy) +set_gdbarch_push_dummy_code (struct gdbarch *gdbarch, + gdbarch_push_dummy_code_ftype push_dummy_code) { - gdbarch->fix_call_dummy = fix_call_dummy; + gdbarch->push_dummy_code = push_dummy_code; } int @@ -3885,86 +4079,86 @@ set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch, } int -gdbarch_get_saved_register_p (struct gdbarch *gdbarch) +gdbarch_deprecated_get_saved_register_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - return gdbarch->get_saved_register != 0; + 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 @@ -4107,106 +4301,160 @@ set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch, gdbarch->return_value_on_stack = return_value_on_stack; } +int +gdbarch_deprecated_push_arguments_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + 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_deprecated_push_arguments invalid"); + if (gdbarch_debug >= 2) + 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_deprecated_push_arguments (struct gdbarch *gdbarch, + gdbarch_deprecated_push_arguments_ftype deprecated_push_arguments) +{ + gdbarch->deprecated_push_arguments = deprecated_push_arguments; +} + +int +gdbarch_push_dummy_call_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->push_dummy_call != 0; +} + CORE_ADDR -gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_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_arguments == 0) + if (gdbarch->push_dummy_call == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_push_arguments invalid"); + "gdbarch: gdbarch_push_dummy_call 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_push_dummy_call called\n"); + return gdbarch->push_dummy_call (gdbarch, func_addr, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr); } void -set_gdbarch_push_arguments (struct gdbarch *gdbarch, - gdbarch_push_arguments_ftype push_arguments) +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_dummy_frame_p (struct gdbarch *gdbarch) { - gdbarch->push_arguments = push_arguments; + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_push_dummy_frame != 0; } void -gdbarch_push_dummy_frame (struct gdbarch *gdbarch) +gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->push_dummy_frame == 0) + if (gdbarch->deprecated_push_dummy_frame == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_push_dummy_frame invalid"); + "gdbarch: gdbarch_deprecated_push_dummy_frame invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_frame called\n"); - gdbarch->push_dummy_frame (); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_dummy_frame called\n"); + gdbarch->deprecated_push_dummy_frame (); } void -set_gdbarch_push_dummy_frame (struct gdbarch *gdbarch, - gdbarch_push_dummy_frame_ftype push_dummy_frame) +set_gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch, + gdbarch_deprecated_push_dummy_frame_ftype deprecated_push_dummy_frame) { - gdbarch->push_dummy_frame = push_dummy_frame; + gdbarch->deprecated_push_dummy_frame = deprecated_push_dummy_frame; } int -gdbarch_push_return_address_p (struct gdbarch *gdbarch) +gdbarch_deprecated_push_return_address_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - return gdbarch->push_return_address != 0; + return gdbarch->deprecated_push_return_address != 0; } CORE_ADDR -gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp) +gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp) { gdb_assert (gdbarch != NULL); - if (gdbarch->push_return_address == 0) + if (gdbarch->deprecated_push_return_address == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_push_return_address invalid"); + "gdbarch: gdbarch_deprecated_push_return_address 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_deprecated_push_return_address called\n"); + return gdbarch->deprecated_push_return_address (pc, sp); } void -set_gdbarch_push_return_address (struct gdbarch *gdbarch, - gdbarch_push_return_address_ftype push_return_address) +set_gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch, + gdbarch_deprecated_push_return_address_ftype deprecated_push_return_address) +{ + gdbarch->deprecated_push_return_address = deprecated_push_return_address; +} + +int +gdbarch_deprecated_pop_frame_p (struct gdbarch *gdbarch) { - gdbarch->push_return_address = push_return_address; + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_pop_frame != 0; } void -gdbarch_pop_frame (struct gdbarch *gdbarch) +gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - if (gdbarch->pop_frame == 0) + if (gdbarch->deprecated_pop_frame == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_pop_frame invalid"); + "gdbarch: gdbarch_deprecated_pop_frame invalid"); if (gdbarch_debug >= 2) - fprintf_unfiltered (gdb_stdlog, "gdbarch_pop_frame called\n"); - gdbarch->pop_frame (); + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pop_frame called\n"); + gdbarch->deprecated_pop_frame (); } void -set_gdbarch_pop_frame (struct gdbarch *gdbarch, - gdbarch_pop_frame_ftype pop_frame) +set_gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch, + gdbarch_deprecated_pop_frame_ftype deprecated_pop_frame) +{ + gdbarch->deprecated_pop_frame = deprecated_pop_frame; +} + +int +gdbarch_deprecated_store_struct_return_p (struct gdbarch *gdbarch) { - gdbarch->pop_frame = pop_frame; + gdb_assert (gdbarch != NULL); + return gdbarch->deprecated_store_struct_return != 0; } void -gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp) +gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp) { gdb_assert (gdbarch != NULL); - if (gdbarch->store_struct_return == 0) + if (gdbarch->deprecated_store_struct_return == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_store_struct_return invalid"); + "gdbarch: gdbarch_deprecated_store_struct_return 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_struct_return called\n"); + gdbarch->deprecated_store_struct_return (addr, sp); } void -set_gdbarch_store_struct_return (struct gdbarch *gdbarch, - gdbarch_store_struct_return_ftype store_struct_return) +set_gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, + gdbarch_deprecated_store_struct_return_ftype deprecated_store_struct_return) { - gdbarch->store_struct_return = store_struct_return; + gdbarch->deprecated_store_struct_return = deprecated_store_struct_return; } void @@ -4356,49 +4604,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 @@ -4573,7 +4828,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) @@ -4581,7 +4836,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 @@ -4629,68 +4884,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_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame) +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->frame_chain == 0) + if (gdbarch->deprecated_frame_chain_valid == 0) internal_error (__FILE__, __LINE__, - "gdbarch: gdbarch_frame_chain invalid"); + "gdbarch: gdbarch_deprecated_frame_chain_valid 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_chain_valid called\n"); + return gdbarch->deprecated_frame_chain_valid (chain, thisframe); } void -set_gdbarch_frame_chain (struct gdbarch *gdbarch, - gdbarch_frame_chain_ftype frame_chain) +set_gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch, + gdbarch_deprecated_frame_chain_valid_ftype deprecated_frame_chain_valid) { - gdbarch->frame_chain = frame_chain; + gdbarch->deprecated_frame_chain_valid = deprecated_frame_chain_valid; } int -gdbarch_frame_chain_valid_p (struct gdbarch *gdbarch) +gdbarch_deprecated_frame_saved_pc_p (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - return gdbarch->frame_chain_valid != 0; + return gdbarch->deprecated_frame_saved_pc != 0; +} + +CORE_ADDR +gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi) +{ + gdb_assert (gdbarch != NULL); + if (gdbarch->deprecated_frame_saved_pc == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_deprecated_frame_saved_pc invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_saved_pc called\n"); + return gdbarch->deprecated_frame_saved_pc (fi); +} + +void +set_gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch, + gdbarch_deprecated_frame_saved_pc_ftype deprecated_frame_saved_pc) +{ + 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->frame_chain_valid = frame_chain_valid; + gdbarch->unwind_pc = unwind_pc; +} + +int +gdbarch_unwind_sp_p (struct gdbarch *gdbarch) +{ + 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 @@ -4731,23 +5052,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 @@ -4822,20 +5157,20 @@ set_gdbarch_frame_align (struct gdbarch *gdbarch, } int -gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch) +gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch) { gdb_assert (gdbarch != NULL); - /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */ + /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */ 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_deprecated_extra_stack_alignment_needed called\n"); + return gdbarch->deprecated_extra_stack_alignment_needed; } void -set_gdbarch_extra_stack_alignment_needed (struct gdbarch *gdbarch, - int extra_stack_alignment_needed) +set_gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch, + int deprecated_extra_stack_alignment_needed) { - gdbarch->extra_stack_alignment_needed = extra_stack_alignment_needed; + gdbarch->deprecated_extra_stack_alignment_needed = deprecated_extra_stack_alignment_needed; } int @@ -4890,6 +5225,32 @@ set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, gdbarch->save_dummy_frame_tos = save_dummy_frame_tos; } +int +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->unwind_dummy_id == 0) + internal_error (__FILE__, __LINE__, + "gdbarch: gdbarch_unwind_dummy_id invalid"); + if (gdbarch_debug >= 2) + fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n"); + return gdbarch->unwind_dummy_id (gdbarch, info); +} + +void +set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, + gdbarch_unwind_dummy_id_ftype unwind_dummy_id) +{ + gdbarch->unwind_dummy_id = unwind_dummy_id; +} + int gdbarch_parm_boundary (struct gdbarch *gdbarch) { @@ -5434,6 +5795,32 @@ set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch, 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. */ @@ -5992,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); @@ -6003,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,