const struct floatformat ** long_double_format;
int ptr_bit;
int addr_bit;
- int bfd_vma_bit;
int char_signed;
gdbarch_read_pc_ftype *read_pc;
gdbarch_write_pc_ftype *write_pc;
gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
int deprecated_fp_regnum;
gdbarch_push_dummy_call_ftype *push_dummy_call;
- int deprecated_register_size;
int call_dummy_location;
gdbarch_push_dummy_code_ftype *push_dummy_code;
gdbarch_print_registers_info_ftype *print_registers_info;
gdbarch_print_float_info_ftype *print_float_info;
gdbarch_print_vector_info_ftype *print_vector_info;
gdbarch_register_sim_regno_ftype *register_sim_regno;
- gdbarch_register_bytes_ok_ftype *register_bytes_ok;
gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
gdbarch_cannot_store_register_ftype *cannot_store_register;
gdbarch_get_longjmp_target_ftype *get_longjmp_target;
gdbarch_extract_return_value_ftype *extract_return_value;
gdbarch_store_return_value_ftype *store_return_value;
gdbarch_deprecated_use_struct_convention_ftype *deprecated_use_struct_convention;
- gdbarch_deprecated_extract_struct_value_address_ftype *deprecated_extract_struct_value_address;
gdbarch_skip_prologue_ftype *skip_prologue;
gdbarch_inner_than_ftype *inner_than;
gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
gdbarch_unwind_pc_ftype *unwind_pc;
gdbarch_unwind_sp_ftype *unwind_sp;
gdbarch_frame_num_args_ftype *frame_num_args;
- gdbarch_deprecated_stack_align_ftype *deprecated_stack_align;
gdbarch_frame_align_ftype *frame_align;
gdbarch_deprecated_reg_struct_has_addr_ftype *deprecated_reg_struct_has_addr;
gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr;
0, /* long_double_format */
8 * sizeof (void*), /* ptr_bit */
8 * sizeof (void*), /* addr_bit */
- 8 * sizeof (void*), /* bfd_vma_bit */
1, /* char_signed */
0, /* read_pc */
0, /* write_pc */
0, /* unwind_dummy_id */
-1, /* deprecated_fp_regnum */
0, /* push_dummy_call */
- 0, /* deprecated_register_size */
0, /* call_dummy_location */
0, /* push_dummy_code */
default_print_registers_info, /* print_registers_info */
0, /* print_float_info */
0, /* print_vector_info */
0, /* register_sim_regno */
- 0, /* register_bytes_ok */
0, /* cannot_fetch_register */
0, /* cannot_store_register */
0, /* get_longjmp_target */
0, /* extract_return_value */
0, /* store_return_value */
0, /* deprecated_use_struct_convention */
- 0, /* deprecated_extract_struct_value_address */
0, /* skip_prologue */
0, /* inner_than */
0, /* breakpoint_from_pc */
0, /* unwind_pc */
0, /* unwind_sp */
0, /* frame_num_args */
- 0, /* deprecated_stack_align */
0, /* frame_align */
0, /* deprecated_reg_struct_has_addr */
default_stabs_argument_has_addr, /* stabs_argument_has_addr */
struct gdbarch_tdep *tdep)
{
/* NOTE: The new architecture variable is named ``current_gdbarch''
- so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
+ so that macros such as TARGET_ARCHITECTURE, when expanded, refer to
the current local architecture and not the previous global
architecture. This ensures that the new architectures initial
values are not influenced by the previous architecture. Once
current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
- current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;
+ current_gdbarch->long_long_bit = 2*current_gdbarch->long_bit;
current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
- current_gdbarch->ptr_bit = TARGET_INT_BIT;
- current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
+ current_gdbarch->ptr_bit = current_gdbarch->int_bit;
current_gdbarch->char_signed = -1;
- current_gdbarch->write_pc = generic_target_write_pc;
current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
current_gdbarch->num_regs = -1;
current_gdbarch->sp_regnum = -1;
current_gdbarch->long_double_format = floatformats_ieee_double;
/* Skip verify of ptr_bit, invalid_p == 0 */
if (current_gdbarch->addr_bit == 0)
- current_gdbarch->addr_bit = TARGET_PTR_BIT;
- /* Skip verify of bfd_vma_bit, invalid_p == 0 */
+ current_gdbarch->addr_bit = gdbarch_ptr_bit (current_gdbarch);
if (current_gdbarch->char_signed == -1)
current_gdbarch->char_signed = 1;
/* Skip verify of read_pc, has predicate */
- /* Skip verify of write_pc, invalid_p == 0 */
+ /* Skip verify of write_pc, has predicate */
/* Skip verify of virtual_frame_pointer, invalid_p == 0 */
/* Skip verify of pseudo_register_read, has predicate */
/* Skip verify of pseudo_register_write, has predicate */
/* Skip verify of print_float_info, has predicate */
/* Skip verify of print_vector_info, has predicate */
/* Skip verify of register_sim_regno, invalid_p == 0 */
- /* Skip verify of register_bytes_ok, has predicate */
/* Skip verify of cannot_fetch_register, invalid_p == 0 */
/* Skip verify of cannot_store_register, invalid_p == 0 */
/* Skip verify of get_longjmp_target, has predicate */
/* Skip verify of integer_to_address, has predicate */
/* Skip verify of return_value, has predicate */
/* Skip verify of deprecated_use_struct_convention, invalid_p == 0 */
- /* Skip verify of deprecated_extract_struct_value_address, has predicate */
if (current_gdbarch->skip_prologue == 0)
fprintf_unfiltered (log, "\n\tskip_prologue");
if (current_gdbarch->inner_than == 0)
/* Skip verify of unwind_pc, has predicate */
/* Skip verify of unwind_sp, has predicate */
/* Skip verify of frame_num_args, has predicate */
- /* Skip verify of deprecated_stack_align, has predicate */
/* Skip verify of frame_align, has predicate */
/* Skip verify of deprecated_reg_struct_has_addr, has predicate */
/* Skip verify of stabs_argument_has_addr, invalid_p == 0 */
fprintf_unfiltered (file,
"gdbarch_dump: GDB_TM_FILE = %s\n",
gdb_tm_file);
-#ifdef TARGET_ADDR_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
- XSTRING (TARGET_ADDR_BIT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: addr_bit = %s\n",
paddr_d (current_gdbarch->addr_bit));
-#ifdef ADDR_BITS_REMOVE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "ADDR_BITS_REMOVE(addr)",
- XSTRING (ADDR_BITS_REMOVE (addr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: addr_bits_remove = <0x%lx>\n",
(long) current_gdbarch->addr_bits_remove);
fprintf_unfiltered (file,
"gdbarch_dump: address_class_name_to_type_flags = <0x%lx>\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 ()));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_address_class_type_flags_p() = %d\n",
gdbarch_address_class_type_flags_p (current_gdbarch));
-#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)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: address_class_type_flags = <0x%lx>\n",
(long) current_gdbarch->address_class_type_flags);
fprintf_unfiltered (file,
"gdbarch_dump: address_class_type_flags_to_name = <0x%lx>\n",
(long) current_gdbarch->address_class_type_flags_to_name);
-#ifdef ADDRESS_TO_POINTER
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "ADDRESS_TO_POINTER(type, buf, addr)",
- XSTRING (ADDRESS_TO_POINTER (type, buf, addr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: address_to_pointer = <0x%lx>\n",
(long) current_gdbarch->address_to_pointer);
fprintf_unfiltered (file,
"gdbarch_dump: adjust_breakpoint_address = <0x%lx>\n",
(long) current_gdbarch->adjust_breakpoint_address);
-#ifdef BELIEVE_PCC_PROMOTION
- fprintf_unfiltered (file,
- "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
- XSTRING (BELIEVE_PCC_PROMOTION));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: believe_pcc_promotion = %s\n",
paddr_d (current_gdbarch->believe_pcc_promotion));
-#ifdef TARGET_ARCHITECTURE
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
- XSTRING (TARGET_ARCHITECTURE));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: bfd_arch_info = %s\n",
- TARGET_ARCHITECTURE->printable_name);
-#ifdef TARGET_BFD_VMA_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
- XSTRING (TARGET_BFD_VMA_BIT));
-#endif
- fprintf_unfiltered (file,
- "gdbarch_dump: bfd_vma_bit = %s\n",
- paddr_d (current_gdbarch->bfd_vma_bit));
-#ifdef BREAKPOINT_FROM_PC
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "BREAKPOINT_FROM_PC(pcptr, lenptr)",
- XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
-#endif
+ gdbarch_bfd_arch_info (current_gdbarch)->printable_name);
fprintf_unfiltered (file,
"gdbarch_dump: breakpoint_from_pc = <0x%lx>\n",
(long) current_gdbarch->breakpoint_from_pc);
fprintf_unfiltered (file,
"gdbarch_dump: call_dummy_location = %s\n",
paddr_d (current_gdbarch->call_dummy_location));
-#ifdef CANNOT_FETCH_REGISTER
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "CANNOT_FETCH_REGISTER(regnum)",
- XSTRING (CANNOT_FETCH_REGISTER (regnum)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: cannot_fetch_register = <0x%lx>\n",
(long) current_gdbarch->cannot_fetch_register);
-#ifdef CANNOT_STEP_BREAKPOINT
- fprintf_unfiltered (file,
- "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
- XSTRING (CANNOT_STEP_BREAKPOINT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: cannot_step_breakpoint = %s\n",
paddr_d (current_gdbarch->cannot_step_breakpoint));
-#ifdef CANNOT_STORE_REGISTER
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "CANNOT_STORE_REGISTER(regnum)",
- XSTRING (CANNOT_STORE_REGISTER (regnum)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: cannot_store_register = <0x%lx>\n",
(long) current_gdbarch->cannot_store_register);
fprintf_unfiltered (file,
"gdbarch_dump: char_signed = %s\n",
paddr_d (current_gdbarch->char_signed));
-#ifdef COFF_MAKE_MSYMBOL_SPECIAL
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
- XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val, msym)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: coff_make_msymbol_special = <0x%lx>\n",
(long) current_gdbarch->coff_make_msymbol_special);
fprintf_unfiltered (file,
"gdbarch_dump: convert_from_func_ptr_addr = <0x%lx>\n",
(long) current_gdbarch->convert_from_func_ptr_addr);
-#ifdef CONVERT_REGISTER_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "CONVERT_REGISTER_P(regnum, type)",
- XSTRING (CONVERT_REGISTER_P (regnum, type)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: convert_register_p = <0x%lx>\n",
(long) current_gdbarch->convert_register_p);
-#ifdef DECR_PC_AFTER_BREAK
- fprintf_unfiltered (file,
- "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
- XSTRING (DECR_PC_AFTER_BREAK));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: decr_pc_after_break = 0x%s\n",
paddr_nz (current_gdbarch->decr_pc_after_break));
-#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 ()));
-#endif
- fprintf_unfiltered (file,
- "gdbarch_dump: gdbarch_deprecated_extract_struct_value_address_p() = %d\n",
- gdbarch_deprecated_extract_struct_value_address_p (current_gdbarch));
-#ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
- XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
-#endif
- fprintf_unfiltered (file,
- "gdbarch_dump: deprecated_extract_struct_value_address = <0x%lx>\n",
- (long) current_gdbarch->deprecated_extract_struct_value_address);
-#ifdef DEPRECATED_FP_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
- XSTRING (DEPRECATED_FP_REGNUM));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: deprecated_fp_regnum = %s\n",
paddr_d (current_gdbarch->deprecated_fp_regnum));
-#ifdef DEPRECATED_FUNCTION_START_OFFSET
- fprintf_unfiltered (file,
- "gdbarch_dump: DEPRECATED_FUNCTION_START_OFFSET # %s\n",
- XSTRING (DEPRECATED_FUNCTION_START_OFFSET));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: deprecated_function_start_offset = 0x%s\n",
paddr_nz (current_gdbarch->deprecated_function_start_offset));
-#ifdef DEPRECATED_REG_STRUCT_HAS_ADDR_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DEPRECATED_REG_STRUCT_HAS_ADDR_P()",
- XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_deprecated_reg_struct_has_addr_p() = %d\n",
gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch));
-#ifdef DEPRECATED_REG_STRUCT_HAS_ADDR
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DEPRECATED_REG_STRUCT_HAS_ADDR(gcc_p, type)",
- XSTRING (DEPRECATED_REG_STRUCT_HAS_ADDR (gcc_p, type)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: deprecated_reg_struct_has_addr = <0x%lx>\n",
(long) current_gdbarch->deprecated_reg_struct_has_addr);
-#ifdef DEPRECATED_REGISTER_SIZE
- fprintf_unfiltered (file,
- "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
- XSTRING (DEPRECATED_REGISTER_SIZE));
-#endif
- fprintf_unfiltered (file,
- "gdbarch_dump: deprecated_register_size = %s\n",
- paddr_d (current_gdbarch->deprecated_register_size));
-#ifdef DEPRECATED_STACK_ALIGN_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DEPRECATED_STACK_ALIGN_P()",
- XSTRING (DEPRECATED_STACK_ALIGN_P ()));
-#endif
- fprintf_unfiltered (file,
- "gdbarch_dump: gdbarch_deprecated_stack_align_p() = %d\n",
- gdbarch_deprecated_stack_align_p (current_gdbarch));
-#ifdef DEPRECATED_STACK_ALIGN
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DEPRECATED_STACK_ALIGN(sp)",
- XSTRING (DEPRECATED_STACK_ALIGN (sp)));
-#endif
- fprintf_unfiltered (file,
- "gdbarch_dump: deprecated_stack_align = <0x%lx>\n",
- (long) current_gdbarch->deprecated_stack_align);
-#ifdef DEPRECATED_USE_STRUCT_CONVENTION
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DEPRECATED_USE_STRUCT_CONVENTION(gcc_p, value_type)",
- XSTRING (DEPRECATED_USE_STRUCT_CONVENTION (gcc_p, value_type)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: deprecated_use_struct_convention = <0x%lx>\n",
(long) current_gdbarch->deprecated_use_struct_convention);
-#ifdef TARGET_DOUBLE_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
- XSTRING (TARGET_DOUBLE_BIT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: double_bit = %s\n",
paddr_d (current_gdbarch->double_bit));
-#ifdef TARGET_DOUBLE_FORMAT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
- XSTRING (TARGET_DOUBLE_FORMAT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: double_format = %s\n",
pformat (current_gdbarch->double_format));
-#ifdef DWARF2_REG_TO_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
- XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: dwarf2_reg_to_regnum = <0x%lx>\n",
(long) current_gdbarch->dwarf2_reg_to_regnum);
-#ifdef DWARF_REG_TO_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "DWARF_REG_TO_REGNUM(dwarf_regnr)",
- XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: dwarf_reg_to_regnum = <0x%lx>\n",
(long) current_gdbarch->dwarf_reg_to_regnum);
-#ifdef ECOFF_REG_TO_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
- XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: ecoff_reg_to_regnum = <0x%lx>\n",
(long) current_gdbarch->ecoff_reg_to_regnum);
-#ifdef ELF_MAKE_MSYMBOL_SPECIAL
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
- XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym, msym)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: elf_make_msymbol_special = <0x%lx>\n",
(long) current_gdbarch->elf_make_msymbol_special);
-#ifdef EXTRACT_RETURN_VALUE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
- XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: extract_return_value = <0x%lx>\n",
(long) current_gdbarch->extract_return_value);
-#ifdef FETCH_POINTER_ARGUMENT_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FETCH_POINTER_ARGUMENT_P()",
- XSTRING (FETCH_POINTER_ARGUMENT_P ()));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_fetch_pointer_argument_p() = %d\n",
gdbarch_fetch_pointer_argument_p (current_gdbarch));
-#ifdef FETCH_POINTER_ARGUMENT
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FETCH_POINTER_ARGUMENT(frame, argi, type)",
- XSTRING (FETCH_POINTER_ARGUMENT (frame, argi, type)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: fetch_pointer_argument = <0x%lx>\n",
(long) current_gdbarch->fetch_pointer_argument);
-#ifdef FETCH_TLS_LOAD_MODULE_ADDRESS_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FETCH_TLS_LOAD_MODULE_ADDRESS_P()",
- XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS_P ()));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_fetch_tls_load_module_address_p() = %d\n",
gdbarch_fetch_tls_load_module_address_p (current_gdbarch));
-#ifdef FETCH_TLS_LOAD_MODULE_ADDRESS
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FETCH_TLS_LOAD_MODULE_ADDRESS(objfile)",
- XSTRING (FETCH_TLS_LOAD_MODULE_ADDRESS (objfile)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: fetch_tls_load_module_address = <0x%lx>\n",
(long) current_gdbarch->fetch_tls_load_module_address);
-#ifdef TARGET_FLOAT_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
- XSTRING (TARGET_FLOAT_BIT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: float_bit = %s\n",
paddr_d (current_gdbarch->float_bit));
-#ifdef TARGET_FLOAT_FORMAT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
- XSTRING (TARGET_FLOAT_FORMAT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: float_format = %s\n",
pformat (current_gdbarch->float_format));
-#ifdef FP0_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: FP0_REGNUM # %s\n",
- XSTRING (FP0_REGNUM));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: fp0_regnum = %s\n",
paddr_d (current_gdbarch->fp0_regnum));
fprintf_unfiltered (file,
"gdbarch_dump: frame_align = <0x%lx>\n",
(long) current_gdbarch->frame_align);
-#ifdef FRAME_ARGS_SKIP
- fprintf_unfiltered (file,
- "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
- XSTRING (FRAME_ARGS_SKIP));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: frame_args_skip = 0x%s\n",
paddr_nz (current_gdbarch->frame_args_skip));
-#ifdef FRAME_NUM_ARGS_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FRAME_NUM_ARGS_P()",
- XSTRING (FRAME_NUM_ARGS_P ()));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_frame_num_args_p() = %d\n",
gdbarch_frame_num_args_p (current_gdbarch));
-#ifdef FRAME_NUM_ARGS
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FRAME_NUM_ARGS(frame)",
- XSTRING (FRAME_NUM_ARGS (frame)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: frame_num_args = <0x%lx>\n",
(long) current_gdbarch->frame_num_args);
-#ifdef FRAME_RED_ZONE_SIZE
- fprintf_unfiltered (file,
- "gdbarch_dump: FRAME_RED_ZONE_SIZE # %s\n",
- XSTRING (FRAME_RED_ZONE_SIZE));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: frame_red_zone_size = %s\n",
paddr_d (current_gdbarch->frame_red_zone_size));
-#ifdef GET_LONGJMP_TARGET_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "GET_LONGJMP_TARGET_P()",
- XSTRING (GET_LONGJMP_TARGET_P ()));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_get_longjmp_target_p() = %d\n",
gdbarch_get_longjmp_target_p (current_gdbarch));
-#ifdef GET_LONGJMP_TARGET
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "GET_LONGJMP_TARGET(pc)",
- XSTRING (GET_LONGJMP_TARGET (pc)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: get_longjmp_target = <0x%lx>\n",
(long) current_gdbarch->get_longjmp_target);
-#ifdef HAVE_NONSTEPPABLE_WATCHPOINT
- fprintf_unfiltered (file,
- "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
- XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: have_nonsteppable_watchpoint = %s\n",
paddr_d (current_gdbarch->have_nonsteppable_watchpoint));
fprintf_unfiltered (file,
"gdbarch_dump: in_function_epilogue_p = <0x%lx>\n",
(long) current_gdbarch->in_function_epilogue_p);
-#ifdef IN_SOLIB_RETURN_TRAMPOLINE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
- XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: in_solib_return_trampoline = <0x%lx>\n",
(long) current_gdbarch->in_solib_return_trampoline);
-#ifdef INNER_THAN
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "INNER_THAN(lhs, rhs)",
- XSTRING (INNER_THAN (lhs, rhs)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: inner_than = <0x%lx>\n",
(long) current_gdbarch->inner_than);
-#ifdef TARGET_INT_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_INT_BIT # %s\n",
- XSTRING (TARGET_INT_BIT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: int_bit = %s\n",
paddr_d (current_gdbarch->int_bit));
fprintf_unfiltered (file,
"gdbarch_dump: integer_to_address = <0x%lx>\n",
(long) current_gdbarch->integer_to_address);
-#ifdef TARGET_LONG_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_LONG_BIT # %s\n",
- XSTRING (TARGET_LONG_BIT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: long_bit = %s\n",
paddr_d (current_gdbarch->long_bit));
-#ifdef TARGET_LONG_DOUBLE_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
- XSTRING (TARGET_LONG_DOUBLE_BIT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: long_double_bit = %s\n",
paddr_d (current_gdbarch->long_double_bit));
-#ifdef TARGET_LONG_DOUBLE_FORMAT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
- XSTRING (TARGET_LONG_DOUBLE_FORMAT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: long_double_format = %s\n",
pformat (current_gdbarch->long_double_format));
-#ifdef TARGET_LONG_LONG_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
- XSTRING (TARGET_LONG_LONG_BIT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: long_long_bit = %s\n",
paddr_d (current_gdbarch->long_long_bit));
-#ifdef MEMORY_INSERT_BREAKPOINT
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "MEMORY_INSERT_BREAKPOINT(bp_tgt)",
- XSTRING (MEMORY_INSERT_BREAKPOINT (bp_tgt)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: memory_insert_breakpoint = <0x%lx>\n",
(long) current_gdbarch->memory_insert_breakpoint);
-#ifdef MEMORY_REMOVE_BREAKPOINT
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "MEMORY_REMOVE_BREAKPOINT(bp_tgt)",
- XSTRING (MEMORY_REMOVE_BREAKPOINT (bp_tgt)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: memory_remove_breakpoint = <0x%lx>\n",
(long) current_gdbarch->memory_remove_breakpoint);
-#ifdef NAME_OF_MALLOC
- fprintf_unfiltered (file,
- "gdbarch_dump: NAME_OF_MALLOC # %s\n",
- XSTRING (NAME_OF_MALLOC));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: name_of_malloc = %s\n",
- NAME_OF_MALLOC);
-#ifdef NUM_PSEUDO_REGS
- fprintf_unfiltered (file,
- "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
- XSTRING (NUM_PSEUDO_REGS));
-#endif
+ current_gdbarch->name_of_malloc);
fprintf_unfiltered (file,
"gdbarch_dump: num_pseudo_regs = %s\n",
paddr_d (current_gdbarch->num_pseudo_regs));
-#ifdef NUM_REGS
- fprintf_unfiltered (file,
- "gdbarch_dump: NUM_REGS # %s\n",
- XSTRING (NUM_REGS));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: num_regs = %s\n",
paddr_d (current_gdbarch->num_regs));
fprintf_unfiltered (file,
"gdbarch_dump: overlay_update = <0x%lx>\n",
(long) current_gdbarch->overlay_update);
-#ifdef PC_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: PC_REGNUM # %s\n",
- XSTRING (PC_REGNUM));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: pc_regnum = %s\n",
paddr_d (current_gdbarch->pc_regnum));
-#ifdef POINTER_TO_ADDRESS
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "POINTER_TO_ADDRESS(type, buf)",
- XSTRING (POINTER_TO_ADDRESS (type, buf)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: pointer_to_address = <0x%lx>\n",
(long) current_gdbarch->pointer_to_address);
fprintf_unfiltered (file,
"gdbarch_dump: print_float_info = <0x%lx>\n",
(long) current_gdbarch->print_float_info);
-#ifdef TARGET_PRINT_INSN
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "TARGET_PRINT_INSN(vma, info)",
- XSTRING (TARGET_PRINT_INSN (vma, info)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: print_insn = <0x%lx>\n",
(long) current_gdbarch->print_insn);
fprintf_unfiltered (file,
"gdbarch_dump: print_vector_info = <0x%lx>\n",
(long) current_gdbarch->print_vector_info);
-#ifdef PS_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: PS_REGNUM # %s\n",
- XSTRING (PS_REGNUM));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: ps_regnum = %s\n",
paddr_d (current_gdbarch->ps_regnum));
fprintf_unfiltered (file,
"gdbarch_dump: pseudo_register_write = <0x%lx>\n",
(long) current_gdbarch->pseudo_register_write);
-#ifdef TARGET_PTR_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_PTR_BIT # %s\n",
- XSTRING (TARGET_PTR_BIT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: ptr_bit = %s\n",
paddr_d (current_gdbarch->ptr_bit));
fprintf_unfiltered (file,
"gdbarch_dump: push_dummy_code = <0x%lx>\n",
(long) current_gdbarch->push_dummy_code);
-#ifdef TARGET_READ_PC_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "TARGET_READ_PC_P()",
- XSTRING (TARGET_READ_PC_P ()));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_read_pc_p() = %d\n",
gdbarch_read_pc_p (current_gdbarch));
-#ifdef TARGET_READ_PC
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "TARGET_READ_PC(ptid)",
- XSTRING (TARGET_READ_PC (ptid)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: read_pc = <0x%lx>\n",
(long) current_gdbarch->read_pc);
-#ifdef REGISTER_BYTES_OK_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_BYTES_OK_P()",
- XSTRING (REGISTER_BYTES_OK_P ()));
-#endif
- fprintf_unfiltered (file,
- "gdbarch_dump: gdbarch_register_bytes_ok_p() = %d\n",
- gdbarch_register_bytes_ok_p (current_gdbarch));
-#ifdef REGISTER_BYTES_OK
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_BYTES_OK(nr_bytes)",
- XSTRING (REGISTER_BYTES_OK (nr_bytes)));
-#endif
- fprintf_unfiltered (file,
- "gdbarch_dump: register_bytes_ok = <0x%lx>\n",
- (long) current_gdbarch->register_bytes_ok);
-#ifdef REGISTER_NAME
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_NAME(regnr)",
- XSTRING (REGISTER_NAME (regnr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: register_name = <0x%lx>\n",
(long) current_gdbarch->register_name);
fprintf_unfiltered (file,
"gdbarch_dump: register_reggroup_p = <0x%lx>\n",
(long) current_gdbarch->register_reggroup_p);
-#ifdef REGISTER_SIM_REGNO
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_SIM_REGNO(reg_nr)",
- XSTRING (REGISTER_SIM_REGNO (reg_nr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: register_sim_regno = <0x%lx>\n",
(long) current_gdbarch->register_sim_regno);
-#ifdef REGISTER_TO_VALUE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "REGISTER_TO_VALUE(frame, regnum, type, buf)",
- XSTRING (REGISTER_TO_VALUE (frame, regnum, type, buf)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: register_to_value = <0x%lx>\n",
(long) current_gdbarch->register_to_value);
fprintf_unfiltered (file,
"gdbarch_dump: return_value = <0x%lx>\n",
(long) current_gdbarch->return_value);
-#ifdef SDB_REG_TO_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "SDB_REG_TO_REGNUM(sdb_regnr)",
- XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: sdb_reg_to_regnum = <0x%lx>\n",
(long) current_gdbarch->sdb_reg_to_regnum);
-#ifdef TARGET_SHORT_BIT
- fprintf_unfiltered (file,
- "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
- XSTRING (TARGET_SHORT_BIT));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: short_bit = %s\n",
paddr_d (current_gdbarch->short_bit));
fprintf_unfiltered (file,
"gdbarch_dump: skip_permanent_breakpoint = <0x%lx>\n",
(long) current_gdbarch->skip_permanent_breakpoint);
-#ifdef SKIP_PROLOGUE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "SKIP_PROLOGUE(ip)",
- XSTRING (SKIP_PROLOGUE (ip)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: skip_prologue = <0x%lx>\n",
(long) current_gdbarch->skip_prologue);
fprintf_unfiltered (file,
"gdbarch_dump: skip_solib_resolver = <0x%lx>\n",
(long) current_gdbarch->skip_solib_resolver);
-#ifdef SKIP_TRAMPOLINE_CODE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "SKIP_TRAMPOLINE_CODE(pc)",
- XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: skip_trampoline_code = <0x%lx>\n",
(long) current_gdbarch->skip_trampoline_code);
-#ifdef SMASH_TEXT_ADDRESS
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "SMASH_TEXT_ADDRESS(addr)",
- XSTRING (SMASH_TEXT_ADDRESS (addr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: smash_text_address = <0x%lx>\n",
(long) current_gdbarch->smash_text_address);
-#ifdef SOFTWARE_SINGLE_STEP_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "SOFTWARE_SINGLE_STEP_P()",
- XSTRING (SOFTWARE_SINGLE_STEP_P ()));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: gdbarch_software_single_step_p() = %d\n",
gdbarch_software_single_step_p (current_gdbarch));
-#ifdef SOFTWARE_SINGLE_STEP
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "SOFTWARE_SINGLE_STEP(regcache)",
- XSTRING (SOFTWARE_SINGLE_STEP (regcache)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: software_single_step = <0x%lx>\n",
(long) current_gdbarch->software_single_step);
-#ifdef SP_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: SP_REGNUM # %s\n",
- XSTRING (SP_REGNUM));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: sp_regnum = %s\n",
paddr_d (current_gdbarch->sp_regnum));
-#ifdef STAB_REG_TO_REGNUM
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "STAB_REG_TO_REGNUM(stab_regnr)",
- XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: stab_reg_to_regnum = <0x%lx>\n",
(long) current_gdbarch->stab_reg_to_regnum);
fprintf_unfiltered (file,
"gdbarch_dump: stabs_argument_has_addr = <0x%lx>\n",
(long) current_gdbarch->stabs_argument_has_addr);
-#ifdef STORE_RETURN_VALUE
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "STORE_RETURN_VALUE(type, regcache, valbuf)",
- XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: store_return_value = <0x%lx>\n",
(long) current_gdbarch->store_return_value);
fprintf_unfiltered (file,
"gdbarch_dump: value_from_register = <0x%lx>\n",
(long) current_gdbarch->value_from_register);
-#ifdef VALUE_TO_REGISTER
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "VALUE_TO_REGISTER(frame, regnum, type, buf)",
- XSTRING (VALUE_TO_REGISTER (frame, regnum, type, buf)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: value_to_register = <0x%lx>\n",
(long) current_gdbarch->value_to_register);
fprintf_unfiltered (file,
"gdbarch_dump: vbit_in_delta = %s\n",
paddr_d (current_gdbarch->vbit_in_delta));
-#ifdef TARGET_VIRTUAL_FRAME_POINTER
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
- XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
-#endif
fprintf_unfiltered (file,
"gdbarch_dump: virtual_frame_pointer = <0x%lx>\n",
(long) current_gdbarch->virtual_frame_pointer);
fprintf_unfiltered (file,
"gdbarch_dump: vtable_function_descriptors = %s\n",
paddr_d (current_gdbarch->vtable_function_descriptors));
-#ifdef TARGET_WRITE_PC
fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "TARGET_WRITE_PC(val, ptid)",
- XSTRING (TARGET_WRITE_PC (val, ptid)));
-#endif
+ "gdbarch_dump: gdbarch_write_pc_p() = %d\n",
+ gdbarch_write_pc_p (current_gdbarch));
fprintf_unfiltered (file,
"gdbarch_dump: write_pc = <0x%lx>\n",
(long) current_gdbarch->write_pc);
gdbarch->addr_bit = addr_bit;
}
-int
-gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- /* Skip verify of bfd_vma_bit, invalid_p == 0 */
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
- return gdbarch->bfd_vma_bit;
-}
-
-void
-set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
- int bfd_vma_bit)
-{
- gdbarch->bfd_vma_bit = bfd_vma_bit;
-}
-
int
gdbarch_char_signed (struct gdbarch *gdbarch)
{
}
CORE_ADDR
-gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
+gdbarch_read_pc (struct gdbarch *gdbarch, struct regcache *regcache)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->read_pc != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
- return gdbarch->read_pc (ptid);
+ return gdbarch->read_pc (regcache);
}
void
gdbarch->read_pc = read_pc;
}
+int
+gdbarch_write_pc_p (struct gdbarch *gdbarch)
+{
+ gdb_assert (gdbarch != NULL);
+ return gdbarch->write_pc != NULL;
+}
+
void
-gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
+gdbarch_write_pc (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->write_pc != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
- gdbarch->write_pc (val, ptid);
+ gdbarch->write_pc (regcache, val);
}
void
gdbarch->push_dummy_call = push_dummy_call;
}
-int
-gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
- return gdbarch->deprecated_register_size;
-}
-
-void
-set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
- int deprecated_register_size)
-{
- gdbarch->deprecated_register_size = deprecated_register_size;
-}
-
int
gdbarch_call_dummy_location (struct gdbarch *gdbarch)
{
}
CORE_ADDR
-gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+gdbarch_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->push_dummy_code != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_code called\n");
- return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr);
+ return gdbarch->push_dummy_code (gdbarch, sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr, regcache);
}
void
gdbarch->register_sim_regno = register_sim_regno;
}
-int
-gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- return gdbarch->register_bytes_ok != NULL;
-}
-
-int
-gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
-{
- gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->register_bytes_ok != NULL);
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
- return gdbarch->register_bytes_ok (nr_bytes);
-}
-
-void
-set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
- gdbarch_register_bytes_ok_ftype register_bytes_ok)
-{
- gdbarch->register_bytes_ok = register_bytes_ok;
-}
-
int
gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
{
}
int
-gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
+gdbarch_get_longjmp_target (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR *pc)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->get_longjmp_target != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
- return gdbarch->get_longjmp_target (pc);
+ return gdbarch->get_longjmp_target (frame, pc);
}
void
gdbarch->deprecated_use_struct_convention = deprecated_use_struct_convention;
}
-int
-gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- return gdbarch->deprecated_extract_struct_value_address != NULL;
-}
-
-CORE_ADDR
-gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
-{
- gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->deprecated_extract_struct_value_address != NULL);
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
- return gdbarch->deprecated_extract_struct_value_address (regcache);
-}
-
-void
-set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
- gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
-{
- gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
-}
-
CORE_ADDR
gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
{
gdbarch->frame_num_args = frame_num_args;
}
-int
-gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
-{
- gdb_assert (gdbarch != NULL);
- return gdbarch->deprecated_stack_align != NULL;
-}
-
-CORE_ADDR
-gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
-{
- gdb_assert (gdbarch != NULL);
- gdb_assert (gdbarch->deprecated_stack_align != NULL);
- if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
- return gdbarch->deprecated_stack_align (sp);
-}
-
-void
-set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
- gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
-{
- gdbarch->deprecated_stack_align = deprecated_stack_align;
-}
-
int
gdbarch_frame_align_p (struct gdbarch *gdbarch)
{
}
int
-gdbarch_software_single_step (struct gdbarch *gdbarch, struct regcache *regcache)
+gdbarch_software_single_step (struct gdbarch *gdbarch, struct frame_info *frame)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->software_single_step != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
- return gdbarch->software_single_step (regcache);
+ return gdbarch->software_single_step (frame);
}
void
}
CORE_ADDR
-gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
+gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc)
{
gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->skip_trampoline_code != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
- return gdbarch->skip_trampoline_code (pc);
+ return gdbarch->skip_trampoline_code (frame, pc);
}
void
}
-
-/* Keep a registry of swapped data required by GDB modules. */
-
-struct gdbarch_swap
-{
- void *swap;
- struct gdbarch_swap_registration *source;
- struct gdbarch_swap *next;
-};
-
-struct gdbarch_swap_registration
-{
- void *data;
- unsigned long sizeof_data;
- gdbarch_swap_ftype *init;
- struct gdbarch_swap_registration *next;
-};
-
-struct gdbarch_swap_registry
-{
- int nr;
- struct gdbarch_swap_registration *registrations;
-};
-
-struct gdbarch_swap_registry gdbarch_swap_registry =
-{
- 0, NULL,
-};
-
-void
-deprecated_register_gdbarch_swap (void *data,
- unsigned long sizeof_data,
- gdbarch_swap_ftype *init)
-{
- struct gdbarch_swap_registration **rego;
- for (rego = &gdbarch_swap_registry.registrations;
- (*rego) != NULL;
- rego = &(*rego)->next);
- (*rego) = XMALLOC (struct gdbarch_swap_registration);
- (*rego)->next = NULL;
- (*rego)->init = init;
- (*rego)->data = data;
- (*rego)->sizeof_data = sizeof_data;
-}
-
-static void
-current_gdbarch_swap_init_hack (void)
-{
- struct gdbarch_swap_registration *rego;
- struct gdbarch_swap **curr = ¤t_gdbarch->swap;
- for (rego = gdbarch_swap_registry.registrations;
- rego != NULL;
- rego = rego->next)
- {
- if (rego->data != NULL)
- {
- (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
- struct gdbarch_swap);
- (*curr)->source = rego;
- (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
- rego->sizeof_data);
- (*curr)->next = NULL;
- curr = &(*curr)->next;
- }
- if (rego->init != NULL)
- rego->init ();
- }
-}
-
-static struct gdbarch *
-current_gdbarch_swap_out_hack (void)
-{
- struct gdbarch *old_gdbarch = current_gdbarch;
- struct gdbarch_swap *curr;
-
- gdb_assert (old_gdbarch != NULL);
- for (curr = old_gdbarch->swap;
- curr != NULL;
- curr = curr->next)
- {
- memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
- memset (curr->source->data, 0, curr->source->sizeof_data);
- }
- current_gdbarch = NULL;
- return old_gdbarch;
-}
-
-static void
-current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
-{
- struct gdbarch_swap *curr;
-
- gdb_assert (current_gdbarch == NULL);
- for (curr = new_gdbarch->swap;
- curr != NULL;
- curr = curr->next)
- memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
- current_gdbarch = new_gdbarch;
-}
-
-
/* Keep a registry of the architectures known by GDB. */
struct gdbarch_registration
verify_gdbarch (new_gdbarch);
new_gdbarch->initialized_p = 1;
- /* Initialize any per-architecture swap areas. This phase requires
- a valid global CURRENT_GDBARCH. Set it momentarially, and then
- swap the entire architecture out. */
- current_gdbarch = new_gdbarch;
- current_gdbarch_swap_init_hack ();
- current_gdbarch_swap_out_hack ();
-
if (gdbarch_debug)
gdbarch_dump (new_gdbarch, gdb_stdlog);
struct gdbarch *
gdbarch_find_by_info (struct gdbarch_info info)
{
+ struct gdbarch *new_gdbarch;
+
/* Save the previously selected architecture, setting the global to
NULL. This stops things like gdbarch->init() trying to use the
previous architecture's configuration. The previous architecture
may not even be of the same architecture family. The most recent
architecture of the same family is found at the head of the
rego->arches list. */
- struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
+ struct gdbarch *old_gdbarch = current_gdbarch;
+ current_gdbarch = NULL;
/* Find the specified architecture. */
- struct gdbarch *new_gdbarch = find_arch_by_info (info);
+ new_gdbarch = find_arch_by_info (info);
/* Restore the existing architecture. */
gdb_assert (current_gdbarch == NULL);
- current_gdbarch_swap_in_hack (old_gdbarch);
+ current_gdbarch = old_gdbarch;
return new_gdbarch;
}
-/* Make the specified architecture current, swapping the existing one
- out. */
+/* Make the specified architecture current. */
void
deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
gdb_assert (new_gdbarch != NULL);
gdb_assert (current_gdbarch != NULL);
gdb_assert (new_gdbarch->initialized_p);
- current_gdbarch_swap_out_hack ();
- current_gdbarch_swap_in_hack (new_gdbarch);
+ current_gdbarch = new_gdbarch;
architecture_changed_event ();
reinit_frame_cache ();
}