int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
|| TYPE_CODE (valtype) == TYPE_CODE_UNION
|| TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
- && DEPRECATED_USE_STRUCT_CONVENTION (0, valtype));
+ && gdbarch_deprecated_use_struct_convention
+ (current_gdbarch, 0, valtype));
if (writebuf != NULL)
{
gdb_assert (!struct_return);
/* NOTE: cagney/2004-06-13: See stack.c:return_command. Old
- architectures don't expect STORE_RETURN_VALUE to handle small
+ architectures don't expect store_return_value to handle small
structures. Should not be called with such types. */
gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_STRUCT
&& TYPE_CODE (valtype) != TYPE_CODE_UNION);
- STORE_RETURN_VALUE (valtype, regcache, writebuf);
+ gdbarch_store_return_value (current_gdbarch, valtype, regcache, writebuf);
}
if (readbuf != NULL)
{
gdb_assert (!struct_return);
- EXTRACT_RETURN_VALUE (valtype, regcache, readbuf);
+ gdbarch_extract_return_value (current_gdbarch,
+ valtype, regcache, readbuf);
}
if (struct_return)
legacy_register_sim_regno (int regnum)
{
/* Only makes sense to supply raw registers. */
- gdb_assert (regnum >= 0 && regnum < NUM_REGS);
+ gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch));
/* NOTE: cagney/2002-05-13: The old code did it this way and it is
suspected that some GDB/SIM combinations may rely on this
behavour. The default should be one2one_register_sim_regno
(below). */
- if (REGISTER_NAME (regnum) != NULL
- && REGISTER_NAME (regnum)[0] != '\0')
+ if (gdbarch_register_name (current_gdbarch, regnum) != NULL
+ && gdbarch_register_name (current_gdbarch, regnum)[0] != '\0')
return regnum;
else
return LEGACY_SIM_REGNO_IGNORE;
}
CORE_ADDR
-generic_skip_trampoline_code (CORE_ADDR pc)
+generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
return 0;
}
return 0;
}
-void
-generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
- struct regcache *regcache,
- CORE_ADDR gdb_addr, int gdb_len,
- CORE_ADDR * rem_addr, int *rem_len)
-{
- *rem_addr = gdb_addr;
- *rem_len = gdb_len;
-}
-
-/* Helper functions for INNER_THAN */
+/* Helper functions for gdbarch_inner_than */
int
core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
return (lhs > rhs);
}
-
-/* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
-
-const struct floatformat *
-default_float_format (struct gdbarch *gdbarch)
-{
- int byte_order = gdbarch_byte_order (gdbarch);
- switch (byte_order)
- {
- case BFD_ENDIAN_BIG:
- return &floatformat_ieee_single_big;
- case BFD_ENDIAN_LITTLE:
- return &floatformat_ieee_single_little;
- default:
- internal_error (__FILE__, __LINE__,
- _("default_float_format: bad byte order"));
- }
-}
-
-
-const struct floatformat *
-default_double_format (struct gdbarch *gdbarch)
-{
- int byte_order = gdbarch_byte_order (gdbarch);
- switch (byte_order)
- {
- case BFD_ENDIAN_BIG:
- return &floatformat_ieee_double_big;
- case BFD_ENDIAN_LITTLE:
- return &floatformat_ieee_double_little;
- default:
- internal_error (__FILE__, __LINE__,
- _("default_double_format: bad byte order"));
- }
-}
-
/* Misc helper functions for targets. */
CORE_ADDR
}
/* Legacy version of target_virtual_frame_pointer(). Assumes that
- there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
+ there is an gdbarch_deprecated_fp_regnum and that it is the same, cooked or
raw. */
void
register and an offset can determine this. I think it should
instead generate a byte code expression as that would work better
with things like Dwarf2's CFI. */
- if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
- *frame_regnum = DEPRECATED_FP_REGNUM;
- else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
- *frame_regnum = SP_REGNUM;
+ if (gdbarch_deprecated_fp_regnum (current_gdbarch) >= 0
+ && gdbarch_deprecated_fp_regnum (current_gdbarch)
+ < gdbarch_num_regs (current_gdbarch))
+ *frame_regnum = gdbarch_deprecated_fp_regnum (current_gdbarch);
+ else if (gdbarch_sp_regnum (current_gdbarch) >= 0
+ && gdbarch_sp_regnum (current_gdbarch)
+ < gdbarch_num_regs (current_gdbarch))
+ *frame_regnum = gdbarch_sp_regnum (current_gdbarch);
else
/* Should this be an internal error? I guess so, it is reflecting
an architectural limitation in the current design. */
*frame_offset = 0;
}
-/* Assume the world is sane, every register's virtual and real size
- is identical. */
-
-int
-generic_register_size (int regnum)
-{
- gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
- return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
-}
-
-/* Assume all registers are adjacent. */
-
-int
-generic_register_byte (int regnum)
-{
- int byte;
- int i;
- gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
- byte = 0;
- for (i = 0; i < regnum; i++)
- {
- byte += generic_register_size (i);
- }
- return byte;
-}
-
\f
-int
-legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
-{
-#if defined (DEPRECATED_IN_SIGTRAMP)
- return DEPRECATED_IN_SIGTRAMP (pc, name);
-#else
- return name && strcmp ("_sigtramp", name) == 0;
-#endif
-}
-
int
generic_convert_register_p (int regnum, struct type *type)
{
return 0;
}
+int
+default_remote_register_number (struct gdbarch *gdbarch,
+ int regno)
+{
+ return regno;
+}
+
\f
/* Functions to manipulate the endianness of the target. */
};
static const char *set_endian_string;
+enum bfd_endian
+selected_byte_order (void)
+{
+ if (target_byte_order_user != BFD_ENDIAN_UNKNOWN)
+ return gdbarch_byte_order (current_gdbarch);
+ else
+ return BFD_ENDIAN_UNKNOWN;
+}
+
/* Called by ``show endian''. */
static void
const char *value)
{
if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
fprintf_unfiltered (file, _("The target endianness is set automatically "
"(currently big endian)\n"));
else
fprintf_unfiltered (file, _("The target endianness is set automatically "
"(currently little endian)\n"));
else
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
fprintf_unfiltered (file,
_("The target is assumed to be big endian\n"));
else
struct cmd_list_element *c, const char *value)
{
const char *arch;
- arch = TARGET_ARCHITECTURE->printable_name;
+ arch = gdbarch_bfd_arch_info (current_gdbarch)->printable_name;
if (target_architecture_user == NULL)
fprintf_filtered (file, _("\
The target architecture is set automatically (currently %s)\n"), arch);