/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
/* Dynamic architecture support for GDB, the GNU debugger.
- Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+
+ Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
+ Software Foundation, Inc.
This file is part of GDB.
#include "gdb-events.h"
#include "reggroups.h"
#include "osabi.h"
-#include "symfile.h" /* For entry_point_address. */
#include "gdb_obstack.h"
/* Static function declarations */
-static void verify_gdbarch (struct gdbarch *gdbarch);
static void alloc_gdbarch_data (struct gdbarch *);
-static void init_gdbarch_swap (struct gdbarch *);
-static void clear_gdbarch_swap (struct gdbarch *);
-static void swapout_gdbarch_swap (struct gdbarch *);
-static void swapin_gdbarch_swap (struct gdbarch *);
/* Non-zero if we want to trace architecture code. */
int pc_regnum;
int ps_regnum;
int fp0_regnum;
- int npc_regnum;
gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum;
gdbarch_ecoff_reg_to_regnum_ftype *ecoff_reg_to_regnum;
gdbarch_dwarf_reg_to_regnum_ftype *dwarf_reg_to_regnum;
gdbarch_deprecated_dummy_write_sp_ftype *deprecated_dummy_write_sp;
int deprecated_register_size;
int call_dummy_location;
- gdbarch_deprecated_call_dummy_address_ftype *deprecated_call_dummy_address;
CORE_ADDR deprecated_call_dummy_start_offset;
CORE_ADDR deprecated_call_dummy_breakpoint_offset;
int deprecated_call_dummy_length;
LONGEST * deprecated_call_dummy_words;
int deprecated_sizeof_call_dummy_words;
- int deprecated_call_dummy_stack_adjust;
gdbarch_deprecated_fix_call_dummy_ftype *deprecated_fix_call_dummy;
gdbarch_push_dummy_code_ftype *push_dummy_code;
gdbarch_deprecated_push_dummy_frame_ftype *deprecated_push_dummy_frame;
- int deprecated_extra_stack_alignment_needed;
gdbarch_deprecated_do_registers_info_ftype *deprecated_do_registers_info;
gdbarch_print_registers_info_ftype *print_registers_info;
gdbarch_print_float_info_ftype *print_float_info;
gdbarch_pointer_to_address_ftype *pointer_to_address;
gdbarch_address_to_pointer_ftype *address_to_pointer;
gdbarch_integer_to_address_ftype *integer_to_address;
- gdbarch_return_value_on_stack_ftype *return_value_on_stack;
gdbarch_deprecated_pop_frame_ftype *deprecated_pop_frame;
gdbarch_deprecated_store_struct_return_ftype *deprecated_store_struct_return;
+ gdbarch_return_value_ftype *return_value;
+ gdbarch_return_value_on_stack_ftype *return_value_on_stack;
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;
gdbarch_deprecated_store_return_value_ftype *deprecated_store_return_value;
- gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
- gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
gdbarch_use_struct_convention_ftype *use_struct_convention;
+ gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
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;
gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
+ gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address;
gdbarch_memory_insert_breakpoint_ftype *memory_insert_breakpoint;
gdbarch_memory_remove_breakpoint_ftype *memory_remove_breakpoint;
CORE_ADDR decr_pc_after_break;
CORE_ADDR function_start_offset;
gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
CORE_ADDR frame_args_skip;
- gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
+ gdbarch_deprecated_frameless_function_invocation_ftype *deprecated_frameless_function_invocation;
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_deprecated_frame_locals_address_ftype *deprecated_frame_locals_address;
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_deprecated_stack_align_ftype *deprecated_stack_align;
gdbarch_frame_align_ftype *frame_align;
- gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr;
+ gdbarch_deprecated_reg_struct_has_addr_ftype *deprecated_reg_struct_has_addr;
+ gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
int frame_red_zone_size;
int parm_boundary;
const struct floatformat * float_format;
gdbarch_software_single_step_ftype *software_single_step;
gdbarch_print_insn_ftype *print_insn;
gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
+ gdbarch_skip_solib_resolver_ftype *skip_solib_resolver;
gdbarch_in_solib_call_trampoline_ftype *in_solib_call_trampoline;
gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
- gdbarch_pc_in_sigtramp_ftype *pc_in_sigtramp;
+ gdbarch_deprecated_pc_in_sigtramp_ftype *deprecated_pc_in_sigtramp;
gdbarch_sigtramp_start_ftype *sigtramp_start;
gdbarch_sigtramp_end_ftype *sigtramp_end;
gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
gdbarch_register_reggroup_p_ftype *register_reggroup_p;
gdbarch_fetch_pointer_argument_ftype *fetch_pointer_argument;
+ gdbarch_regset_from_core_section_ftype *regset_from_core_section;
};
-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, /* deprecated_dummy_write_sp */
0, /* deprecated_register_size */
0, /* call_dummy_location */
- 0, /* deprecated_call_dummy_address */
0, /* deprecated_call_dummy_start_offset */
0, /* deprecated_call_dummy_breakpoint_offset */
0, /* deprecated_call_dummy_length */
0, /* deprecated_call_dummy_words */
0, /* deprecated_sizeof_call_dummy_words */
- 0, /* deprecated_call_dummy_stack_adjust */
0, /* deprecated_fix_call_dummy */
0, /* push_dummy_code */
0, /* deprecated_push_dummy_frame */
- 0, /* deprecated_extra_stack_alignment_needed */
0, /* deprecated_do_registers_info */
default_print_registers_info, /* print_registers_info */
0, /* print_float_info */
0, /* cannot_fetch_register */
0, /* cannot_store_register */
0, /* get_longjmp_target */
- generic_pc_in_call_dummy, /* deprecated_pc_in_call_dummy */
+ deprecated_pc_in_call_dummy, /* deprecated_pc_in_call_dummy */
0, /* deprecated_init_frame_pc_first */
0, /* deprecated_init_frame_pc */
0, /* believe_pcc_promotion */
0, /* pointer_to_address */
0, /* address_to_pointer */
0, /* integer_to_address */
- 0, /* return_value_on_stack */
0, /* deprecated_pop_frame */
0, /* deprecated_store_struct_return */
+ 0, /* return_value */
+ 0, /* return_value_on_stack */
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_extract_struct_value_address */
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, /* adjust_breakpoint_address */
0, /* memory_insert_breakpoint */
0, /* memory_remove_breakpoint */
0, /* decr_pc_after_break */
0, /* function_start_offset */
generic_remote_translate_xfer_address, /* remote_translate_xfer_address */
0, /* frame_args_skip */
- 0, /* frameless_function_invocation */
+ 0, /* deprecated_frameless_function_invocation */
0, /* deprecated_frame_chain */
0, /* deprecated_frame_chain_valid */
0, /* deprecated_frame_saved_pc */
get_frame_base, /* deprecated_frame_locals_address */
0, /* deprecated_saved_pc_after_call */
0, /* frame_num_args */
- 0, /* stack_align */
+ 0, /* deprecated_stack_align */
0, /* frame_align */
- 0, /* reg_struct_has_addr */
+ 0, /* deprecated_reg_struct_has_addr */
+ default_stabs_argument_has_addr, /* stabs_argument_has_addr */
0, /* frame_red_zone_size */
0, /* parm_boundary */
0, /* float_format */
0, /* double_format */
0, /* long_double_format */
- 0, /* convert_from_func_ptr_addr */
+ convert_from_func_ptr_addr_identity, /* convert_from_func_ptr_addr */
0, /* addr_bits_remove */
0, /* smash_text_address */
0, /* software_single_step */
0, /* print_insn */
0, /* skip_trampoline_code */
+ generic_skip_solib_resolver, /* skip_solib_resolver */
0, /* in_solib_call_trampoline */
0, /* in_solib_return_trampoline */
- 0, /* pc_in_sigtramp */
+ 0, /* deprecated_pc_in_sigtramp */
0, /* sigtramp_start */
0, /* sigtramp_end */
generic_in_function_epilogue_p, /* in_function_epilogue_p */
0, /* address_class_name_to_type_flags */
default_register_reggroup_p, /* register_reggroup_p */
0, /* fetch_pointer_argument */
+ 0, /* regset_from_core_section */
/* startup_gdbarch() */
};
struct gdbarch *current_gdbarch = &startup_gdbarch;
-/* Do any initialization needed for a non-multiarch configuration
- after the _initialize_MODULE functions have been run. */
-void
-initialize_non_multiarch (void)
-{
- alloc_gdbarch_data (&startup_gdbarch);
- /* Ensure that all swap areas are zeroed so that they again think
- they are starting from scratch. */
- clear_gdbarch_swap (&startup_gdbarch);
- init_gdbarch_swap (&startup_gdbarch);
-}
-
-
/* Create a new ``struct gdbarch'' based on information provided by
``struct gdbarch_info''. */
current_gdbarch->pc_regnum = -1;
current_gdbarch->ps_regnum = -1;
current_gdbarch->fp0_regnum = -1;
- current_gdbarch->npc_regnum = -1;
current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
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_pc_in_call_dummy = generic_pc_in_call_dummy;
- current_gdbarch->deprecated_register_convertible = deprecated_register_convertible_not;
+ current_gdbarch->deprecated_pc_in_call_dummy = deprecated_pc_in_call_dummy;
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->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->memory_insert_breakpoint = default_memory_insert_breakpoint;
current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
- current_gdbarch->decr_pc_after_break = -1;
- current_gdbarch->function_start_offset = -1;
current_gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
- current_gdbarch->frame_args_skip = -1;
- current_gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
current_gdbarch->deprecated_frame_args_address = get_frame_base;
current_gdbarch->deprecated_frame_locals_address = get_frame_base;
- current_gdbarch->convert_from_func_ptr_addr = core_addr_identity;
+ current_gdbarch->stabs_argument_has_addr = default_stabs_argument_has_addr;
+ current_gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr_identity;
current_gdbarch->addr_bits_remove = core_addr_identity;
current_gdbarch->smash_text_address = core_addr_identity;
current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
+ current_gdbarch->skip_solib_resolver = generic_skip_solib_resolver;
current_gdbarch->in_solib_call_trampoline = generic_in_solib_call_trampoline;
current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
- current_gdbarch->pc_in_sigtramp = legacy_pc_in_sigtramp;
+ current_gdbarch->deprecated_pc_in_sigtramp = legacy_pc_in_sigtramp;
current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
}
-/* Ensure that all values in a GDBARCH are reasonable. */
+/* Ensure that all values in a GDBARCH are reasonable. */
+
+/* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
+ just happens to match the global variable ``current_gdbarch''. That
+ way macros refering to that variable get the local and not the global
+ version - ulgh. Once everything is parameterised with gdbarch, this
+ will go away. */
static void
-verify_gdbarch (struct gdbarch *gdbarch)
+verify_gdbarch (struct gdbarch *current_gdbarch)
{
struct ui_file *log;
struct cleanup *cleanups;
log = mem_fileopen ();
cleanups = make_cleanup_ui_file_delete (log);
/* fundamental */
- if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
+ if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
fprintf_unfiltered (log, "\n\tbyte-order");
- if (gdbarch->bfd_arch_info == NULL)
+ if (current_gdbarch->bfd_arch_info == NULL)
fprintf_unfiltered (log, "\n\tbfd_arch_info");
/* Check those that need to be defined for the given multi-arch level. */
/* Skip verify of short_bit, invalid_p == 0 */
/* Skip verify of double_bit, invalid_p == 0 */
/* Skip verify of long_double_bit, invalid_p == 0 */
/* Skip verify of ptr_bit, invalid_p == 0 */
- if (gdbarch->addr_bit == 0)
- gdbarch->addr_bit = TARGET_PTR_BIT;
+ if (current_gdbarch->addr_bit == 0)
+ current_gdbarch->addr_bit = TARGET_PTR_BIT;
/* Skip verify of bfd_vma_bit, invalid_p == 0 */
- if (gdbarch->char_signed == -1)
- gdbarch->char_signed = 1;
+ if (current_gdbarch->char_signed == -1)
+ current_gdbarch->char_signed = 1;
/* Skip verify of read_pc, has predicate */
/* Skip verify of write_pc, invalid_p == 0 */
/* Skip verify of read_sp, has predicate */
/* Skip verify of pseudo_register_read, has predicate */
/* Skip verify of pseudo_register_write, has predicate */
if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->num_regs == -1))
+ && (current_gdbarch->num_regs == -1))
fprintf_unfiltered (log, "\n\tnum_regs");
/* Skip verify of num_pseudo_regs, invalid_p == 0 */
/* Skip verify of sp_regnum, invalid_p == 0 */
/* Skip verify of pc_regnum, invalid_p == 0 */
/* Skip verify of ps_regnum, invalid_p == 0 */
/* Skip verify of fp0_regnum, invalid_p == 0 */
- /* Skip verify of npc_regnum, invalid_p == 0 */
/* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
/* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
/* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
/* Skip verify of deprecated_push_return_address, has predicate */
/* Skip verify of deprecated_dummy_write_sp, has predicate */
/* Skip verify of call_dummy_location, invalid_p == 0 */
- /* Skip verify of deprecated_call_dummy_address, has predicate */
/* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
/* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */
- /* Skip verify of deprecated_call_dummy_stack_adjust, has predicate */
/* Skip verify of deprecated_fix_call_dummy, has predicate */
/* Skip verify of push_dummy_code, has predicate */
/* Skip verify of deprecated_push_dummy_frame, has predicate */
- /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
/* Skip verify of deprecated_do_registers_info, has predicate */
/* Skip verify of print_registers_info, invalid_p == 0 */
/* Skip verify of print_float_info, has predicate */
/* Skip verify of deprecated_init_frame_pc_first, has predicate */
/* Skip verify of deprecated_init_frame_pc, has predicate */
/* Skip verify of deprecated_get_saved_register, has predicate */
- /* Skip verify of deprecated_register_convertible, invalid_p == 0 */
+ /* Skip verify of deprecated_register_convertible, has predicate */
/* 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 pointer_to_address, invalid_p == 0 */
/* Skip verify of address_to_pointer, invalid_p == 0 */
/* Skip verify of integer_to_address, has predicate */
- /* Skip verify of return_value_on_stack, invalid_p == 0 */
/* Skip verify of deprecated_pop_frame, has predicate */
/* Skip verify of deprecated_store_struct_return, has predicate */
+ /* Skip verify of return_value, has predicate */
+ /* Skip verify of return_value_on_stack, invalid_p == 0 */
/* 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 */
+ /* Skip verify of deprecated_extract_struct_value_address, 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))
+ && (current_gdbarch->skip_prologue == 0))
fprintf_unfiltered (log, "\n\tskip_prologue");
- /* Skip verify of prologue_frameless_p, invalid_p == 0 */
if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->inner_than == 0))
+ && (current_gdbarch->inner_than == 0))
fprintf_unfiltered (log, "\n\tinner_than");
if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->breakpoint_from_pc == 0))
+ && (current_gdbarch->breakpoint_from_pc == 0))
fprintf_unfiltered (log, "\n\tbreakpoint_from_pc");
+ /* Skip verify of adjust_breakpoint_address, has predicate */
/* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
/* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
- if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->decr_pc_after_break == -1))
- fprintf_unfiltered (log, "\n\tdecr_pc_after_break");
- if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->function_start_offset == -1))
- fprintf_unfiltered (log, "\n\tfunction_start_offset");
+ /* Skip verify of decr_pc_after_break, invalid_p == 0 */
+ /* Skip verify of function_start_offset, invalid_p == 0 */
/* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
- if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->frame_args_skip == -1))
- fprintf_unfiltered (log, "\n\tframe_args_skip");
- /* Skip verify of frameless_function_invocation, invalid_p == 0 */
+ /* Skip verify of frame_args_skip, invalid_p == 0 */
+ /* Skip verify of deprecated_frameless_function_invocation, has predicate */
/* 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 deprecated_frame_locals_address, has predicate */
/* 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 deprecated_stack_align, has predicate */
/* Skip verify of frame_align, has predicate */
- /* Skip verify of reg_struct_has_addr, has predicate */
- if (gdbarch->float_format == 0)
- gdbarch->float_format = default_float_format (gdbarch);
- if (gdbarch->double_format == 0)
- gdbarch->double_format = default_double_format (gdbarch);
- if (gdbarch->long_double_format == 0)
- gdbarch->long_double_format = default_double_format (gdbarch);
+ /* Skip verify of deprecated_reg_struct_has_addr, has predicate */
+ /* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
+ if (current_gdbarch->float_format == 0)
+ current_gdbarch->float_format = default_float_format (current_gdbarch);
+ if (current_gdbarch->double_format == 0)
+ current_gdbarch->double_format = default_double_format (current_gdbarch);
+ if (current_gdbarch->long_double_format == 0)
+ current_gdbarch->long_double_format = default_double_format (current_gdbarch);
/* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
/* Skip verify of addr_bits_remove, invalid_p == 0 */
/* Skip verify of smash_text_address, invalid_p == 0 */
/* Skip verify of software_single_step, has predicate */
if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->print_insn == 0))
+ && (current_gdbarch->print_insn == 0))
fprintf_unfiltered (log, "\n\tprint_insn");
/* Skip verify of skip_trampoline_code, invalid_p == 0 */
+ /* Skip verify of skip_solib_resolver, invalid_p == 0 */
/* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
/* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
- /* Skip verify of pc_in_sigtramp, invalid_p == 0 */
+ /* Skip verify of deprecated_pc_in_sigtramp, has predicate */
/* Skip verify of sigtramp_start, has predicate */
/* Skip verify of sigtramp_end, has predicate */
/* Skip verify of in_function_epilogue_p, invalid_p == 0 */
/* Skip verify of address_class_name_to_type_flags, has predicate */
/* Skip verify of register_reggroup_p, invalid_p == 0 */
/* Skip verify of fetch_pointer_argument, has predicate */
+ /* Skip verify of regset_from_core_section, has predicate */
buf = ui_file_xstrdup (log, &dummy);
make_cleanup (xfree, buf);
if (strlen (buf) > 0)
will go away. */
void
-gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
+gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
{
fprintf_unfiltered (file,
"gdbarch_dump: GDB_MULTI_ARCH = %d\n",
GDB_MULTI_ARCH);
+ fprintf_unfiltered (file,
+ "gdbarch_dump: convert_from_func_ptr_addr = 0x%08lx\n",
+ (long) current_gdbarch->convert_from_func_ptr_addr);
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_frame_align_p() = %d\n",
gdbarch_frame_align_p (current_gdbarch));
fprintf_unfiltered (file,
"gdbarch_dump: frame_align = 0x%08lx\n",
(long) current_gdbarch->frame_align);
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_regset_from_core_section_p() = %d\n",
+ gdbarch_regset_from_core_section_p (current_gdbarch));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: regset_from_core_section = 0x%08lx\n",
+ (long) current_gdbarch->regset_from_core_section);
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_return_value_p() = %d\n",
+ gdbarch_return_value_p (current_gdbarch));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: return_value = 0x%08lx\n",
+ (long) current_gdbarch->return_value);
fprintf_unfiltered (file,
"gdbarch_dump: in_function_epilogue_p = 0x%08lx\n",
(long) current_gdbarch->in_function_epilogue_p);
fprintf_unfiltered (file,
"gdbarch_dump: register_reggroup_p = 0x%08lx\n",
(long) current_gdbarch->register_reggroup_p);
+ fprintf_unfiltered (file,
+ "gdbarch_dump: stabs_argument_has_addr = 0x%08lx\n",
+ (long) current_gdbarch->stabs_argument_has_addr);
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
gdbarch_pseudo_register_read_p (current_gdbarch));
(long) current_gdbarch->addr_bits_remove
/*ADDR_BITS_REMOVE ()*/);
#endif
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_adjust_breakpoint_address_p() = %d\n",
+ gdbarch_adjust_breakpoint_address_p (current_gdbarch));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: adjust_breakpoint_address = 0x%08lx\n",
+ (long) current_gdbarch->adjust_breakpoint_address);
#ifdef BELIEVE_PCC_PROMOTION
fprintf_unfiltered (file,
"gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
fprintf_unfiltered (file,
"gdbarch_dump: construct_inferior_arguments = 0x%08lx\n",
(long) current_gdbarch->construct_inferior_arguments);
-#ifdef CONVERT_FROM_FUNC_PTR_ADDR
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "CONVERT_FROM_FUNC_PTR_ADDR(addr)",
- XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr)));
- fprintf_unfiltered (file,
- "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = <0x%08lx>\n",
- (long) current_gdbarch->convert_from_func_ptr_addr
- /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
-#endif
#ifdef CONVERT_REGISTER_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
(long) DECR_PC_AFTER_BREAK);
#endif
-#ifdef DEPRECATED_CALL_DUMMY_ADDRESS_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DEPRECATED_CALL_DUMMY_ADDRESS_P()",
- XSTRING (DEPRECATED_CALL_DUMMY_ADDRESS_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: DEPRECATED_CALL_DUMMY_ADDRESS_P() = %d\n",
- DEPRECATED_CALL_DUMMY_ADDRESS_P ());
-#endif
-#ifdef DEPRECATED_CALL_DUMMY_ADDRESS
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DEPRECATED_CALL_DUMMY_ADDRESS()",
- XSTRING (DEPRECATED_CALL_DUMMY_ADDRESS ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: DEPRECATED_CALL_DUMMY_ADDRESS = <0x%08lx>\n",
- (long) current_gdbarch->deprecated_call_dummy_address
- /*DEPRECATED_CALL_DUMMY_ADDRESS ()*/);
-#endif
#ifdef DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
"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",
#ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
- "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
- XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf)));
+ "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
+ XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->deprecated_extract_struct_value_address
/*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
#endif
-#ifdef 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",
"gdbarch_dump: DEPRECATED_FP_REGNUM = %d\n",
DEPRECATED_FP_REGNUM);
#endif
+#ifdef DEPRECATED_FRAMELESS_FUNCTION_INVOCATION_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_FRAMELESS_FUNCTION_INVOCATION_P()",
+ XSTRING (DEPRECATED_FRAMELESS_FUNCTION_INVOCATION_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_FRAMELESS_FUNCTION_INVOCATION_P() = %d\n",
+ DEPRECATED_FRAMELESS_FUNCTION_INVOCATION_P ());
+#endif
+#ifdef DEPRECATED_FRAMELESS_FUNCTION_INVOCATION
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_FRAMELESS_FUNCTION_INVOCATION(fi)",
+ XSTRING (DEPRECATED_FRAMELESS_FUNCTION_INVOCATION (fi)));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_frameless_function_invocation
+ /*DEPRECATED_FRAMELESS_FUNCTION_INVOCATION ()*/);
+#endif
#ifdef DEPRECATED_FRAME_ARGS_ADDRESS_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
(long) current_gdbarch->deprecated_pc_in_call_dummy
/*DEPRECATED_PC_IN_CALL_DUMMY ()*/);
#endif
+#ifdef DEPRECATED_PC_IN_SIGTRAMP_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_PC_IN_SIGTRAMP_P()",
+ XSTRING (DEPRECATED_PC_IN_SIGTRAMP_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_PC_IN_SIGTRAMP_P() = %d\n",
+ DEPRECATED_PC_IN_SIGTRAMP_P ());
+#endif
+#ifdef DEPRECATED_PC_IN_SIGTRAMP
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_PC_IN_SIGTRAMP(pc, name)",
+ XSTRING (DEPRECATED_PC_IN_SIGTRAMP (pc, name)));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_PC_IN_SIGTRAMP = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_pc_in_sigtramp
+ /*DEPRECATED_PC_IN_SIGTRAMP ()*/);
+#endif
#ifdef DEPRECATED_POP_FRAME_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
(long) current_gdbarch->deprecated_push_return_address
/*DEPRECATED_PUSH_RETURN_ADDRESS ()*/);
#endif
+#ifdef DEPRECATED_REGISTER_BYTE_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REGISTER_BYTE_P()",
+ XSTRING (DEPRECATED_REGISTER_BYTE_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REGISTER_BYTE_P() = %d\n",
+ DEPRECATED_REGISTER_BYTE_P ());
+#endif
+#ifdef DEPRECATED_REGISTER_BYTE
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REGISTER_BYTE(reg_nr)",
+ XSTRING (DEPRECATED_REGISTER_BYTE (reg_nr)));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REGISTER_BYTE = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_register_byte
+ /*DEPRECATED_REGISTER_BYTE ()*/);
+#endif
#ifdef DEPRECATED_REGISTER_BYTES
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_REGISTER_BYTES # %s\n",
"gdbarch_dump: DEPRECATED_REGISTER_BYTES = %d\n",
DEPRECATED_REGISTER_BYTES);
#endif
+#ifdef DEPRECATED_REGISTER_CONVERTIBLE_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REGISTER_CONVERTIBLE_P()",
+ XSTRING (DEPRECATED_REGISTER_CONVERTIBLE_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REGISTER_CONVERTIBLE_P() = %d\n",
+ DEPRECATED_REGISTER_CONVERTIBLE_P ());
+#endif
#ifdef DEPRECATED_REGISTER_CONVERTIBLE
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
(long) current_gdbarch->deprecated_register_convert_to_virtual
/*DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL ()*/);
#endif
+#ifdef DEPRECATED_REGISTER_RAW_SIZE_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REGISTER_RAW_SIZE_P()",
+ XSTRING (DEPRECATED_REGISTER_RAW_SIZE_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REGISTER_RAW_SIZE_P() = %d\n",
+ DEPRECATED_REGISTER_RAW_SIZE_P ());
+#endif
+#ifdef DEPRECATED_REGISTER_RAW_SIZE
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REGISTER_RAW_SIZE(reg_nr)",
+ XSTRING (DEPRECATED_REGISTER_RAW_SIZE (reg_nr)));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REGISTER_RAW_SIZE = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_register_raw_size
+ /*DEPRECATED_REGISTER_RAW_SIZE ()*/);
+#endif
#ifdef DEPRECATED_REGISTER_SIZE
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
"gdbarch_dump: DEPRECATED_REGISTER_SIZE = %d\n",
DEPRECATED_REGISTER_SIZE);
#endif
+#ifdef DEPRECATED_REGISTER_VIRTUAL_SIZE_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REGISTER_VIRTUAL_SIZE_P()",
+ XSTRING (DEPRECATED_REGISTER_VIRTUAL_SIZE_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_SIZE_P() = %d\n",
+ DEPRECATED_REGISTER_VIRTUAL_SIZE_P ());
+#endif
+#ifdef DEPRECATED_REGISTER_VIRTUAL_SIZE
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REGISTER_VIRTUAL_SIZE(reg_nr)",
+ XSTRING (DEPRECATED_REGISTER_VIRTUAL_SIZE (reg_nr)));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_register_virtual_size
+ /*DEPRECATED_REGISTER_VIRTUAL_SIZE ()*/);
+#endif
+#ifdef DEPRECATED_REGISTER_VIRTUAL_TYPE_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REGISTER_VIRTUAL_TYPE_P()",
+ XSTRING (DEPRECATED_REGISTER_VIRTUAL_TYPE_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_TYPE_P() = %d\n",
+ DEPRECATED_REGISTER_VIRTUAL_TYPE_P ());
+#endif
+#ifdef DEPRECATED_REGISTER_VIRTUAL_TYPE
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REGISTER_VIRTUAL_TYPE(reg_nr)",
+ XSTRING (DEPRECATED_REGISTER_VIRTUAL_TYPE (reg_nr)));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REGISTER_VIRTUAL_TYPE = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_register_virtual_type
+ /*DEPRECATED_REGISTER_VIRTUAL_TYPE ()*/);
+#endif
+#ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
+ XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REG_STRUCT_HAS_ADDR_P() = %d\n",
+ DEPRECATED_REG_STRUCT_HAS_ADDR_P ());
+#endif
+#ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
+ XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p, type)));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_REG_STRUCT_HAS_ADDR = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_reg_struct_has_addr
+ /*DEPRECATED_REG_STRUCT_HAS_ADDR ()*/);
+#endif
#ifdef DEPRECATED_SAVED_PC_AFTER_CALL_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS = %d\n",
DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
#endif
+#ifdef DEPRECATED_STACK_ALIGN_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_STACK_ALIGN_P()",
+ XSTRING (DEPRECATED_STACK_ALIGN_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_STACK_ALIGN_P() = %d\n",
+ DEPRECATED_STACK_ALIGN_P ());
+#endif
+#ifdef DEPRECATED_STACK_ALIGN
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_STACK_ALIGN(sp)",
+ XSTRING (DEPRECATED_STACK_ALIGN (sp)));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_STACK_ALIGN = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_stack_align
+ /*DEPRECATED_STACK_ALIGN ()*/);
+#endif
#ifdef DEPRECATED_STORE_RETURN_VALUE
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
(long) current_gdbarch->extract_return_value
/*EXTRACT_RETURN_VALUE ()*/);
#endif
-#ifdef EXTRACT_STRUCT_VALUE_ADDRESS_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "EXTRACT_STRUCT_VALUE_ADDRESS_P()",
- XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
- EXTRACT_STRUCT_VALUE_ADDRESS_P ());
-#endif
-#ifdef EXTRACT_STRUCT_VALUE_ADDRESS
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
- XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
- fprintf_unfiltered (file,
- "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
- (long) current_gdbarch->extract_struct_value_address
- /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
-#endif
#ifdef FETCH_POINTER_ARGUMENT_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"gdbarch_dump: FP0_REGNUM = %d\n",
FP0_REGNUM);
#endif
-#ifdef FRAMELESS_FUNCTION_INVOCATION
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FRAMELESS_FUNCTION_INVOCATION(fi)",
- XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi)));
- fprintf_unfiltered (file,
- "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n",
- (long) current_gdbarch->frameless_function_invocation
- /*FRAMELESS_FUNCTION_INVOCATION ()*/);
-#endif
#ifdef FRAME_ARGS_SKIP
fprintf_unfiltered (file,
"gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
"gdbarch_dump: NAME_OF_MALLOC = %s\n",
NAME_OF_MALLOC);
#endif
-#ifdef NPC_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: NPC_REGNUM # %s\n",
- XSTRING (NPC_REGNUM));
- fprintf_unfiltered (file,
- "gdbarch_dump: NPC_REGNUM = %d\n",
- NPC_REGNUM);
-#endif
#ifdef NUM_PSEUDO_REGS
fprintf_unfiltered (file,
"gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
"gdbarch_dump: PARM_BOUNDARY = %d\n",
PARM_BOUNDARY);
#endif
-#ifdef PC_IN_SIGTRAMP
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "PC_IN_SIGTRAMP(pc, name)",
- XSTRING (PC_IN_SIGTRAMP (pc, name)));
- fprintf_unfiltered (file,
- "gdbarch_dump: PC_IN_SIGTRAMP = <0x%08lx>\n",
- (long) current_gdbarch->pc_in_sigtramp
- /*PC_IN_SIGTRAMP ()*/);
-#endif
#ifdef PC_REGNUM
fprintf_unfiltered (file,
"gdbarch_dump: PC_REGNUM # %s\n",
fprintf_unfiltered (file,
"gdbarch_dump: print_vector_info = 0x%08lx\n",
(long) current_gdbarch->print_vector_info);
-#ifdef PROLOGUE_FRAMELESS_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "PROLOGUE_FRAMELESS_P(ip)",
- XSTRING (PROLOGUE_FRAMELESS_P (ip)));
- fprintf_unfiltered (file,
- "gdbarch_dump: PROLOGUE_FRAMELESS_P = <0x%08lx>\n",
- (long) current_gdbarch->prologue_frameless_p
- /*PROLOGUE_FRAMELESS_P ()*/);
-#endif
#ifdef PS_REGNUM
fprintf_unfiltered (file,
"gdbarch_dump: PS_REGNUM # %s\n",
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",
- "REGISTER_BYTE_P()",
- XSTRING (REGISTER_BYTE_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_BYTE_P() = %d\n",
- REGISTER_BYTE_P ());
-#endif
-#ifdef REGISTER_BYTE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_BYTE(reg_nr)",
- XSTRING (REGISTER_BYTE (reg_nr)));
- fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_BYTE = <0x%08lx>\n",
- (long) current_gdbarch->deprecated_register_byte
- /*REGISTER_BYTE ()*/);
-#endif
#ifdef REGISTER_BYTES_OK_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
(long) current_gdbarch->register_name
/*REGISTER_NAME ()*/);
#endif
-#ifdef REGISTER_RAW_SIZE_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_RAW_SIZE_P()",
- XSTRING (REGISTER_RAW_SIZE_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_RAW_SIZE_P() = %d\n",
- REGISTER_RAW_SIZE_P ());
-#endif
-#ifdef REGISTER_RAW_SIZE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_RAW_SIZE(reg_nr)",
- XSTRING (REGISTER_RAW_SIZE (reg_nr)));
- fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n",
- (long) current_gdbarch->deprecated_register_raw_size
- /*REGISTER_RAW_SIZE ()*/);
-#endif
#ifdef REGISTER_SIM_REGNO
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
fprintf_unfiltered (file,
"gdbarch_dump: register_type = 0x%08lx\n",
(long) current_gdbarch->register_type);
-#ifdef REGISTER_VIRTUAL_SIZE_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_VIRTUAL_SIZE_P()",
- XSTRING (REGISTER_VIRTUAL_SIZE_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_VIRTUAL_SIZE_P() = %d\n",
- REGISTER_VIRTUAL_SIZE_P ());
-#endif
-#ifdef REGISTER_VIRTUAL_SIZE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_VIRTUAL_SIZE(reg_nr)",
- XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr)));
- fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
- (long) current_gdbarch->deprecated_register_virtual_size
- /*REGISTER_VIRTUAL_SIZE ()*/);
-#endif
-#ifdef REGISTER_VIRTUAL_TYPE_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_VIRTUAL_TYPE_P()",
- XSTRING (REGISTER_VIRTUAL_TYPE_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_VIRTUAL_TYPE_P() = %d\n",
- REGISTER_VIRTUAL_TYPE_P ());
-#endif
-#ifdef REGISTER_VIRTUAL_TYPE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_VIRTUAL_TYPE(reg_nr)",
- XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr)));
- fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_VIRTUAL_TYPE = <0x%08lx>\n",
- (long) current_gdbarch->deprecated_register_virtual_type
- /*REGISTER_VIRTUAL_TYPE ()*/);
-#endif
-#ifdef REG_STRUCT_HAS_ADDR_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REG_STRUCT_HAS_ADDR_P()",
- XSTRING (REG_STRUCT_HAS_ADDR_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: REG_STRUCT_HAS_ADDR_P() = %d\n",
- REG_STRUCT_HAS_ADDR_P ());
-#endif
-#ifdef REG_STRUCT_HAS_ADDR
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REG_STRUCT_HAS_ADDR(gcc_p, type)",
- XSTRING (REG_STRUCT_HAS_ADDR (gcc_p, type)));
- fprintf_unfiltered (file,
- "gdbarch_dump: REG_STRUCT_HAS_ADDR = <0x%08lx>\n",
- (long) current_gdbarch->reg_struct_has_addr
- /*REG_STRUCT_HAS_ADDR ()*/);
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: remote_translate_xfer_address = 0x%08lx\n",
(long) current_gdbarch->remote_translate_xfer_address);
(long) current_gdbarch->skip_prologue
/*SKIP_PROLOGUE ()*/);
#endif
+ fprintf_unfiltered (file,
+ "gdbarch_dump: skip_solib_resolver = 0x%08lx\n",
+ (long) current_gdbarch->skip_solib_resolver);
#ifdef SKIP_TRAMPOLINE_CODE
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
(long) current_gdbarch->stab_reg_to_regnum
/*STAB_REG_TO_REGNUM ()*/);
#endif
-#ifdef STACK_ALIGN_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "STACK_ALIGN_P()",
- XSTRING (STACK_ALIGN_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: STACK_ALIGN_P() = %d\n",
- STACK_ALIGN_P ());
-#endif
-#ifdef STACK_ALIGN
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "STACK_ALIGN(sp)",
- XSTRING (STACK_ALIGN (sp)));
- fprintf_unfiltered (file,
- "gdbarch_dump: STACK_ALIGN = <0x%08lx>\n",
- (long) current_gdbarch->stack_align
- /*STACK_ALIGN ()*/);
-#endif
#ifdef STORE_RETURN_VALUE
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
gdbarch->fp0_regnum = fp0_regnum;
}
-int
-gdbarch_npc_regnum (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- /* Skip verify of npc_regnum, invalid_p == 0 */
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_npc_regnum called\n");
- return gdbarch->npc_regnum;
-}
-
-void
-set_gdbarch_npc_regnum (struct gdbarch *gdbarch,
- int npc_regnum)
-{
- gdbarch->npc_regnum = npc_regnum;
-}
-
int
gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
{
gdbarch->call_dummy_location = call_dummy_location;
}
-int
-gdbarch_deprecated_call_dummy_address_p (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- return gdbarch->deprecated_call_dummy_address != NULL;
-}
-
-CORE_ADDR
-gdbarch_deprecated_call_dummy_address (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->deprecated_call_dummy_address != NULL);
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_address called\n");
- return gdbarch->deprecated_call_dummy_address ();
-}
-
-void
-set_gdbarch_deprecated_call_dummy_address (struct gdbarch *gdbarch,
- gdbarch_deprecated_call_dummy_address_ftype deprecated_call_dummy_address)
-{
- gdbarch->deprecated_call_dummy_address = deprecated_call_dummy_address;
-}
-
CORE_ADDR
gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch)
{
gdbarch->deprecated_sizeof_call_dummy_words = deprecated_sizeof_call_dummy_words;
}
-int
-gdbarch_deprecated_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- return gdbarch->deprecated_call_dummy_stack_adjust != 0;
-}
-
-int
-gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_stack_adjust called\n");
- return gdbarch->deprecated_call_dummy_stack_adjust;
-}
-
-void
-set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch,
- int deprecated_call_dummy_stack_adjust)
-{
- gdbarch->deprecated_call_dummy_stack_adjust = deprecated_call_dummy_stack_adjust;
-}
-
int
gdbarch_deprecated_fix_call_dummy_p (struct gdbarch *gdbarch)
{
gdbarch->deprecated_push_dummy_frame = deprecated_push_dummy_frame;
}
-int
-gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extra_stack_alignment_needed called\n");
- return gdbarch->deprecated_extra_stack_alignment_needed;
-}
-
-void
-set_gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch,
- int deprecated_extra_stack_alignment_needed)
-{
- gdbarch->deprecated_extra_stack_alignment_needed = deprecated_extra_stack_alignment_needed;
-}
-
int
gdbarch_deprecated_do_registers_info_p (struct gdbarch *gdbarch)
{
gdbarch_deprecated_pc_in_call_dummy_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- return gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy;
+ return gdbarch->deprecated_pc_in_call_dummy != deprecated_pc_in_call_dummy;
}
int
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->deprecated_pc_in_call_dummy != NULL);
- /* Do not check predicate: gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy, allow call. */
+ /* Do not check predicate: gdbarch->deprecated_pc_in_call_dummy != deprecated_pc_in_call_dummy, allow call. */
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pc_in_call_dummy called\n");
return gdbarch->deprecated_pc_in_call_dummy (pc, sp, frame_address);
gdbarch->deprecated_get_saved_register = deprecated_get_saved_register;
}
+int
+gdbarch_deprecated_register_convertible_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->deprecated_register_convertible != NULL;
+}
+
int
gdbarch_deprecated_register_convertible (struct gdbarch *gdbarch, int nr)
{
gdbarch->integer_to_address = integer_to_address;
}
-int
-gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type)
-{
- gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->return_value_on_stack != NULL);
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value_on_stack called\n");
- return gdbarch->return_value_on_stack (type);
-}
-
-void
-set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch,
- gdbarch_return_value_on_stack_ftype return_value_on_stack)
-{
- gdbarch->return_value_on_stack = return_value_on_stack;
-}
-
int
gdbarch_deprecated_pop_frame_p (struct gdbarch *gdbarch)
{
gdbarch->deprecated_store_struct_return = deprecated_store_struct_return;
}
+int
+gdbarch_return_value_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->return_value != NULL;
+}
+
+enum return_value_convention
+gdbarch_return_value (struct gdbarch *gdbarch, struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf)
+{
+ gdb_assert (gdbarch != NULL);
+ gdb_assert (gdbarch->return_value != NULL);
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value called\n");
+ return gdbarch->return_value (gdbarch, valtype, regcache, readbuf, writebuf);
+}
+
+void
+set_gdbarch_return_value (struct gdbarch *gdbarch,
+ gdbarch_return_value_ftype return_value)
+{
+ gdbarch->return_value = return_value;
+}
+
+int
+gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type)
+{
+ gdb_assert (gdbarch != NULL);
+ gdb_assert (gdbarch->return_value_on_stack != NULL);
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value_on_stack called\n");
+ return gdbarch->return_value_on_stack (type);
+}
+
+void
+set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch,
+ gdbarch_return_value_on_stack_ftype return_value_on_stack)
+{
+ gdbarch->return_value_on_stack = return_value_on_stack;
+}
+
void
gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, void *valbuf)
{
}
int
-gdbarch_extract_struct_value_address_p (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- return gdbarch->extract_struct_value_address != NULL;
-}
-
-CORE_ADDR
-gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
+gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
{
gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->extract_struct_value_address != NULL);
+ gdb_assert (gdbarch->use_struct_convention != NULL);
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n");
- return gdbarch->extract_struct_value_address (regcache);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_use_struct_convention called\n");
+ return gdbarch->use_struct_convention (gcc_p, value_type);
}
void
-set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch,
- gdbarch_extract_struct_value_address_ftype extract_struct_value_address)
+set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
+ gdbarch_use_struct_convention_ftype use_struct_convention)
{
- gdbarch->extract_struct_value_address = extract_struct_value_address;
+ gdbarch->use_struct_convention = use_struct_convention;
}
int
}
CORE_ADDR
-gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf)
+gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
- return gdbarch->deprecated_extract_struct_value_address (regbuf);
+ return gdbarch->deprecated_extract_struct_value_address (regcache);
}
void
gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
}
-int
-gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
-{
- gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->use_struct_convention != NULL);
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_use_struct_convention called\n");
- return gdbarch->use_struct_convention (gcc_p, value_type);
-}
-
-void
-set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
- gdbarch_use_struct_convention_ftype use_struct_convention)
-{
- gdbarch->use_struct_convention = use_struct_convention;
-}
-
int
gdbarch_deprecated_frame_init_saved_regs_p (struct gdbarch *gdbarch)
{
gdbarch->skip_prologue = skip_prologue;
}
-int
-gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, CORE_ADDR ip)
-{
- gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->prologue_frameless_p != NULL);
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_prologue_frameless_p called\n");
- return gdbarch->prologue_frameless_p (ip);
-}
-
-void
-set_gdbarch_prologue_frameless_p (struct gdbarch *gdbarch,
- gdbarch_prologue_frameless_p_ftype prologue_frameless_p)
-{
- gdbarch->prologue_frameless_p = prologue_frameless_p;
-}
-
int
gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
{
gdbarch->breakpoint_from_pc = breakpoint_from_pc;
}
+int
+gdbarch_adjust_breakpoint_address_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->adjust_breakpoint_address != NULL;
+}
+
+CORE_ADDR
+gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
+{
+ gdb_assert (gdbarch != NULL);
+ gdb_assert (gdbarch->adjust_breakpoint_address != NULL);
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_adjust_breakpoint_address called\n");
+ return gdbarch->adjust_breakpoint_address (gdbarch, bpaddr);
+}
+
+void
+set_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch,
+ gdbarch_adjust_breakpoint_address_ftype adjust_breakpoint_address)
+{
+ gdbarch->adjust_breakpoint_address = adjust_breakpoint_address;
+}
+
int
gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
{
gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- /* Check variable changed from pre-default. */
- gdb_assert (gdbarch->decr_pc_after_break != -1);
+ /* Skip verify of decr_pc_after_break, invalid_p == 0 */
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
return gdbarch->decr_pc_after_break;
gdbarch_function_start_offset (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- /* Check variable changed from pre-default. */
- gdb_assert (gdbarch->function_start_offset != -1);
+ /* Skip verify of function_start_offset, invalid_p == 0 */
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_function_start_offset called\n");
return gdbarch->function_start_offset;
gdbarch_frame_args_skip (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- /* Check variable changed from pre-default. */
- gdb_assert (gdbarch->frame_args_skip != -1);
+ /* Skip verify of frame_args_skip, invalid_p == 0 */
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
return gdbarch->frame_args_skip;
}
int
-gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi)
+gdbarch_deprecated_frameless_function_invocation_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->deprecated_frameless_function_invocation != NULL;
+}
+
+int
+gdbarch_deprecated_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi)
{
gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->frameless_function_invocation != NULL);
+ gdb_assert (gdbarch->deprecated_frameless_function_invocation != NULL);
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_frameless_function_invocation called\n");
- return gdbarch->frameless_function_invocation (fi);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frameless_function_invocation called\n");
+ return gdbarch->deprecated_frameless_function_invocation (fi);
}
void
-set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch,
- gdbarch_frameless_function_invocation_ftype frameless_function_invocation)
+set_gdbarch_deprecated_frameless_function_invocation (struct gdbarch *gdbarch,
+ gdbarch_deprecated_frameless_function_invocation_ftype deprecated_frameless_function_invocation)
{
- gdbarch->frameless_function_invocation = frameless_function_invocation;
+ gdbarch->deprecated_frameless_function_invocation = deprecated_frameless_function_invocation;
}
int
}
int
-gdbarch_stack_align_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- return gdbarch->stack_align != NULL;
+ return gdbarch->deprecated_stack_align != NULL;
}
CORE_ADDR
-gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
+gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
{
gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->stack_align != NULL);
+ gdb_assert (gdbarch->deprecated_stack_align != NULL);
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_stack_align called\n");
- return gdbarch->stack_align (sp);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
+ return gdbarch->deprecated_stack_align (sp);
}
void
-set_gdbarch_stack_align (struct gdbarch *gdbarch,
- gdbarch_stack_align_ftype stack_align)
+set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
+ gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
{
- gdbarch->stack_align = stack_align;
+ gdbarch->deprecated_stack_align = deprecated_stack_align;
}
int
}
int
-gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_reg_struct_has_addr_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- return gdbarch->reg_struct_has_addr != NULL;
+ return gdbarch->deprecated_reg_struct_has_addr != NULL;
}
int
-gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
+gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
{
gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->reg_struct_has_addr != NULL);
+ gdb_assert (gdbarch->deprecated_reg_struct_has_addr != NULL);
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_reg_struct_has_addr called\n");
- return gdbarch->reg_struct_has_addr (gcc_p, type);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_reg_struct_has_addr called\n");
+ return gdbarch->deprecated_reg_struct_has_addr (gcc_p, type);
}
void
-set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch,
- gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr)
+set_gdbarch_deprecated_reg_struct_has_addr (struct gdbarch *gdbarch,
+ gdbarch_deprecated_reg_struct_has_addr_ftype deprecated_reg_struct_has_addr)
{
- gdbarch->reg_struct_has_addr = reg_struct_has_addr;
+ gdbarch->deprecated_reg_struct_has_addr = deprecated_reg_struct_has_addr;
+}
+
+int
+gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
+{
+ gdb_assert (gdbarch != NULL);
+ gdb_assert (gdbarch->stabs_argument_has_addr != NULL);
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_stabs_argument_has_addr called\n");
+ return gdbarch->stabs_argument_has_addr (gdbarch, type);
+}
+
+void
+set_gdbarch_stabs_argument_has_addr (struct gdbarch *gdbarch,
+ gdbarch_stabs_argument_has_addr_ftype stabs_argument_has_addr)
+{
+ gdbarch->stabs_argument_has_addr = stabs_argument_has_addr;
}
int
}
CORE_ADDR
-gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
+gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->convert_from_func_ptr_addr != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
- return gdbarch->convert_from_func_ptr_addr (addr);
+ return gdbarch->convert_from_func_ptr_addr (gdbarch, addr, targ);
}
void
gdbarch->skip_trampoline_code = skip_trampoline_code;
}
+CORE_ADDR
+gdbarch_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+ gdb_assert (gdbarch != NULL);
+ gdb_assert (gdbarch->skip_solib_resolver != NULL);
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_solib_resolver called\n");
+ return gdbarch->skip_solib_resolver (gdbarch, pc);
+}
+
+void
+set_gdbarch_skip_solib_resolver (struct gdbarch *gdbarch,
+ gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
+{
+ gdbarch->skip_solib_resolver = skip_solib_resolver;
+}
+
int
gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
{
}
int
-gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
+gdbarch_deprecated_pc_in_sigtramp_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->pc_in_sigtramp != NULL);
+ return gdbarch->deprecated_pc_in_sigtramp != legacy_pc_in_sigtramp;
+}
+
+int
+gdbarch_deprecated_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
+{
+ gdb_assert (gdbarch != NULL);
+ gdb_assert (gdbarch->deprecated_pc_in_sigtramp != NULL);
+ /* Do not check predicate: gdbarch->deprecated_pc_in_sigtramp != legacy_pc_in_sigtramp, allow call. */
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_sigtramp called\n");
- return gdbarch->pc_in_sigtramp (pc, name);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pc_in_sigtramp called\n");
+ return gdbarch->deprecated_pc_in_sigtramp (pc, name);
}
void
-set_gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch,
- gdbarch_pc_in_sigtramp_ftype pc_in_sigtramp)
+set_gdbarch_deprecated_pc_in_sigtramp (struct gdbarch *gdbarch,
+ gdbarch_deprecated_pc_in_sigtramp_ftype deprecated_pc_in_sigtramp)
{
- gdbarch->pc_in_sigtramp = pc_in_sigtramp;
+ gdbarch->deprecated_pc_in_sigtramp = deprecated_pc_in_sigtramp;
}
int
gdbarch->fetch_pointer_argument = fetch_pointer_argument;
}
+int
+gdbarch_regset_from_core_section_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->regset_from_core_section != NULL;
+}
+
+const struct regset *
+gdbarch_regset_from_core_section (struct gdbarch *gdbarch, const char *sect_name, size_t sect_size)
+{
+ gdb_assert (gdbarch != NULL);
+ gdb_assert (gdbarch->regset_from_core_section != NULL);
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_regset_from_core_section called\n");
+ return gdbarch->regset_from_core_section (gdbarch, sect_name, sect_size);
+}
+
+void
+set_gdbarch_regset_from_core_section (struct gdbarch *gdbarch,
+ gdbarch_regset_from_core_section_ftype regset_from_core_section)
+{
+ gdbarch->regset_from_core_section = regset_from_core_section;
+}
+
/* Keep a registry of per-architecture data-pointers required by GDB
modules. */
{
unsigned index;
int init_p;
- gdbarch_data_init_ftype *init;
+ gdbarch_data_pre_init_ftype *pre_init;
+ gdbarch_data_post_init_ftype *post_init;
};
struct gdbarch_data_registration
0, NULL,
};
-struct gdbarch_data *
-register_gdbarch_data (gdbarch_data_init_ftype *init)
+static struct gdbarch_data *
+gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
+ gdbarch_data_post_init_ftype *post_init)
{
struct gdbarch_data_registration **curr;
/* Append the new registraration. */
(*curr)->next = NULL;
(*curr)->data = XMALLOC (struct gdbarch_data);
(*curr)->data->index = gdbarch_data_registry.nr++;
- (*curr)->data->init = init;
+ (*curr)->data->pre_init = pre_init;
+ (*curr)->data->post_init = post_init;
(*curr)->data->init_p = 1;
return (*curr)->data;
}
+struct gdbarch_data *
+gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
+{
+ return gdbarch_data_register (pre_init, NULL);
+}
+
+struct gdbarch_data *
+gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
+{
+ return gdbarch_data_register (NULL, post_init);
+}
/* Create/delete the gdbarch data vector. */
data-pointer. */
void
-set_gdbarch_data (struct gdbarch *gdbarch,
- struct gdbarch_data *data,
- void *pointer)
+deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
+ struct gdbarch_data *data,
+ void *pointer)
{
gdb_assert (data->index < gdbarch->nr_data);
gdb_assert (gdbarch->data[data->index] == NULL);
+ gdb_assert (data->pre_init == NULL);
gdbarch->data[data->index] = pointer;
}
gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
{
gdb_assert (data->index < gdbarch->nr_data);
- /* The data-pointer isn't initialized, call init() to get a value but
- only if the architecture initializaiton has completed. Otherwise
- punt - hope that the caller knows what they are doing. */
- if (gdbarch->data[data->index] == NULL
- && gdbarch->initialized_p)
+ if (gdbarch->data[data->index] == NULL)
{
- /* Be careful to detect an initialization cycle. */
- gdb_assert (data->init_p);
- data->init_p = 0;
- gdb_assert (data->init != NULL);
- gdbarch->data[data->index] = data->init (gdbarch);
- data->init_p = 1;
+ /* The data-pointer isn't initialized, call init() to get a
+ value. */
+ if (data->pre_init != NULL)
+ /* Mid architecture creation: pass just the obstack, and not
+ the entire architecture, as that way it isn't possible for
+ pre-init code to refer to undefined architecture
+ fields. */
+ gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
+ else if (gdbarch->initialized_p
+ && data->post_init != NULL)
+ /* Post architecture creation: pass the entire architecture
+ (as all fields are valid), but be careful to also detect
+ recursive references. */
+ {
+ gdb_assert (data->init_p);
+ data->init_p = 0;
+ gdbarch->data[data->index] = data->post_init (gdbarch);
+ data->init_p = 1;
+ }
+ else
+ /* The architecture initialization hasn't completed - punt -
+ hope that the caller knows what they are doing. Once
+ deprecated_set_gdbarch_data has been initialized, this can be
+ changed to an internal error. */
+ return NULL;
gdb_assert (gdbarch->data[data->index] != NULL);
}
return gdbarch->data[data->index];
};
void
-register_gdbarch_swap (void *data,
- unsigned long sizeof_data,
- gdbarch_swap_ftype *init)
+deprecated_register_gdbarch_swap (void *data,
+ unsigned long sizeof_data,
+ gdbarch_swap_ftype *init)
{
struct gdbarch_swap_registration **rego;
for (rego = &gdbarch_swap_registry.registrations;
}
static void
-clear_gdbarch_swap (struct gdbarch *gdbarch)
-{
- struct gdbarch_swap *curr;
- for (curr = gdbarch->swap;
- curr != NULL;
- curr = curr->next)
- {
- memset (curr->source->data, 0, curr->source->sizeof_data);
- }
-}
-
-static void
-init_gdbarch_swap (struct gdbarch *gdbarch)
+current_gdbarch_swap_init_hack (void)
{
struct gdbarch_swap_registration *rego;
- struct gdbarch_swap **curr = &gdbarch->swap;
+ struct gdbarch_swap **curr = ¤t_gdbarch->swap;
for (rego = gdbarch_swap_registry.registrations;
rego != NULL;
rego = rego->next)
{
if (rego->data != NULL)
{
- (*curr) = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct gdbarch_swap);
+ (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
+ struct gdbarch_swap);
(*curr)->source = rego;
- (*curr)->swap = gdbarch_obstack_zalloc (gdbarch, rego->sizeof_data);
+ (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
+ rego->sizeof_data);
(*curr)->next = NULL;
curr = &(*curr)->next;
}
}
}
-static void
-swapout_gdbarch_swap (struct gdbarch *gdbarch)
+static struct gdbarch *
+current_gdbarch_swap_out_hack (void)
{
+ struct gdbarch *old_gdbarch = current_gdbarch;
struct gdbarch_swap *curr;
- for (curr = gdbarch->swap;
+
+ gdb_assert (old_gdbarch != NULL);
+ for (curr = old_gdbarch->swap;
curr != NULL;
curr = curr->next)
- memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
+ {
+ memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
+ memset (curr->source->data, 0, curr->source->sizeof_data);
+ }
+ current_gdbarch = NULL;
+ return old_gdbarch;
}
static void
-swapin_gdbarch_swap (struct gdbarch *gdbarch)
+current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
{
struct gdbarch_swap *curr;
- for (curr = gdbarch->swap;
+
+ gdb_assert (current_gdbarch == NULL);
+ for (curr = new_gdbarch->swap;
curr != NULL;
curr = curr->next)
memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
+ current_gdbarch = new_gdbarch;
}
}
-/* Update the current architecture. Return ZERO if the update request
- failed. */
+/* Find an architecture that matches the specified INFO. Create a new
+ architecture if needed. Return that new architecture. Assumes
+ that there is no current architecture. */
-int
-gdbarch_update_p (struct gdbarch_info info)
+static struct gdbarch *
+find_arch_by_info (struct gdbarch *old_gdbarch, struct gdbarch_info info)
{
struct gdbarch *new_gdbarch;
- struct gdbarch *old_gdbarch;
struct gdbarch_registration *rego;
+ /* The existing architecture has been swapped out - all this code
+ works from a clean slate. */
+ gdb_assert (current_gdbarch == NULL);
+
/* Fill in missing parts of the INFO struct using a number of
- sources: ``set ...''; INFOabfd supplied; existing target. */
-
- /* ``(gdb) set architecture ...'' */
- if (info.bfd_arch_info == NULL
- && !TARGET_ARCHITECTURE_AUTO)
- info.bfd_arch_info = TARGET_ARCHITECTURE;
- if (info.bfd_arch_info == NULL
- && info.abfd != NULL
- && bfd_get_arch (info.abfd) != bfd_arch_unknown
- && bfd_get_arch (info.abfd) != bfd_arch_obscure)
- info.bfd_arch_info = bfd_get_arch_info (info.abfd);
- if (info.bfd_arch_info == NULL)
- info.bfd_arch_info = TARGET_ARCHITECTURE;
-
- /* ``(gdb) set byte-order ...'' */
- if (info.byte_order == BFD_ENDIAN_UNKNOWN
- && !TARGET_BYTE_ORDER_AUTO)
- info.byte_order = TARGET_BYTE_ORDER;
- /* From the INFO struct. */
- if (info.byte_order == BFD_ENDIAN_UNKNOWN
- && info.abfd != NULL)
- info.byte_order = (bfd_big_endian (info.abfd) ? BFD_ENDIAN_BIG
- : bfd_little_endian (info.abfd) ? BFD_ENDIAN_LITTLE
- : BFD_ENDIAN_UNKNOWN);
- /* From the current target. */
- if (info.byte_order == BFD_ENDIAN_UNKNOWN)
- info.byte_order = TARGET_BYTE_ORDER;
-
- /* ``(gdb) set osabi ...'' is handled by gdbarch_lookup_osabi. */
- if (info.osabi == GDB_OSABI_UNINITIALIZED)
- info.osabi = gdbarch_lookup_osabi (info.abfd);
- if (info.osabi == GDB_OSABI_UNINITIALIZED)
- info.osabi = current_gdbarch->osabi;
+ sources: "set ..."; INFOabfd supplied; and the existing
+ architecture. */
+ gdbarch_info_fill (old_gdbarch, &info);
/* Must have found some sort of architecture. */
gdb_assert (info.bfd_arch_info != NULL);
if (gdbarch_debug)
{
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.bfd_arch_info %s\n",
+ "find_arch_by_info: info.bfd_arch_info %s\n",
(info.bfd_arch_info != NULL
? info.bfd_arch_info->printable_name
: "(null)"));
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.byte_order %d (%s)\n",
+ "find_arch_by_info: info.byte_order %d (%s)\n",
info.byte_order,
(info.byte_order == BFD_ENDIAN_BIG ? "big"
: info.byte_order == BFD_ENDIAN_LITTLE ? "little"
: "default"));
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.osabi %d (%s)\n",
+ "find_arch_by_info: info.osabi %d (%s)\n",
info.osabi, gdbarch_osabi_name (info.osabi));
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.abfd 0x%lx\n",
+ "find_arch_by_info: info.abfd 0x%lx\n",
(long) info.abfd);
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.tdep_info 0x%lx\n",
+ "find_arch_by_info: info.tdep_info 0x%lx\n",
(long) info.tdep_info);
}
- /* Find the target that knows about this architecture. */
+ /* Find the tdep code that knows about this architecture. */
for (rego = gdbarch_registry;
rego != NULL;
rego = rego->next)
if (rego == NULL)
{
if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
+ fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
+ "No matching architecture\n");
return 0;
}
- /* Swap the data belonging to the old target out setting the
- installed data to zero. This stops the ->init() function trying
- to refer to the previous architecture's global data structures. */
- swapout_gdbarch_swap (current_gdbarch);
- clear_gdbarch_swap (current_gdbarch);
-
- /* Save the previously selected architecture, setting the global to
- NULL. This stops ->init() trying to use the previous
- architecture's configuration. The previous architecture may not
- even be of the same architecture family. The most recent
- architecture of the same family is found at the head of the
- rego->arches list. */
- old_gdbarch = current_gdbarch;
- current_gdbarch = NULL;
-
- /* Ask the target for a replacement architecture. */
+ /* Ask the tdep code for an architecture that matches "info". */
new_gdbarch = rego->init (info, rego->arches);
- /* Did the target like it? No. Reject the change and revert to the
- old architecture. */
+ /* Did the tdep code like it? No. Reject the change and revert to
+ the old architecture. */
if (new_gdbarch == NULL)
{
if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
- swapin_gdbarch_swap (old_gdbarch);
- current_gdbarch = old_gdbarch;
- return 0;
+ fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
+ "Target rejected architecture\n");
+ return NULL;
}
- /* Did the architecture change? No. Oops, put the old architecture
- back. */
- if (old_gdbarch == new_gdbarch)
+ /* Is this a pre-existing architecture (as determined by already
+ being initialized)? Move it to the front of the architecture
+ list (keeping the list sorted Most Recently Used). */
+ if (new_gdbarch->initialized_p)
{
+ struct gdbarch_list **list;
+ struct gdbarch_list *this;
if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
+ fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
+ "Previous architecture 0x%08lx (%s) selected\n",
(long) new_gdbarch,
new_gdbarch->bfd_arch_info->printable_name);
- swapin_gdbarch_swap (old_gdbarch);
- current_gdbarch = old_gdbarch;
- return 1;
+ /* Find the existing arch in the list. */
+ for (list = ®o->arches;
+ (*list) != NULL && (*list)->gdbarch != new_gdbarch;
+ list = &(*list)->next);
+ /* It had better be in the list of architectures. */
+ gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
+ /* Unlink THIS. */
+ this = (*list);
+ (*list) = this->next;
+ /* Insert THIS at the front. */
+ this->next = rego->arches;
+ rego->arches = this;
+ /* Return it. */
+ return new_gdbarch;
}
- /* Is this a pre-existing architecture? Yes. Move it to the front
- of the list of architectures (keeping the list sorted Most
- Recently Used) and then copy it in. */
- {
- struct gdbarch_list **list;
- for (list = ®o->arches;
- (*list) != NULL;
- list = &(*list)->next)
- {
- if ((*list)->gdbarch == new_gdbarch)
- {
- struct gdbarch_list *this;
- if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
- (long) new_gdbarch,
- new_gdbarch->bfd_arch_info->printable_name);
- /* Unlink this. */
- this = (*list);
- (*list) = this->next;
- /* Insert in the front. */
- this->next = rego->arches;
- rego->arches = this;
- /* Copy the new architecture in. */
- current_gdbarch = new_gdbarch;
- swapin_gdbarch_swap (new_gdbarch);
- architecture_changed_event ();
- return 1;
- }
- }
- }
-
- /* Prepend this new architecture to the architecture list (keep the
- list sorted Most Recently Used). */
+ /* It's a new architecture. */
+ if (gdbarch_debug)
+ fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
+ "New architecture 0x%08lx (%s) selected\n",
+ (long) new_gdbarch,
+ new_gdbarch->bfd_arch_info->printable_name);
+
+ /* Insert the new architecture into the front of the architecture
+ list (keep the list sorted Most Recently Used). */
{
struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
this->next = rego->arches;
rego->arches = this;
}
- /* Switch to this new architecture marking it initialized. */
- current_gdbarch = new_gdbarch;
- current_gdbarch->initialized_p = 1;
- if (gdbarch_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
- (long) new_gdbarch,
- new_gdbarch->bfd_arch_info->printable_name);
- }
-
/* Check that the newly installed architecture is valid. Plug in
any post init values. */
new_gdbarch->dump_tdep = rego->dump_tdep;
verify_gdbarch (new_gdbarch);
+ new_gdbarch->initialized_p = 1;
- /* Initialize the per-architecture memory (swap) areas.
- CURRENT_GDBARCH must be update before these modules are
- called. */
- init_gdbarch_swap (new_gdbarch);
-
- /* Initialize the per-architecture data. CURRENT_GDBARCH
- must be updated before these modules are called. */
- architecture_changed_event ();
+ /* Initialize any per-architecture swap areas. This phase requires
+ a valid global CURRENT_GDBARCH. Set it momentarially, and then
+ swap the entire architecture out. */
+ current_gdbarch = new_gdbarch;
+ current_gdbarch_swap_init_hack ();
+ current_gdbarch_swap_out_hack ();
if (gdbarch_debug)
- gdbarch_dump (current_gdbarch, gdb_stdlog);
+ gdbarch_dump (new_gdbarch, gdb_stdlog);
- return 1;
+ return new_gdbarch;
}
+struct gdbarch *
+gdbarch_find_by_info (struct gdbarch_info info)
+{
+ /* Save the previously selected architecture, setting the global to
+ NULL. This stops things like gdbarch->init() trying to use the
+ previous architecture's configuration. The previous architecture
+ may not even be of the same architecture family. The most recent
+ architecture of the same family is found at the head of the
+ rego->arches list. */
+ struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
+
+ /* Find the specified architecture. */
+ struct gdbarch *new_gdbarch = find_arch_by_info (old_gdbarch, info);
+
+ /* Restore the existing architecture. */
+ gdb_assert (current_gdbarch == NULL);
+ current_gdbarch_swap_in_hack (old_gdbarch);
+
+ return new_gdbarch;
+}
+
+/* Make the specified architecture current, swapping the existing one
+ out. */
+
+void
+deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
+{
+ gdb_assert (new_gdbarch != NULL);
+ gdb_assert (current_gdbarch != NULL);
+ gdb_assert (new_gdbarch->initialized_p);
+ current_gdbarch_swap_out_hack ();
+ current_gdbarch_swap_in_hack (new_gdbarch);
+ architecture_changed_event ();
+}
extern void _initialize_gdbarch (void);
projects / deliverable / binutils-gdb.git / blobdiff