/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
/* Dynamic architecture support for GDB, the GNU debugger.
- Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdb_assert.h"
#include "gdb_string.h"
#include "gdb-events.h"
+#include "reggroups.h"
+#include "osabi.h"
/* Static function declarations */
/* basic architectural information */
const struct bfd_arch_info * bfd_arch_info;
int byte_order;
+ enum gdb_osabi osabi;
/* target specific vector. */
struct gdbarch_tdep *tdep;
int register_bytes;
gdbarch_register_byte_ftype *register_byte;
gdbarch_register_raw_size_ftype *register_raw_size;
- int max_register_raw_size;
+ int deprecated_max_register_raw_size;
gdbarch_register_virtual_size_ftype *register_virtual_size;
- int max_register_virtual_size;
+ int deprecated_max_register_virtual_size;
gdbarch_register_virtual_type_ftype *register_virtual_type;
- gdbarch_do_registers_info_ftype *do_registers_info;
+ gdbarch_register_type_ftype *register_type;
+ gdbarch_deprecated_do_registers_info_ftype *deprecated_do_registers_info;
gdbarch_print_registers_info_ftype *print_registers_info;
gdbarch_print_float_info_ftype *print_float_info;
gdbarch_print_vector_info_ftype *print_vector_info;
gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
gdbarch_cannot_store_register_ftype *cannot_store_register;
gdbarch_get_longjmp_target_ftype *get_longjmp_target;
- int use_generic_dummy_frames;
+ int 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;
- gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy;
+ 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;
+ int deprecated_call_dummy_stack_adjust;
gdbarch_fix_call_dummy_ftype *fix_call_dummy;
- gdbarch_init_frame_pc_first_ftype *init_frame_pc_first;
- gdbarch_init_frame_pc_ftype *init_frame_pc;
+ gdbarch_deprecated_init_frame_pc_first_ftype *deprecated_init_frame_pc_first;
+ gdbarch_deprecated_init_frame_pc_ftype *deprecated_init_frame_pc;
int believe_pcc_promotion;
int believe_pcc_promotion_type;
- gdbarch_coerce_float_to_double_ftype *coerce_float_to_double;
- gdbarch_get_saved_register_ftype *get_saved_register;
+ gdbarch_deprecated_get_saved_register_ftype *deprecated_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_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_deprecated_push_dummy_frame_ftype *deprecated_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_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;
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;
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_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_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;
gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
const char * name_of_malloc;
int cannot_step_breakpoint;
+ int have_nonsteppable_watchpoint;
+ gdbarch_address_class_type_flags_ftype *address_class_type_flags;
+ gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
+ gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
+ gdbarch_register_reggroup_p_ftype *register_reggroup_p;
};
/* basic architecture information */
&bfd_default_arch_struct,
BFD_ENDIAN_BIG,
+ GDB_OSABI_UNKNOWN,
/* target specific vector and its dump routine */
NULL, NULL,
/*per-architecture data-pointers and swap regions */
0,
0,
0,
- default_print_registers_info,
0,
+ default_print_registers_info,
0,
0,
0,
0,
0,
0,
+ generic_pc_in_call_dummy,
0,
0,
0,
0,
"malloc",
0,
+ 0,
+ 0,
+ 0,
+ 0,
+ default_register_reggroup_p,
/* startup_gdbarch() */
};
current_gdbarch->bfd_arch_info = info->bfd_arch_info;
current_gdbarch->byte_order = info->byte_order;
+ current_gdbarch->osabi = info->osabi;
/* Force the explicit initialization of these. */
current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
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->print_registers_info = default_print_registers_info;
current_gdbarch->register_sim_regno = legacy_register_sim_regno;
current_gdbarch->cannot_fetch_register = cannot_register_not;
current_gdbarch->cannot_store_register = cannot_register_not;
- current_gdbarch->use_generic_dummy_frames = -1;
+ current_gdbarch->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->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->init_frame_pc_first = init_frame_pc_noop;
- current_gdbarch->init_frame_pc = init_frame_pc_default;
- current_gdbarch->coerce_float_to_double = default_coerce_float_to_double;
- current_gdbarch->get_saved_register = generic_unwind_get_saved_register;
current_gdbarch->register_convertible = generic_register_convertible_not;
current_gdbarch->convert_register_p = legacy_convert_register_p;
current_gdbarch->register_to_value = legacy_register_to_value;
current_gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
current_gdbarch->frame_args_skip = -1;
current_gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
- current_gdbarch->frame_chain_valid = generic_func_frame_chain_valid;
- current_gdbarch->extra_stack_alignment_needed = 1;
+ current_gdbarch->frame_args_address = get_frame_base;
+ current_gdbarch->frame_locals_address = get_frame_base;
current_gdbarch->convert_from_func_ptr_addr = core_addr_identity;
current_gdbarch->addr_bits_remove = core_addr_identity;
current_gdbarch->smash_text_address = core_addr_identity;
current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
current_gdbarch->name_of_malloc = "malloc";
+ current_gdbarch->register_reggroup_p = default_register_reggroup_p;
/* gdbarch_alloc() */
return current_gdbarch;
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 deprecated_max_register_raw_size, has predicate */
/* Skip verify of register_virtual_size, invalid_p == 0 */
- if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->max_register_virtual_size == -1))
- fprintf_unfiltered (log, "\n\tmax_register_virtual_size");
- if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->register_virtual_type == 0))
- fprintf_unfiltered (log, "\n\tregister_virtual_type");
- /* Skip verify of do_registers_info, has predicate */
+ /* Skip verify of deprecated_max_register_virtual_size, has predicate */
+ /* Skip verify of register_virtual_type, has predicate */
+ /* Skip verify of register_type, 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 */
/* Skip verify of print_vector_info, has predicate */
/* Skip verify of cannot_fetch_register, invalid_p == 0 */
/* Skip verify of cannot_store_register, invalid_p == 0 */
/* Skip verify of get_longjmp_target, has predicate */
- if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->use_generic_dummy_frames == -1))
- fprintf_unfiltered (log, "\n\tuse_generic_dummy_frames");
- if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->call_dummy_location == 0))
- fprintf_unfiltered (log, "\n\tcall_dummy_location");
+ /* 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_length == -1))
fprintf_unfiltered (log, "\n\tcall_dummy_length");
- if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->pc_in_call_dummy == 0))
- fprintf_unfiltered (log, "\n\tpc_in_call_dummy");
+ /* 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");
+ /* Skip verify of deprecated_call_dummy_stack_adjust, has predicate */
if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
&& (gdbarch->fix_call_dummy == 0))
fprintf_unfiltered (log, "\n\tfix_call_dummy");
- /* Skip verify of init_frame_pc_first, invalid_p == 0 */
- /* Skip verify of init_frame_pc, invalid_p == 0 */
- /* Skip verify of coerce_float_to_double, invalid_p == 0 */
- /* Skip verify of get_saved_register, invalid_p == 0 */
+ /* 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 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 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 deprecated_push_dummy_frame, has predicate */
/* 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_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");
&& (gdbarch->frame_args_skip == -1))
fprintf_unfiltered (log, "\n\tframe_args_skip");
/* Skip verify of frameless_function_invocation, invalid_p == 0 */
- if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->frame_chain == 0))
- fprintf_unfiltered (log, "\n\tframe_chain");
- /* Skip verify of frame_chain_valid, invalid_p == 0 */
- if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->frame_saved_pc == 0))
- fprintf_unfiltered (log, "\n\tframe_saved_pc");
- if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->frame_args_address == 0))
- fprintf_unfiltered (log, "\n\tframe_args_address");
- if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
- && (gdbarch->frame_locals_address == 0))
- fprintf_unfiltered (log, "\n\tframe_locals_address");
+ /* 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 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");
fprintf_unfiltered (log, "\n\tframe_num_args");
/* 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)
/* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
/* Skip verify of name_of_malloc, invalid_p == 0 */
/* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
+ /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
+ /* Skip verify of address_class_type_flags, has predicate */
+ /* Skip verify of address_class_type_flags_to_name, has predicate */
+ /* Skip verify of address_class_name_to_type_flags, has predicate */
+ /* Skip verify of register_reggroup_p, invalid_p == 0 */
buf = ui_file_xstrdup (log, &dummy);
make_cleanup (xfree, buf);
if (strlen (buf) > 0)
fprintf_unfiltered (file,
"gdbarch_dump: GDB_MULTI_ARCH = %d\n",
GDB_MULTI_ARCH);
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
+ gdbarch_frame_align_p (current_gdbarch));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
"gdbarch_dump: frame_align = 0x%08lx\n",
fprintf_unfiltered (file,
"gdbarch_dump: in_function_epilogue_p = 0x%08lx\n",
(long) current_gdbarch->in_function_epilogue_p);
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: register_reggroup_p = 0x%08lx\n",
+ (long) current_gdbarch->register_reggroup_p);
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
+ gdbarch_pseudo_register_read_p (current_gdbarch));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
"gdbarch_dump: pseudo_register_read = 0x%08lx\n",
(long) current_gdbarch->pseudo_register_read);
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
+ gdbarch_pseudo_register_write_p (current_gdbarch));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
"gdbarch_dump: pseudo_register_write = 0x%08lx\n",
(long) current_gdbarch->pseudo_register_write);
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
+ gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: address_class_name_to_type_flags = 0x%08lx\n",
+ (long) current_gdbarch->address_class_name_to_type_flags);
+#ifdef ADDRESS_CLASS_TYPE_FLAGS_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "ADDRESS_CLASS_TYPE_FLAGS_P()",
+ XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS_P() = %d\n",
+ ADDRESS_CLASS_TYPE_FLAGS_P ());
+#endif
+#ifdef ADDRESS_CLASS_TYPE_FLAGS
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
+ XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class)));
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = <0x%08lx>\n",
+ (long) current_gdbarch->address_class_type_flags
+ /*ADDRESS_CLASS_TYPE_FLAGS ()*/);
+#endif
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
+ gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: address_class_type_flags_to_name = 0x%08lx\n",
+ (long) current_gdbarch->address_class_type_flags_to_name);
#ifdef ADDRESS_TO_POINTER
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: ADDRESS_TO_POINTER = 0x%08lx\n",
+ "gdbarch_dump: ADDRESS_TO_POINTER = <0x%08lx>\n",
(long) current_gdbarch->address_to_pointer
/*ADDRESS_TO_POINTER ()*/);
#endif
XSTRING (ADDR_BITS_REMOVE (addr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: ADDR_BITS_REMOVE = 0x%08lx\n",
+ "gdbarch_dump: ADDR_BITS_REMOVE = <0x%08lx>\n",
(long) current_gdbarch->addr_bits_remove
/*ADDR_BITS_REMOVE ()*/);
#endif
XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: BREAKPOINT_FROM_PC = 0x%08lx\n",
+ "gdbarch_dump: BREAKPOINT_FROM_PC = <0x%08lx>\n",
(long) current_gdbarch->breakpoint_from_pc
/*BREAKPOINT_FROM_PC ()*/);
#endif
XSTRING (CALL_DUMMY_ADDRESS ()));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: CALL_DUMMY_ADDRESS = 0x%08lx\n",
+ "gdbarch_dump: CALL_DUMMY_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->call_dummy_address
/*CALL_DUMMY_ADDRESS ()*/);
#endif
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)
+ if (gdbarch->call_dummy_length >= 0)
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_LENGTH = %d\n",
CALL_DUMMY_LENGTH);
"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 (CANNOT_FETCH_REGISTER (regnum)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: CANNOT_FETCH_REGISTER = 0x%08lx\n",
+ "gdbarch_dump: CANNOT_FETCH_REGISTER = <0x%08lx>\n",
(long) current_gdbarch->cannot_fetch_register
/*CANNOT_FETCH_REGISTER ()*/);
#endif
XSTRING (CANNOT_STORE_REGISTER (regnum)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: CANNOT_STORE_REGISTER = 0x%08lx\n",
+ "gdbarch_dump: CANNOT_STORE_REGISTER = <0x%08lx>\n",
(long) current_gdbarch->cannot_store_register
/*CANNOT_STORE_REGISTER ()*/);
#endif
-#ifdef COERCE_FLOAT_TO_DOUBLE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "COERCE_FLOAT_TO_DOUBLE(formal, actual)",
- XSTRING (COERCE_FLOAT_TO_DOUBLE (formal, actual)));
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
- (long) current_gdbarch->coerce_float_to_double
- /*COERCE_FLOAT_TO_DOUBLE ()*/);
-#endif
#ifdef COFF_MAKE_MSYMBOL_SPECIAL
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = 0x%08lx\n",
+ "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
(long) current_gdbarch->coff_make_msymbol_special
/*COFF_MAKE_MSYMBOL_SPECIAL ()*/);
#endif
XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = 0x%08lx\n",
+ "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = <0x%08lx>\n",
(long) current_gdbarch->convert_from_func_ptr_addr
/*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
#endif
XSTRING (CONVERT_REGISTER_P (regnum)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: CONVERT_REGISTER_P = 0x%08lx\n",
+ "gdbarch_dump: CONVERT_REGISTER_P = <0x%08lx>\n",
(long) current_gdbarch->convert_register_p
/*CONVERT_REGISTER_P ()*/);
#endif
"gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
(long) DECR_PC_AFTER_BREAK);
#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_DO_REGISTERS_INFO_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_DO_REGISTERS_INFO_P()",
+ XSTRING (DEPRECATED_DO_REGISTERS_INFO_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO_P() = %d\n",
+ DEPRECATED_DO_REGISTERS_INFO_P ());
+#endif
+#ifdef DEPRECATED_DO_REGISTERS_INFO
+#if GDB_MULTI_ARCH
+ /* Macro might contain `[{}]' when not multi-arch */
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs)",
+ XSTRING (DEPRECATED_DO_REGISTERS_INFO (reg_nr, fpregs)));
+#endif
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_do_registers_info
+ /*DEPRECATED_DO_REGISTERS_INFO ()*/);
+#endif
#ifdef DEPRECATED_EXTRACT_RETURN_VALUE
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = 0x%08lx\n",
+ "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = <0x%08lx>\n",
(long) current_gdbarch->deprecated_extract_return_value
/*DEPRECATED_EXTRACT_RETURN_VALUE ()*/);
#endif
+#ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
+ XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
+ DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ());
+#endif
#ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
+ "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_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",
+ "DEPRECATED_INIT_FRAME_PC_P()",
+ XSTRING (DEPRECATED_INIT_FRAME_PC_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_P() = %d\n",
+ DEPRECATED_INIT_FRAME_PC_P ());
+#endif
+#ifdef DEPRECATED_INIT_FRAME_PC
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_INIT_FRAME_PC(fromleaf, prev)",
+ XSTRING (DEPRECATED_INIT_FRAME_PC (fromleaf, prev)));
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_INIT_FRAME_PC = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_init_frame_pc
+ /*DEPRECATED_INIT_FRAME_PC ()*/);
+#endif
+#ifdef DEPRECATED_INIT_FRAME_PC_FIRST_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_INIT_FRAME_PC_FIRST_P()",
+ XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST_P() = %d\n",
+ DEPRECATED_INIT_FRAME_PC_FIRST_P ());
+#endif
+#ifdef DEPRECATED_INIT_FRAME_PC_FIRST
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev)",
+ XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf, prev)));
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_init_frame_pc_first
+ /*DEPRECATED_INIT_FRAME_PC_FIRST ()*/);
+#endif
+#ifdef 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",
+ "DEPRECATED_PC_IN_CALL_DUMMY_P()",
+ XSTRING (DEPRECATED_PC_IN_CALL_DUMMY_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY_P() = %d\n",
+ DEPRECATED_PC_IN_CALL_DUMMY_P ());
+#endif
+#ifdef DEPRECATED_PC_IN_CALL_DUMMY
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address)",
+ XSTRING (DEPRECATED_PC_IN_CALL_DUMMY (pc, sp, frame_address)));
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_pc_in_call_dummy
+ /*DEPRECATED_PC_IN_CALL_DUMMY ()*/);
+#endif
+#ifdef DEPRECATED_POP_FRAME_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_POP_FRAME_P()",
+ XSTRING (DEPRECATED_POP_FRAME_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_POP_FRAME_P() = %d\n",
+ DEPRECATED_POP_FRAME_P ());
+#endif
+#ifdef DEPRECATED_POP_FRAME
+#if GDB_MULTI_ARCH
+ /* Macro might contain `[{}]' when not multi-arch */
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_POP_FRAME(-)",
+ XSTRING (DEPRECATED_POP_FRAME (-)));
+#endif
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_POP_FRAME = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_pop_frame
+ /*DEPRECATED_POP_FRAME ()*/);
+#endif
+#ifdef DEPRECATED_PUSH_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_STORE_RETURN_VALUE
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = 0x%08lx\n",
+ "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = <0x%08lx>\n",
(long) current_gdbarch->deprecated_store_return_value
/*DEPRECATED_STORE_RETURN_VALUE ()*/);
#endif
-#ifdef DO_REGISTERS_INFO
+#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",
- "DO_REGISTERS_INFO(reg_nr, fpregs)",
- XSTRING (DO_REGISTERS_INFO (reg_nr, fpregs)));
+ "DEPRECATED_STORE_STRUCT_RETURN(addr, sp)",
+ XSTRING (DEPRECATED_STORE_STRUCT_RETURN (addr, sp)));
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: DO_REGISTERS_INFO = 0x%08lx\n",
- (long) current_gdbarch->do_registers_info
- /*DO_REGISTERS_INFO ()*/);
+ "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_store_struct_return
+ /*DEPRECATED_STORE_STRUCT_RETURN ()*/);
+#endif
+#ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n",
+ XSTRING (DEPRECATED_USE_GENERIC_DUMMY_FRAMES));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES = %d\n",
+ DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
+#endif
+#ifdef DWARF2_BUILD_FRAME_INFO_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DWARF2_BUILD_FRAME_INFO_P()",
+ XSTRING (DWARF2_BUILD_FRAME_INFO_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DWARF2_BUILD_FRAME_INFO_P() = %d\n",
+ DWARF2_BUILD_FRAME_INFO_P ());
#endif
#ifdef DWARF2_BUILD_FRAME_INFO
#if GDB_MULTI_ARCH
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = 0x%08lx\n",
+ "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = <0x%08lx>\n",
(long) current_gdbarch->dwarf2_build_frame_info
/*DWARF2_BUILD_FRAME_INFO ()*/);
#endif
XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: DWARF2_REG_TO_REGNUM = 0x%08lx\n",
+ "gdbarch_dump: DWARF2_REG_TO_REGNUM = <0x%08lx>\n",
(long) current_gdbarch->dwarf2_reg_to_regnum
/*DWARF2_REG_TO_REGNUM ()*/);
#endif
XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: DWARF_REG_TO_REGNUM = 0x%08lx\n",
+ "gdbarch_dump: DWARF_REG_TO_REGNUM = <0x%08lx>\n",
(long) current_gdbarch->dwarf_reg_to_regnum
/*DWARF_REG_TO_REGNUM ()*/);
#endif
XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: ECOFF_REG_TO_REGNUM = 0x%08lx\n",
+ "gdbarch_dump: ECOFF_REG_TO_REGNUM = <0x%08lx>\n",
(long) current_gdbarch->ecoff_reg_to_regnum
/*ECOFF_REG_TO_REGNUM ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = 0x%08lx\n",
+ "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
(long) current_gdbarch->elf_make_msymbol_special
/*ELF_MAKE_MSYMBOL_SPECIAL ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: EXTRACT_RETURN_VALUE = 0x%08lx\n",
+ "gdbarch_dump: EXTRACT_RETURN_VALUE = <0x%08lx>\n",
(long) current_gdbarch->extract_return_value
/*EXTRACT_RETURN_VALUE ()*/);
#endif
+#ifdef EXTRACT_STRUCT_VALUE_ADDRESS_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "EXTRACT_STRUCT_VALUE_ADDRESS_P()",
+ XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
+ EXTRACT_STRUCT_VALUE_ADDRESS_P ());
+#endif
#ifdef EXTRACT_STRUCT_VALUE_ADDRESS
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
+ "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->extract_struct_value_address
/*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
#endif
-#ifdef EXTRA_STACK_ALIGNMENT_NEEDED
- fprintf_unfiltered (file,
- "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
- XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED));
- fprintf_unfiltered (file,
- "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
- EXTRA_STACK_ALIGNMENT_NEEDED);
-#endif
#ifdef FIX_CALL_DUMMY
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: FIX_CALL_DUMMY = 0x%08lx\n",
+ "gdbarch_dump: FIX_CALL_DUMMY = <0x%08lx>\n",
(long) current_gdbarch->fix_call_dummy
/*FIX_CALL_DUMMY ()*/);
#endif
XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
+ "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n",
(long) current_gdbarch->frameless_function_invocation
/*FRAMELESS_FUNCTION_INVOCATION ()*/);
#endif
XSTRING (FRAME_ARGS_ADDRESS (fi)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: FRAME_ARGS_ADDRESS = 0x%08lx\n",
+ "gdbarch_dump: FRAME_ARGS_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->frame_args_address
/*FRAME_ARGS_ADDRESS ()*/);
#endif
"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
- 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",
XSTRING (FRAME_LOCALS_ADDRESS (fi)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
+ "gdbarch_dump: FRAME_LOCALS_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->frame_locals_address
/*FRAME_LOCALS_ADDRESS ()*/);
#endif
XSTRING (FRAME_NUM_ARGS (frame)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: FRAME_NUM_ARGS = 0x%08lx\n",
+ "gdbarch_dump: FRAME_NUM_ARGS = <0x%08lx>\n",
(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",
"gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
(long) FUNCTION_START_OFFSET);
#endif
+#ifdef GET_LONGJMP_TARGET_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "GET_LONGJMP_TARGET_P()",
+ XSTRING (GET_LONGJMP_TARGET_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: GET_LONGJMP_TARGET_P() = %d\n",
+ GET_LONGJMP_TARGET_P ());
+#endif
#ifdef GET_LONGJMP_TARGET
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (GET_LONGJMP_TARGET (pc)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: GET_LONGJMP_TARGET = 0x%08lx\n",
+ "gdbarch_dump: GET_LONGJMP_TARGET = <0x%08lx>\n",
(long) current_gdbarch->get_longjmp_target
/*GET_LONGJMP_TARGET ()*/);
#endif
-#ifdef GET_SAVED_REGISTER
-#if GDB_MULTI_ARCH
- /* Macro might contain `[{}]' when not multi-arch */
+#ifdef HAVE_NONSTEPPABLE_WATCHPOINT
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 INIT_EXTRA_FRAME_INFO
-#if GDB_MULTI_ARCH
- /* Macro might contain `[{}]' when not multi-arch */
+ "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
+ XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
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 INIT_FRAME_PC
-#if GDB_MULTI_ARCH
- /* Macro might contain `[{}]' when not multi-arch */
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "INIT_FRAME_PC(fromleaf, prev)",
- XSTRING (INIT_FRAME_PC (fromleaf, prev)));
-#endif
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: INIT_FRAME_PC = 0x%08lx\n",
- (long) current_gdbarch->init_frame_pc
- /*INIT_FRAME_PC ()*/);
-#endif
-#ifdef INIT_FRAME_PC_FIRST
-#if GDB_MULTI_ARCH
- /* Macro might contain `[{}]' when not multi-arch */
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "INIT_FRAME_PC_FIRST(fromleaf, prev)",
- XSTRING (INIT_FRAME_PC_FIRST (fromleaf, prev)));
-#endif
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: INIT_FRAME_PC_FIRST = 0x%08lx\n",
- (long) current_gdbarch->init_frame_pc_first
- /*INIT_FRAME_PC_FIRST ()*/);
+ "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n",
+ HAVE_NONSTEPPABLE_WATCHPOINT);
#endif
#ifdef INNER_THAN
fprintf_unfiltered (file,
XSTRING (INNER_THAN (lhs, rhs)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: INNER_THAN = 0x%08lx\n",
+ "gdbarch_dump: INNER_THAN = <0x%08lx>\n",
(long) current_gdbarch->inner_than
/*INNER_THAN ()*/);
#endif
+#ifdef INTEGER_TO_ADDRESS_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "INTEGER_TO_ADDRESS_P()",
+ XSTRING (INTEGER_TO_ADDRESS_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: INTEGER_TO_ADDRESS_P() = %d\n",
+ INTEGER_TO_ADDRESS_P ());
+#endif
#ifdef INTEGER_TO_ADDRESS
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (INTEGER_TO_ADDRESS (type, buf)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: INTEGER_TO_ADDRESS = 0x%08lx\n",
+ "gdbarch_dump: INTEGER_TO_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->integer_to_address
/*INTEGER_TO_ADDRESS ()*/);
#endif
XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc, name)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = 0x%08lx\n",
+ "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = <0x%08lx>\n",
(long) current_gdbarch->in_solib_call_trampoline
/*IN_SOLIB_CALL_TRAMPOLINE ()*/);
#endif
XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = 0x%08lx\n",
+ "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = <0x%08lx>\n",
(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",
XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
+ "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = <0x%08lx>\n",
(long) current_gdbarch->memory_insert_breakpoint
/*MEMORY_INSERT_BREAKPOINT ()*/);
#endif
XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
+ "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = <0x%08lx>\n",
(long) current_gdbarch->memory_remove_breakpoint
/*MEMORY_REMOVE_BREAKPOINT ()*/);
#endif
"gdbarch_dump: NAME_OF_MALLOC # %s\n",
XSTRING (NAME_OF_MALLOC));
fprintf_unfiltered (file,
- "gdbarch_dump: NAME_OF_MALLOC = %ld\n",
- (long) NAME_OF_MALLOC);
+ "gdbarch_dump: NAME_OF_MALLOC = %s\n",
+ NAME_OF_MALLOC);
#endif
#ifdef NPC_REGNUM
fprintf_unfiltered (file,
"gdbarch_dump: PARM_BOUNDARY = %d\n",
PARM_BOUNDARY);
#endif
-#ifdef PC_IN_CALL_DUMMY
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "PC_IN_CALL_DUMMY(pc, sp, frame_address)",
- XSTRING (PC_IN_CALL_DUMMY (pc, sp, frame_address)));
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: PC_IN_CALL_DUMMY = 0x%08lx\n",
- (long) current_gdbarch->pc_in_call_dummy
- /*PC_IN_CALL_DUMMY ()*/);
-#endif
#ifdef PC_IN_SIGTRAMP
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (PC_IN_SIGTRAMP (pc, name)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: PC_IN_SIGTRAMP = 0x%08lx\n",
+ "gdbarch_dump: PC_IN_SIGTRAMP = <0x%08lx>\n",
(long) current_gdbarch->pc_in_sigtramp
/*PC_IN_SIGTRAMP ()*/);
#endif
XSTRING (POINTER_TO_ADDRESS (type, buf)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: POINTER_TO_ADDRESS = 0x%08lx\n",
+ "gdbarch_dump: POINTER_TO_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->pointer_to_address
/*POINTER_TO_ADDRESS ()*/);
#endif
-#ifdef POP_FRAME
-#if GDB_MULTI_ARCH
- /* Macro might contain `[{}]' when not multi-arch */
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "POP_FRAME(-)",
- XSTRING (POP_FRAME (-)));
-#endif
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: POP_FRAME = 0x%08lx\n",
- (long) current_gdbarch->pop_frame
- /*POP_FRAME ()*/);
-#endif
#ifdef PREPARE_TO_PROCEED
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (PREPARE_TO_PROCEED (select_it)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: PREPARE_TO_PROCEED = 0x%08lx\n",
+ "gdbarch_dump: PREPARE_TO_PROCEED = <0x%08lx>\n",
(long) current_gdbarch->prepare_to_proceed
/*PREPARE_TO_PROCEED ()*/);
#endif
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
+ gdbarch_print_float_info_p (current_gdbarch));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
"gdbarch_dump: print_float_info = 0x%08lx\n",
fprintf_unfiltered (file,
"gdbarch_dump: print_registers_info = 0x%08lx\n",
(long) current_gdbarch->print_registers_info);
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
+ gdbarch_print_vector_info_p (current_gdbarch));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
"gdbarch_dump: print_vector_info = 0x%08lx\n",
XSTRING (PROLOGUE_FRAMELESS_P (ip)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: PROLOGUE_FRAMELESS_P = 0x%08lx\n",
+ "gdbarch_dump: PROLOGUE_FRAMELESS_P = <0x%08lx>\n",
(long) current_gdbarch->prologue_frameless_p
/*PROLOGUE_FRAMELESS_P ()*/);
#endif
XSTRING (PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: PUSH_ARGUMENTS = 0x%08lx\n",
+ "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 */
+#ifdef PUSH_RETURN_ADDRESS_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
- "PUSH_DUMMY_FRAME(-)",
- XSTRING (PUSH_DUMMY_FRAME (-)));
-#endif
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: PUSH_DUMMY_FRAME = 0x%08lx\n",
- (long) current_gdbarch->push_dummy_frame
- /*PUSH_DUMMY_FRAME ()*/);
+ "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
fprintf_unfiltered (file,
XSTRING (PUSH_RETURN_ADDRESS (pc, sp)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: PUSH_RETURN_ADDRESS = 0x%08lx\n",
+ "gdbarch_dump: PUSH_RETURN_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->push_return_address
/*PUSH_RETURN_ADDRESS ()*/);
#endif
XSTRING (REGISTER_BYTE (reg_nr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_BYTE = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_BYTE = <0x%08lx>\n",
(long) current_gdbarch->register_byte
/*REGISTER_BYTE ()*/);
#endif
"gdbarch_dump: REGISTER_BYTES = %d\n",
REGISTER_BYTES);
#endif
+#ifdef REGISTER_BYTES_OK_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "REGISTER_BYTES_OK_P()",
+ XSTRING (REGISTER_BYTES_OK_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: REGISTER_BYTES_OK_P() = %d\n",
+ REGISTER_BYTES_OK_P ());
+#endif
#ifdef REGISTER_BYTES_OK
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (REGISTER_BYTES_OK (nr_bytes)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_BYTES_OK = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_BYTES_OK = <0x%08lx>\n",
(long) current_gdbarch->register_bytes_ok
/*REGISTER_BYTES_OK ()*/);
#endif
XSTRING (REGISTER_CONVERTIBLE (nr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_CONVERTIBLE = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_CONVERTIBLE = <0x%08lx>\n",
(long) current_gdbarch->register_convertible
/*REGISTER_CONVERTIBLE ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_CONVERT_TO_RAW = <0x%08lx>\n",
(long) current_gdbarch->register_convert_to_raw
/*REGISTER_CONVERT_TO_RAW ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = <0x%08lx>\n",
(long) current_gdbarch->register_convert_to_virtual
/*REGISTER_CONVERT_TO_VIRTUAL ()*/);
#endif
XSTRING (REGISTER_NAME (regnr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_NAME = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_NAME = <0x%08lx>\n",
(long) current_gdbarch->register_name
/*REGISTER_NAME ()*/);
#endif
XSTRING (REGISTER_RAW_SIZE (reg_nr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_RAW_SIZE = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n",
(long) current_gdbarch->register_raw_size
/*REGISTER_RAW_SIZE ()*/);
#endif
XSTRING (REGISTER_SIM_REGNO (reg_nr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_SIM_REGNO = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_SIM_REGNO = <0x%08lx>\n",
(long) current_gdbarch->register_sim_regno
/*REGISTER_SIM_REGNO ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_TO_VALUE = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_TO_VALUE = <0x%08lx>\n",
(long) current_gdbarch->register_to_value
/*REGISTER_TO_VALUE ()*/);
#endif
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: gdbarch_register_type_p() = %d\n",
+ gdbarch_register_type_p (current_gdbarch));
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: register_type = 0x%08lx\n",
+ (long) current_gdbarch->register_type);
#ifdef REGISTER_VIRTUAL_SIZE
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
(long) current_gdbarch->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",
XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
+ "gdbarch_dump: REGISTER_VIRTUAL_TYPE = <0x%08lx>\n",
(long) current_gdbarch->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",
XSTRING (REG_STRUCT_HAS_ADDR (gcc_p, type)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
+ "gdbarch_dump: REG_STRUCT_HAS_ADDR = <0x%08lx>\n",
(long) current_gdbarch->reg_struct_has_addr
/*REG_STRUCT_HAS_ADDR ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
+ "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->remote_translate_xfer_address
/*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
#endif
XSTRING (RETURN_VALUE_ON_STACK (type)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: RETURN_VALUE_ON_STACK = 0x%08lx\n",
+ "gdbarch_dump: RETURN_VALUE_ON_STACK = <0x%08lx>\n",
(long) current_gdbarch->return_value_on_stack
/*RETURN_VALUE_ON_STACK ()*/);
#endif
XSTRING (SAVED_PC_AFTER_CALL (frame)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: SAVED_PC_AFTER_CALL = 0x%08lx\n",
+ "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",
+ "SAVE_DUMMY_FRAME_TOS_P()",
+ XSTRING (SAVE_DUMMY_FRAME_TOS_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: SAVE_DUMMY_FRAME_TOS_P() = %d\n",
+ SAVE_DUMMY_FRAME_TOS_P ());
+#endif
#ifdef SAVE_DUMMY_FRAME_TOS
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = 0x%08lx\n",
+ "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = <0x%08lx>\n",
(long) current_gdbarch->save_dummy_frame_tos
/*SAVE_DUMMY_FRAME_TOS ()*/);
#endif
XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: SDB_REG_TO_REGNUM = 0x%08lx\n",
+ "gdbarch_dump: SDB_REG_TO_REGNUM = <0x%08lx>\n",
(long) current_gdbarch->sdb_reg_to_regnum
/*SDB_REG_TO_REGNUM ()*/);
#endif
+#ifdef SIGTRAMP_END_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "SIGTRAMP_END_P()",
+ XSTRING (SIGTRAMP_END_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: SIGTRAMP_END_P() = %d\n",
+ SIGTRAMP_END_P ());
+#endif
#ifdef SIGTRAMP_END
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (SIGTRAMP_END (pc)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: SIGTRAMP_END = 0x%08lx\n",
+ "gdbarch_dump: SIGTRAMP_END = <0x%08lx>\n",
(long) current_gdbarch->sigtramp_end
/*SIGTRAMP_END ()*/);
#endif
+#ifdef SIGTRAMP_START_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "SIGTRAMP_START_P()",
+ XSTRING (SIGTRAMP_START_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: SIGTRAMP_START_P() = %d\n",
+ SIGTRAMP_START_P ());
+#endif
#ifdef SIGTRAMP_START
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (SIGTRAMP_START (pc)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: SIGTRAMP_START = 0x%08lx\n",
+ "gdbarch_dump: SIGTRAMP_START = <0x%08lx>\n",
(long) current_gdbarch->sigtramp_start
/*SIGTRAMP_START ()*/);
#endif
XSTRING (SKIP_PROLOGUE (ip)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: SKIP_PROLOGUE = 0x%08lx\n",
+ "gdbarch_dump: SKIP_PROLOGUE = <0x%08lx>\n",
(long) current_gdbarch->skip_prologue
/*SKIP_PROLOGUE ()*/);
#endif
XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: SKIP_TRAMPOLINE_CODE = 0x%08lx\n",
+ "gdbarch_dump: SKIP_TRAMPOLINE_CODE = <0x%08lx>\n",
(long) current_gdbarch->skip_trampoline_code
/*SKIP_TRAMPOLINE_CODE ()*/);
#endif
XSTRING (SMASH_TEXT_ADDRESS (addr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: SMASH_TEXT_ADDRESS = 0x%08lx\n",
+ "gdbarch_dump: SMASH_TEXT_ADDRESS = <0x%08lx>\n",
(long) current_gdbarch->smash_text_address
/*SMASH_TEXT_ADDRESS ()*/);
#endif
+#ifdef SOFTWARE_SINGLE_STEP_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "SOFTWARE_SINGLE_STEP_P()",
+ XSTRING (SOFTWARE_SINGLE_STEP_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: SOFTWARE_SINGLE_STEP_P() = %d\n",
+ SOFTWARE_SINGLE_STEP_P ());
+#endif
#ifdef SOFTWARE_SINGLE_STEP
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: SOFTWARE_SINGLE_STEP = 0x%08lx\n",
+ "gdbarch_dump: SOFTWARE_SINGLE_STEP = <0x%08lx>\n",
(long) current_gdbarch->software_single_step
/*SOFTWARE_SINGLE_STEP ()*/);
#endif
XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: STAB_REG_TO_REGNUM = 0x%08lx\n",
+ "gdbarch_dump: STAB_REG_TO_REGNUM = <0x%08lx>\n",
(long) current_gdbarch->stab_reg_to_regnum
/*STAB_REG_TO_REGNUM ()*/);
#endif
+#ifdef STACK_ALIGN_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "STACK_ALIGN_P()",
+ XSTRING (STACK_ALIGN_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: STACK_ALIGN_P() = %d\n",
+ STACK_ALIGN_P ());
+#endif
#ifdef STACK_ALIGN
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (STACK_ALIGN (sp)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: STACK_ALIGN = 0x%08lx\n",
+ "gdbarch_dump: STACK_ALIGN = <0x%08lx>\n",
(long) current_gdbarch->stack_align
/*STACK_ALIGN ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: STORE_RETURN_VALUE = 0x%08lx\n",
+ "gdbarch_dump: STORE_RETURN_VALUE = <0x%08lx>\n",
(long) current_gdbarch->store_return_value
/*STORE_RETURN_VALUE ()*/);
#endif
-#ifdef STORE_STRUCT_RETURN
-#if GDB_MULTI_ARCH
- /* Macro might contain `[{}]' when not multi-arch */
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "STORE_STRUCT_RETURN(addr, sp)",
- XSTRING (STORE_STRUCT_RETURN (addr, sp)));
-#endif
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: STORE_STRUCT_RETURN = 0x%08lx\n",
- (long) current_gdbarch->store_struct_return
- /*STORE_STRUCT_RETURN ()*/);
-#endif
#ifdef TARGET_ADDR_BIT
fprintf_unfiltered (file,
"gdbarch_dump: TARGET_ADDR_BIT # %s\n",
"gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
XSTRING (TARGET_DOUBLE_FORMAT));
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_DOUBLE_FORMAT = %ld\n",
- (long) TARGET_DOUBLE_FORMAT);
+ "gdbarch_dump: TARGET_DOUBLE_FORMAT = %s\n",
+ (TARGET_DOUBLE_FORMAT)->name);
#endif
#ifdef TARGET_FLOAT_BIT
fprintf_unfiltered (file,
"gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
XSTRING (TARGET_FLOAT_FORMAT));
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_FLOAT_FORMAT = %ld\n",
- (long) TARGET_FLOAT_FORMAT);
+ "gdbarch_dump: TARGET_FLOAT_FORMAT = %s\n",
+ (TARGET_FLOAT_FORMAT)->name);
#endif
#ifdef TARGET_INT_BIT
fprintf_unfiltered (file,
"gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
XSTRING (TARGET_LONG_DOUBLE_FORMAT));
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %ld\n",
- (long) TARGET_LONG_DOUBLE_FORMAT);
+ "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %s\n",
+ (TARGET_LONG_DOUBLE_FORMAT)->name);
#endif
#ifdef TARGET_LONG_LONG_BIT
fprintf_unfiltered (file,
"gdbarch_dump: TARGET_LONG_LONG_BIT = %d\n",
TARGET_LONG_LONG_BIT);
#endif
+#ifdef TARGET_OSABI
+ fprintf_unfiltered (file,
+ "gdbarch_dump: TARGET_OSABI # %s\n",
+ XSTRING (TARGET_OSABI));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: TARGET_OSABI = %ld\n",
+ (long) TARGET_OSABI);
+#endif
#ifdef TARGET_PRINT_INSN
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (TARGET_PRINT_INSN (vma, info)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_PRINT_INSN = 0x%08lx\n",
+ "gdbarch_dump: TARGET_PRINT_INSN = <0x%08lx>\n",
(long) current_gdbarch->print_insn
/*TARGET_PRINT_INSN ()*/);
#endif
XSTRING (TARGET_READ_FP ()));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_READ_FP = 0x%08lx\n",
+ "gdbarch_dump: TARGET_READ_FP = <0x%08lx>\n",
(long) current_gdbarch->read_fp
/*TARGET_READ_FP ()*/);
#endif
XSTRING (TARGET_READ_PC (ptid)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_READ_PC = 0x%08lx\n",
+ "gdbarch_dump: TARGET_READ_PC = <0x%08lx>\n",
(long) current_gdbarch->read_pc
/*TARGET_READ_PC ()*/);
#endif
XSTRING (TARGET_READ_SP ()));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_READ_SP = 0x%08lx\n",
+ "gdbarch_dump: TARGET_READ_SP = <0x%08lx>\n",
(long) current_gdbarch->read_sp
/*TARGET_READ_SP ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = 0x%08lx\n",
+ "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = <0x%08lx>\n",
(long) current_gdbarch->virtual_frame_pointer
/*TARGET_VIRTUAL_FRAME_POINTER ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_WRITE_PC = 0x%08lx\n",
+ "gdbarch_dump: TARGET_WRITE_PC = <0x%08lx>\n",
(long) current_gdbarch->write_pc
/*TARGET_WRITE_PC ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_WRITE_SP = 0x%08lx\n",
+ "gdbarch_dump: TARGET_WRITE_SP = <0x%08lx>\n",
(long) current_gdbarch->write_sp
/*TARGET_WRITE_SP ()*/);
#endif
-#ifdef USE_GENERIC_DUMMY_FRAMES
- fprintf_unfiltered (file,
- "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES # %s\n",
- XSTRING (USE_GENERIC_DUMMY_FRAMES));
- fprintf_unfiltered (file,
- "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES = %d\n",
- USE_GENERIC_DUMMY_FRAMES);
-#endif
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "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);
#ifdef USE_STRUCT_CONVENTION
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
XSTRING (USE_STRUCT_CONVENTION (gcc_p, value_type)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: USE_STRUCT_CONVENTION = 0x%08lx\n",
+ "gdbarch_dump: USE_STRUCT_CONVENTION = <0x%08lx>\n",
(long) current_gdbarch->use_struct_convention
/*USE_STRUCT_CONVENTION ()*/);
#endif
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
- "gdbarch_dump: VALUE_TO_REGISTER = 0x%08lx\n",
+ "gdbarch_dump: VALUE_TO_REGISTER = <0x%08lx>\n",
(long) current_gdbarch->value_to_register
/*VALUE_TO_REGISTER ()*/);
#endif
return gdbarch->byte_order;
}
+enum gdb_osabi
+gdbarch_osabi (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
+ return gdbarch->osabi;
+}
+
int
gdbarch_short_bit (struct gdbarch *gdbarch)
{
}
int
-gdbarch_max_register_raw_size (struct gdbarch *gdbarch)
+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->max_register_raw_size == -1)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_max_register_raw_size invalid");
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_max_register_raw_size called\n");
- return gdbarch->max_register_raw_size;
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_max_register_raw_size called\n");
+ return gdbarch->deprecated_max_register_raw_size;
}
void
-set_gdbarch_max_register_raw_size (struct gdbarch *gdbarch,
- int max_register_raw_size)
+set_gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarch,
+ int deprecated_max_register_raw_size)
{
- gdbarch->max_register_raw_size = max_register_raw_size;
+ gdbarch->deprecated_max_register_raw_size = deprecated_max_register_raw_size;
}
int
}
int
-gdbarch_max_register_virtual_size (struct gdbarch *gdbarch)
+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->max_register_virtual_size == -1)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_max_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_max_register_virtual_size called\n");
+ return gdbarch->deprecated_max_register_virtual_size;
}
void
-set_gdbarch_max_register_virtual_size (struct gdbarch *gdbarch,
- int max_register_virtual_size)
+set_gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch,
+ int deprecated_max_register_virtual_size)
+{
+ gdbarch->deprecated_max_register_virtual_size = deprecated_max_register_virtual_size;
+}
+
+int
+gdbarch_register_virtual_type_p (struct gdbarch *gdbarch)
{
- gdbarch->max_register_virtual_size = max_register_virtual_size;
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->register_virtual_type != 0;
}
struct type *
}
int
-gdbarch_do_registers_info_p (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_type == 0)
+ internal_error (__FILE__, __LINE__,
+ "gdbarch: gdbarch_register_type invalid");
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
+ return gdbarch->register_type (gdbarch, reg_nr);
+}
+
+void
+set_gdbarch_register_type (struct gdbarch *gdbarch,
+ gdbarch_register_type_ftype register_type)
+{
+ gdbarch->register_type = register_type;
+}
+
+int
+gdbarch_deprecated_do_registers_info_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- return gdbarch->do_registers_info != 0;
+ return gdbarch->deprecated_do_registers_info != 0;
}
void
-gdbarch_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs)
+gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->do_registers_info == 0)
+ if (gdbarch->deprecated_do_registers_info == 0)
internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_do_registers_info invalid");
+ "gdbarch: gdbarch_deprecated_do_registers_info invalid");
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_do_registers_info called\n");
- gdbarch->do_registers_info (reg_nr, fpregs);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_do_registers_info called\n");
+ gdbarch->deprecated_do_registers_info (reg_nr, fpregs);
}
void
-set_gdbarch_do_registers_info (struct gdbarch *gdbarch,
- gdbarch_do_registers_info_ftype do_registers_info)
+set_gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch,
+ gdbarch_deprecated_do_registers_info_ftype deprecated_do_registers_info)
{
- gdbarch->do_registers_info = do_registers_info;
+ gdbarch->deprecated_do_registers_info = deprecated_do_registers_info;
}
void
}
int
-gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch)
+gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->use_generic_dummy_frames == -1)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_use_generic_dummy_frames invalid");
+ /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_use_generic_dummy_frames called\n");
- return gdbarch->use_generic_dummy_frames;
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_generic_dummy_frames called\n");
+ return gdbarch->deprecated_use_generic_dummy_frames;
}
void
-set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch,
- int use_generic_dummy_frames)
+set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch,
+ int deprecated_use_generic_dummy_frames)
{
- gdbarch->use_generic_dummy_frames = use_generic_dummy_frames;
+ gdbarch->deprecated_use_generic_dummy_frames = deprecated_use_generic_dummy_frames;
}
int
gdbarch_call_dummy_location (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->call_dummy_location == 0)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_call_dummy_location invalid");
+ /* Skip verify of call_dummy_location, invalid_p == 0 */
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
return gdbarch->call_dummy_location;
}
int
-gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
+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;
+}
+
+int
+gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->pc_in_call_dummy == 0)
+ if (gdbarch->deprecated_pc_in_call_dummy == 0)
internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_pc_in_call_dummy invalid");
+ "gdbarch: gdbarch_deprecated_pc_in_call_dummy invalid");
+ /* Ignore predicate (gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy). */
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_call_dummy called\n");
- return gdbarch->pc_in_call_dummy (pc, sp, frame_address);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pc_in_call_dummy called\n");
+ return gdbarch->deprecated_pc_in_call_dummy (pc, sp, frame_address);
}
void
-set_gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch,
- gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy)
+set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch,
+ gdbarch_deprecated_pc_in_call_dummy_ftype deprecated_pc_in_call_dummy)
{
- gdbarch->pc_in_call_dummy = pc_in_call_dummy;
+ gdbarch->deprecated_pc_in_call_dummy = deprecated_pc_in_call_dummy;
}
int
}
int
-gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->call_dummy_stack_adjust_p == -1)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_stack_adjust_p called\n");
- return gdbarch->call_dummy_stack_adjust_p;
-}
-
-void
-set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch *gdbarch,
- int call_dummy_stack_adjust_p)
-{
- gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p;
+ return gdbarch->deprecated_call_dummy_stack_adjust != 0;
}
int
-gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch)
+gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_call_dummy_stack_adjust invalid");
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_call_dummy_stack_adjust called\n");
+ return gdbarch->deprecated_call_dummy_stack_adjust;
}
void
-set_gdbarch_call_dummy_stack_adjust (struct gdbarch *gdbarch,
- int call_dummy_stack_adjust)
+set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch,
+ int deprecated_call_dummy_stack_adjust)
{
- gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust;
+ gdbarch->deprecated_call_dummy_stack_adjust = deprecated_call_dummy_stack_adjust;
}
void
gdbarch->fix_call_dummy = fix_call_dummy;
}
-void
-gdbarch_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
+int
+gdbarch_deprecated_init_frame_pc_first_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->deprecated_init_frame_pc_first != 0;
+}
+
+CORE_ADDR
+gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->init_frame_pc_first == 0)
+ if (gdbarch->deprecated_init_frame_pc_first == 0)
internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_init_frame_pc_first invalid");
+ "gdbarch: gdbarch_deprecated_init_frame_pc_first invalid");
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_init_frame_pc_first called\n");
- gdbarch->init_frame_pc_first (fromleaf, prev);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc_first called\n");
+ return gdbarch->deprecated_init_frame_pc_first (fromleaf, prev);
}
void
-set_gdbarch_init_frame_pc_first (struct gdbarch *gdbarch,
- gdbarch_init_frame_pc_first_ftype init_frame_pc_first)
+set_gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch,
+ gdbarch_deprecated_init_frame_pc_first_ftype deprecated_init_frame_pc_first)
{
- gdbarch->init_frame_pc_first = init_frame_pc_first;
+ gdbarch->deprecated_init_frame_pc_first = deprecated_init_frame_pc_first;
}
-void
-gdbarch_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
+int
+gdbarch_deprecated_init_frame_pc_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->deprecated_init_frame_pc != 0;
+}
+
+CORE_ADDR
+gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->init_frame_pc == 0)
+ if (gdbarch->deprecated_init_frame_pc == 0)
internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_init_frame_pc invalid");
+ "gdbarch: gdbarch_deprecated_init_frame_pc invalid");
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_init_frame_pc called\n");
- gdbarch->init_frame_pc (fromleaf, prev);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc called\n");
+ return gdbarch->deprecated_init_frame_pc (fromleaf, prev);
}
void
-set_gdbarch_init_frame_pc (struct gdbarch *gdbarch,
- gdbarch_init_frame_pc_ftype init_frame_pc)
+set_gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch,
+ gdbarch_deprecated_init_frame_pc_ftype deprecated_init_frame_pc)
{
- gdbarch->init_frame_pc = init_frame_pc;
+ gdbarch->deprecated_init_frame_pc = deprecated_init_frame_pc;
}
int
}
int
-gdbarch_coerce_float_to_double (struct gdbarch *gdbarch, struct type *formal, struct type *actual)
+gdbarch_deprecated_get_saved_register_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->coerce_float_to_double == 0)
- internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_coerce_float_to_double invalid");
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_coerce_float_to_double called\n");
- return gdbarch->coerce_float_to_double (formal, actual);
-}
-
-void
-set_gdbarch_coerce_float_to_double (struct gdbarch *gdbarch,
- gdbarch_coerce_float_to_double_ftype coerce_float_to_double)
-{
- gdbarch->coerce_float_to_double = coerce_float_to_double;
+ return gdbarch->deprecated_get_saved_register != 0;
}
void
-gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
+gdbarch_deprecated_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->get_saved_register == 0)
+ if (gdbarch->deprecated_get_saved_register == 0)
internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_get_saved_register invalid");
+ "gdbarch: gdbarch_deprecated_get_saved_register invalid");
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_get_saved_register called\n");
- gdbarch->get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_get_saved_register called\n");
+ gdbarch->deprecated_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
}
void
-set_gdbarch_get_saved_register (struct gdbarch *gdbarch,
- gdbarch_get_saved_register_ftype get_saved_register)
+set_gdbarch_deprecated_get_saved_register (struct gdbarch *gdbarch,
+ gdbarch_deprecated_get_saved_register_ftype deprecated_get_saved_register)
{
- gdbarch->get_saved_register = get_saved_register;
+ gdbarch->deprecated_get_saved_register = deprecated_get_saved_register;
}
int
}
CORE_ADDR
-gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
+gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const void *buf)
{
gdb_assert (gdbarch != NULL);
if (gdbarch->pointer_to_address == 0)
gdbarch->push_arguments = push_arguments;
}
+int
+gdbarch_deprecated_push_dummy_frame_p (struct gdbarch *gdbarch)
+{
+ 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 = push_return_address;
}
+int
+gdbarch_deprecated_pop_frame_p (struct gdbarch *gdbarch)
+{
+ 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->pop_frame = pop_frame;
+ gdbarch->deprecated_pop_frame = deprecated_pop_frame;
+}
+
+int
+gdbarch_deprecated_store_struct_return_p (struct gdbarch *gdbarch)
+{
+ 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
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
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 (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
+gdbarch_deprecated_frame_saved_pc_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ 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->frame_chain_valid == 0)
+ if (gdbarch->deprecated_frame_saved_pc == 0)
internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_frame_chain_valid invalid");
+ "gdbarch: gdbarch_deprecated_frame_saved_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_deprecated_frame_saved_pc called\n");
+ return gdbarch->deprecated_frame_saved_pc (fi);
}
void
-set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch,
- gdbarch_frame_chain_valid_ftype frame_chain_valid)
+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_unwind_pc_p (struct gdbarch *gdbarch)
{
- gdbarch->frame_chain_valid = frame_chain_valid;
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->unwind_pc != 0;
}
CORE_ADDR
-gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
+gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->frame_saved_pc == 0)
+ if (gdbarch->unwind_pc == 0)
internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_frame_saved_pc invalid");
+ "gdbarch: gdbarch_unwind_pc 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_pc called\n");
+ return gdbarch->unwind_pc (gdbarch, next_frame);
}
void
-set_gdbarch_frame_saved_pc (struct gdbarch *gdbarch,
- gdbarch_frame_saved_pc_ftype frame_saved_pc)
+set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
+ gdbarch_unwind_pc_ftype unwind_pc)
{
- gdbarch->frame_saved_pc = frame_saved_pc;
+ gdbarch->unwind_pc = unwind_pc;
}
CORE_ADDR
}
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
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)
{
gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
}
+int
+gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
+ return gdbarch->have_nonsteppable_watchpoint;
+}
+
+void
+set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
+ int have_nonsteppable_watchpoint)
+{
+ gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
+}
+
+int
+gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->address_class_type_flags != 0;
+}
+
+int
+gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
+{
+ gdb_assert (gdbarch != NULL);
+ if (gdbarch->address_class_type_flags == 0)
+ internal_error (__FILE__, __LINE__,
+ "gdbarch: gdbarch_address_class_type_flags invalid");
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
+ return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
+}
+
+void
+set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
+ gdbarch_address_class_type_flags_ftype address_class_type_flags)
+{
+ gdbarch->address_class_type_flags = address_class_type_flags;
+}
+
+int
+gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->address_class_type_flags_to_name != 0;
+}
+
+const char *
+gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
+{
+ gdb_assert (gdbarch != NULL);
+ if (gdbarch->address_class_type_flags_to_name == 0)
+ internal_error (__FILE__, __LINE__,
+ "gdbarch: gdbarch_address_class_type_flags_to_name invalid");
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
+ return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
+}
+
+void
+set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
+ gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
+{
+ gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
+}
+
+int
+gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->address_class_name_to_type_flags != 0;
+}
+
+int
+gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
+{
+ gdb_assert (gdbarch != NULL);
+ if (gdbarch->address_class_name_to_type_flags == 0)
+ internal_error (__FILE__, __LINE__,
+ "gdbarch: gdbarch_address_class_name_to_type_flags invalid");
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
+ return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
+}
+
+void
+set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
+ gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
+{
+ gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
+}
+
+int
+gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
+{
+ gdb_assert (gdbarch != NULL);
+ if (gdbarch->register_reggroup_p == 0)
+ internal_error (__FILE__, __LINE__,
+ "gdbarch: gdbarch_register_reggroup_p invalid");
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
+ return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
+}
+
+void
+set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
+ gdbarch_register_reggroup_p_ftype register_reggroup_p)
+{
+ gdbarch->register_reggroup_p = register_reggroup_p;
+}
+
/* Keep a registry of per-architecture data-pointers required by GDB
modules. */
continue;
if (info->byte_order != arches->gdbarch->byte_order)
continue;
+ if (info->osabi != arches->gdbarch->osabi)
+ continue;
return arches;
}
return NULL;
if (info.byte_order == BFD_ENDIAN_UNKNOWN)
info.byte_order = TARGET_BYTE_ORDER;
+ /* ``(gdb) set osabi ...'' is handled by gdbarch_lookup_osabi. */
+ if (info.osabi == GDB_OSABI_UNINITIALIZED)
+ info.osabi = gdbarch_lookup_osabi (info.abfd);
+ if (info.osabi == GDB_OSABI_UNINITIALIZED)
+ info.osabi = current_gdbarch->osabi;
+
/* Must have found some sort of architecture. */
gdb_assert (info.bfd_arch_info != NULL);
(info.byte_order == BFD_ENDIAN_BIG ? "big"
: info.byte_order == BFD_ENDIAN_LITTLE ? "little"
: "default"));
+ fprintf_unfiltered (gdb_stdlog,
+ "gdbarch_update: info.osabi %d (%s)\n",
+ info.osabi, gdbarch_osabi_name (info.osabi));
fprintf_unfiltered (gdb_stdlog,
"gdbarch_update: info.abfd 0x%lx\n",
(long) info.abfd);