#include "target-descriptions.h"
#include "floatformat.h"
#include "target-float.h"
+#include "elf-bfd.h"
+#include "elf/m68k.h"
#include "m68k-tdep.h"
\f
%d0/%d1 instead of in memory by using -freg-struct-return. This is
the default on NetBSD a.out, OpenBSD and GNU/Linux and several
embedded systems. This convention is implemented by setting the
- struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
+ struct_return member of `struct gdbarch_tdep' to reg_struct_return.
+
+ GCC also has an "embedded" ABI. This works like the SVR4 ABI,
+ except that pointers are returned in %D0. This is implemented by
+ setting the pointer_result_regnum member of `struct gdbarch_tdep'
+ as appropriate. */
/* Read a function return value of TYPE from REGCACHE, and copy that
into VALBUF. */
int len = TYPE_LENGTH (type);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
- if (len <= 4)
+ if (type->code () == TYPE_CODE_PTR && len == 4)
+ {
+ struct gdbarch *gdbarch = regcache->arch ();
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ regcache->raw_read (tdep->pointer_result_regnum, valbuf);
+ }
+ else if (len <= 4)
{
regcache->raw_read (M68K_D0_REGNUM, buf);
memcpy (valbuf, buf + (4 - len), len);
regcache->raw_read (M68K_FP0_REGNUM, buf);
target_float_convert (buf, fpreg_type, valbuf, type);
}
- else if (type->code () == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
- regcache->raw_read (M68K_A0_REGNUM, valbuf);
else
m68k_extract_return_value (type, regcache, valbuf);
}
{
int len = TYPE_LENGTH (type);
- if (len <= 4)
+ if (type->code () == TYPE_CODE_PTR && len == 4)
+ {
+ struct gdbarch *gdbarch = regcache->arch ();
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ regcache->raw_write (tdep->pointer_result_regnum, valbuf);
+ /* gdb historically also set D0 in the SVR4 case. */
+ if (tdep->pointer_result_regnum != M68K_D0_REGNUM)
+ regcache->raw_write (M68K_D0_REGNUM, valbuf);
+ }
+ else if (len <= 4)
regcache->raw_write_part (M68K_D0_REGNUM, 4 - len, len, valbuf);
else if (len <= 8)
{
target_float_convert (valbuf, type, buf, fpreg_type);
regcache->raw_write (M68K_FP0_REGNUM, buf);
}
- else if (type->code () == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
- {
- regcache->raw_write (M68K_A0_REGNUM, valbuf);
- regcache->raw_write (M68K_D0_REGNUM, valbuf);
- }
else
m68k_store_return_value (type, regcache, valbuf);
}
int len = TYPE_LENGTH (type);
gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
- || code == TYPE_CODE_COMPLEX);
+ || code == TYPE_CODE_COMPLEX || code == TYPE_CODE_ARRAY);
if (tdep->struct_return == pcc_struct_return)
return 0;
+ const bool is_vector = code == TYPE_CODE_ARRAY && type->is_vector ();
+
+ if (is_vector
+ && check_typedef (TYPE_TARGET_TYPE (type))->code () == TYPE_CODE_FLT)
+ return 0;
+
+ /* According to m68k_return_in_memory in the m68k GCC back-end,
+ strange things happen for small aggregate types. Aggregate types
+ with only one component are always returned like the type of the
+ component. Aggregate types whose size is 2, 4, or 8 are returned
+ in registers if their natural alignment is at least 16 bits.
+
+ We reject vectors here, as experimentally this gives the correct
+ answer. */
+ if (!is_vector && (len == 2 || len == 4 || len == 8))
+ return type_align (type) >= 2;
+
return (len == 1 || len == 2 || len == 4 || len == 8);
}
/* GCC returns a `long double' in memory too. */
if (((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
- || code == TYPE_CODE_COMPLEX)
+ || code == TYPE_CODE_COMPLEX || code == TYPE_CODE_ARRAY)
&& !m68k_reg_struct_return_p (gdbarch, type))
|| (code == TYPE_CODE_FLT && TYPE_LENGTH (type) == 12))
{
{
enum type_code code = type->code ();
- if ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
- || code == TYPE_CODE_COMPLEX)
- && !m68k_reg_struct_return_p (gdbarch, type))
+ /* Aggregates with a single member are always returned like their
+ sole element. */
+ if ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
+ && type->num_fields () == 1)
+ {
+ type = check_typedef (type->field (0).type ());
+ return m68k_svr4_return_value (gdbarch, function, type, regcache,
+ readbuf, writebuf);
+ }
+
+ if (((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
+ || code == TYPE_CODE_COMPLEX || code == TYPE_CODE_ARRAY)
+ && !m68k_reg_struct_return_p (gdbarch, type))
+ /* GCC may return a `long double' in memory too. */
+ || (!gdbarch_tdep (gdbarch)->float_return
+ && code == TYPE_CODE_FLT
+ && TYPE_LENGTH (type) == 12))
{
/* The System V ABI says that:
register %a0."
So the ABI guarantees that we can always find the return
- value just after the function has returned. */
+ value just after the function has returned.
+
+ However, GCC also implements the "embedded" ABI. That ABI
+ does not preserve %a0 across calls, but does write the value
+ back to %d0. */
if (readbuf)
{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
ULONGEST addr;
- regcache_raw_read_unsigned (regcache, M68K_A0_REGNUM, &addr);
+ regcache_raw_read_unsigned (regcache, tdep->pointer_result_regnum,
+ &addr);
read_memory (addr, readbuf, TYPE_LENGTH (type));
}
return RETURN_VALUE_ABI_RETURNS_ADDRESS;
}
- /* This special case is for structures consisting of a single
- `float' or `double' member. These structures are returned in
- %fp0. For these structures, we call ourselves recursively,
- changing TYPE into the type of the first member of the structure.
- Since that should work for all structures that have only one
- member, we don't bother to check the member's type here. */
- if (code == TYPE_CODE_STRUCT && type->num_fields () == 1)
- {
- type = check_typedef (type->field (0).type ());
- return m68k_svr4_return_value (gdbarch, function, type, regcache,
- readbuf, writebuf);
- }
-
if (readbuf)
m68k_svr4_extract_return_value (type, regcache, readbuf);
if (writebuf)
/* SVR4 uses %a0 instead of %a1. */
tdep->struct_value_regnum = M68K_A0_REGNUM;
+
+ /* SVR4 returns pointers in %a0. */
+ tdep->pointer_result_regnum = M68K_A0_REGNUM;
+}
+
+/* GCC's m68k "embedded" ABI. This is like the SVR4 ABI, but pointer
+ values are returned in %d0, not %a0. */
+
+static void
+m68k_embedded_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+
+ m68k_svr4_init_abi (info, gdbarch);
+ tdep->pointer_result_regnum = M68K_D0_REGNUM;
}
+
\f
/* Function: m68k_gdbarch_init
flavour = m68k_coldfire_flavour;
}
+ /* Try to figure out if the arch uses floating registers to return
+ floating point values from functions. On ColdFire, floating
+ point values are returned in D0. */
+ int float_return = 0;
+ if (has_fp && flavour != m68k_coldfire_flavour)
+ float_return = 1;
+#ifdef HAVE_ELF
+ if (info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
+ {
+ int fp_abi = bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
+ Tag_GNU_M68K_ABI_FP);
+ if (fp_abi == 1)
+ float_return = 1;
+ else if (fp_abi == 2)
+ float_return = 0;
+ }
+#endif /* HAVE_ELF */
+
/* If there is already a candidate, use it. */
for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
best_arch != NULL;
if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
continue;
+ if (float_return != gdbarch_tdep (best_arch->gdbarch)->float_return)
+ continue;
+
break;
}
tdep = XCNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
tdep->fpregs_present = has_fp;
+ tdep->float_return = float_return;
tdep->flavour = flavour;
if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
if (has_fp)
set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
- /* Try to figure out if the arch uses floating registers to return
- floating point values from functions. */
- if (has_fp)
- {
- /* On ColdFire, floating point values are returned in D0. */
- if (flavour == m68k_coldfire_flavour)
- tdep->float_return = 0;
- else
- tdep->float_return = 1;
- }
- else
- {
- /* No floating registers, so can't use them for returning values. */
- tdep->float_return = 0;
- }
-
/* Function call & return. */
set_gdbarch_push_dummy_call (gdbarch, m68k_push_dummy_call);
set_gdbarch_return_value (gdbarch, m68k_return_value);
#else
tdep->jb_pc = -1;
#endif
+ tdep->pointer_result_regnum = M68K_D0_REGNUM;
tdep->struct_value_regnum = M68K_A1_REGNUM;
tdep->struct_return = reg_struct_return;
return;
}
+/* OSABI sniffer for m68k. */
+
+static enum gdb_osabi
+m68k_osabi_sniffer (bfd *abfd)
+{
+ unsigned int elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
+
+ if (elfosabi == ELFOSABI_NONE)
+ return GDB_OSABI_SVR4;
+
+ return GDB_OSABI_UNKNOWN;
+}
+
void _initialize_m68k_tdep ();
void
_initialize_m68k_tdep ()
{
gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
+
+ gdbarch_register_osabi_sniffer (bfd_arch_m68k, bfd_target_elf_flavour,
+ m68k_osabi_sniffer);
+ gdbarch_register_osabi (bfd_arch_m68k, 0, GDB_OSABI_SVR4,
+ m68k_embedded_init_abi);
}
projects / binutils-gdb.git / commitdiff