* ColdFire/fido support
@ 2007-05-05 9:37 Vladimir Prus
2007-05-05 11:02 ` Andreas Schwab
0 siblings, 1 reply; 19+ messages in thread
From: Vladimir Prus @ 2007-05-05 9:37 UTC (permalink / raw)
To: gdb-patches
[-- Attachment #1: Type: text/plain, Size: 424 bytes --]
This patch adds initial support for ColdFire and fido versions of m68k.
The primary difference is different format of floating point, and different
return convention for floating point values on coldfire. This patch also
adds support for XML description, which allows remote stub to
advertise presense of floating point registers in a clean way.
No change in behaviour for classic m68k-tdep.c is expected. OK?
- Volodya
[-- Attachment #2: 2.ChangeLog --]
[-- Type: text/plain, Size: 1064 bytes --]
* m68k-tdep.h (struct gdbarch_tdep): New fields
float_return, fpreg_type, coldire, fido and
fpregs_present.
* m68k-tdep.c (m68k_register_type): Use
fpregs_present and fpreg_type.
(m68k_register_names): New.
(m68k_register_name): Use the above.
(m68k_convert_register_p): Consult fpregs_present.
(m68k_register_to_value, m68k_value_to_register):
Use register_type to obtain the type of floating
point registers.
(m68k_svr4_extract_return_value): Check tdep->float_return.
Use register_type to get the type of floating
point regiters.
(m68k_svr4_store_return_value): Likewise.
(m68k_dwarf_reg_to_regnum): Check tdep->fpregs_present.
(m68k_analyze_register_saves): Likewise.
(m68k_gdbarch_init): Extract infromation
from XML description, if present. Guess coldfire by
looking at the file, if present. Conditionalize
setting of long double format. Set decr_pc_after_break
to 2 on coldfire and fido. Enable XML-driven
register description.
* m68kbsd-tdep.c (m68kbsd_fpreg_offset): Use
size of tdep->fpreg_type, as opposed to hardcoded value.
[-- Attachment #3: 2.diff --]
[-- Type: text/x-diff, Size: 13455 bytes --]
--- gdb/m68k-tdep.c (/patches/gdb/coldfire_1) (revision 4079)
+++ gdb/m68k-tdep.c (/patches/gdb/coldfire_2) (revision 4079)
@@ -36,6 +36,7 @@
#include "arch-utils.h"
#include "osabi.h"
#include "dis-asm.h"
+#include "target-descriptions.h"
#include "m68k-tdep.h"
\f
@@ -80,15 +81,25 @@ m68k_local_breakpoint_from_pc (CORE_ADDR
static struct type *
m68k_register_type (struct gdbarch *gdbarch, int regnum)
{
- if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
- return builtin_type_m68881_ext;
+ if (gdbarch_tdep (gdbarch)->fpregs_present)
+ {
+ if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
+ return *gdbarch_tdep (gdbarch)->fpreg_type;
- if (regnum == M68K_FPI_REGNUM || regnum == PC_REGNUM)
- return builtin_type_void_func_ptr;
+ if (regnum == M68K_FPI_REGNUM)
+ return builtin_type_void_func_ptr;
+
+ if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM)
+ return builtin_type_int32;
+ }
+ else
+ {
+ if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM)
+ return builtin_type_int0;
+ }
- if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM
- || regnum == PS_REGNUM)
- return builtin_type_int32;
+ if (regnum == PC_REGNUM)
+ return builtin_type_void_func_ptr;
if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
return builtin_type_void_data_ptr;
@@ -96,25 +107,25 @@ m68k_register_type (struct gdbarch *gdba
return builtin_type_int32;
}
-/* Function: m68k_register_name
- Returns the name of the standard m68k register regnum. */
-
-static const char *
-m68k_register_name (int regnum)
-{
- static char *register_names[] = {
+static const char *m68k_register_names[] = {
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
"ps", "pc",
"fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
- "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
+ "fpcontrol", "fpstatus", "fpiaddr"
};
- if (regnum < 0 || regnum >= ARRAY_SIZE (register_names))
+/* Function: m68k_register_name
+ Returns the name of the standard m68k register regnum. */
+
+static const char *
+m68k_register_name (int regnum)
+{
+ if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names))
internal_error (__FILE__, __LINE__,
_("m68k_register_name: illegal register number %d"), regnum);
else
- return register_names[regnum];
+ return m68k_register_names[regnum];
}
\f
/* Return nonzero if a value of type TYPE stored in register REGNUM
@@ -123,6 +134,8 @@ m68k_register_name (int regnum)
static int
m68k_convert_register_p (int regnum, struct type *type)
{
+ if (!gdbarch_tdep (current_gdbarch)->fpregs_present)
+ return 0;
return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7);
}
@@ -134,6 +147,7 @@ m68k_register_to_value (struct frame_inf
struct type *type, gdb_byte *to)
{
gdb_byte from[M68K_MAX_REGISTER_SIZE];
+ struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM);
/* We only support floating-point values. */
if (TYPE_CODE (type) != TYPE_CODE_FLT)
@@ -146,7 +160,7 @@ m68k_register_to_value (struct frame_inf
/* Convert to TYPE. This should be a no-op if TYPE is equivalent to
the extended floating-point format used by the FPU. */
get_frame_register (frame, regnum, from);
- convert_typed_floating (from, builtin_type_m68881_ext, to, type);
+ convert_typed_floating (from, fpreg_type, to, type);
}
/* Write the contents FROM of a value of type TYPE into register
@@ -157,6 +171,7 @@ m68k_value_to_register (struct frame_inf
struct type *type, const gdb_byte *from)
{
gdb_byte to[M68K_MAX_REGISTER_SIZE];
+ struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM);
/* We only support floating-point values. */
if (TYPE_CODE (type) != TYPE_CODE_FLT)
@@ -168,7 +183,7 @@ m68k_value_to_register (struct frame_inf
/* Convert from TYPE. This should be a no-op if TYPE is equivalent
to the extended floating-point format used by the FPU. */
- convert_typed_floating (from, type, to, builtin_type_m68881_ext);
+ convert_typed_floating (from, type, to, fpreg_type);
put_frame_register (frame, regnum, to);
}
@@ -234,11 +249,14 @@ m68k_svr4_extract_return_value (struct t
{
int len = TYPE_LENGTH (type);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
{
+ struct type *fpreg_type = register_type
+ (current_gdbarch, M68K_FP0_REGNUM);
regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
- convert_typed_floating (buf, builtin_type_m68881_ext, valbuf, type);
+ convert_typed_floating (buf, fpreg_type, valbuf, type);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
@@ -272,11 +290,14 @@ m68k_svr4_store_return_value (struct typ
const gdb_byte *valbuf)
{
int len = TYPE_LENGTH (type);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
{
+ struct type *fpreg_type = register_type
+ (current_gdbarch, M68K_FP0_REGNUM);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
- convert_typed_floating (valbuf, type, buf, builtin_type_m68881_ext);
+ convert_typed_floating (valbuf, type, buf, fpreg_type);
regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
@@ -477,7 +498,7 @@ m68k_dwarf_reg_to_regnum (int num)
else if (num < 16)
/* a0..7 */
return (num - 8) + M68K_A0_REGNUM;
- else if (num < 24)
+ else if (num < 24 && gdbarch_tdep (current_gdbarch)->fpregs_present)
/* fp0..7 */
return (num - 16) + M68K_FP0_REGNUM;
else if (num == 25)
@@ -645,7 +666,8 @@ m68k_analyze_register_saves (CORE_ADDR p
while (pc < current_pc)
{
op = read_memory_unsigned_integer (pc, 2);
- if (op == P_FMOVEMX_SP)
+ if (op == P_FMOVEMX_SP
+ && gdbarch_tdep (current_gdbarch)->fpregs_present)
{
/* fmovem.x REGS,-(%sp) */
op = read_memory_unsigned_integer (pc + 2, 2);
@@ -1136,17 +1158,118 @@ m68k_gdbarch_init (struct gdbarch_info i
{
struct gdbarch_tdep *tdep = NULL;
struct gdbarch *gdbarch;
+ struct gdbarch_list *best_arch;
+ struct tdesc_arch_data *tdesc_data = NULL;
+ int i;
+ int coldfire = 0;
+ int fido = 0;
+ int has_fp = 1;
+ const struct floatformat **long_double_format = floatformats_m68881_ext;
+
+ /* Check any target description for validity. */
+ if (tdesc_has_registers (info.target_desc))
+ {
+ const struct tdesc_feature *feature;
+ int valid_p;
+
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.m68k.core");
+ if (feature != NULL)
+ /* Do nothing. */
+ ;
+
+ if (feature == NULL)
+ {
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.coldfire.core");
+ if (feature != NULL)
+ coldfire = 1;
+ }
+
+ if (feature == NULL)
+ {
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.fido.core");
+ if (feature != NULL)
+ fido = 1;
+ }
+
+ if (feature == NULL)
+ return NULL;
+
+ tdesc_data = tdesc_data_alloc ();
- /* find a candidate among the list of pre-declared architectures. */
- arches = gdbarch_list_lookup_by_info (arches, &info);
- if (arches != NULL)
- return (arches->gdbarch);
+ valid_p = 1;
+ for (i = 0; i <= M68K_PC_REGNUM; i++)
+ valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
+ m68k_register_names[i]);
+
+ if (!valid_p)
+ {
+ tdesc_data_cleanup (tdesc_data);
+ return NULL;
+ }
+
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.coldfire.fp");
+ if (feature != NULL)
+ {
+ valid_p = 1;
+ for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++)
+ valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
+ m68k_register_names[i]);
+ if (!valid_p)
+ {
+ tdesc_data_cleanup (tdesc_data);
+ return NULL;
+ }
+ }
+ else
+ has_fp = 0;
+ }
+
+ /* The mechanism for returning floating values from function
+ and the type of long double depend on whether we're
+ on ColdFire or standard m68k. */
+
+ if (info.bfd_arch_info)
+ {
+ const bfd_arch_info_type *coldfire_arch =
+ bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
+
+ if (coldfire_arch
+ && (*info.bfd_arch_info->compatible)
+ (info.bfd_arch_info, coldfire_arch))
+ coldfire = 1;
+ }
+
+ /* If there is already a candidate, use it. */
+ for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
+ best_arch != NULL;
+ best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
+ {
+ if (coldfire != gdbarch_tdep (best_arch->gdbarch)->coldfire)
+ continue;
+
+ if (fido != gdbarch_tdep (best_arch->gdbarch)->fido)
+ continue;
+
+ if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
+ continue;
+
+ break;
+ }
tdep = xmalloc (sizeof (struct gdbarch_tdep));
gdbarch = gdbarch_alloc (&info, tdep);
-
- set_gdbarch_long_double_format (gdbarch, floatformats_m68881_ext);
- set_gdbarch_long_double_bit (gdbarch, 96);
+ tdep->fpregs_present = has_fp;
+ tdep->coldfire = coldfire;
+ tdep->fido = fido;
+
+ if (coldfire || fido)
+ long_double_format = floatformats_ieee_double;
+ set_gdbarch_long_double_format (gdbarch, long_double_format);
+ set_gdbarch_long_double_bit (gdbarch, long_double_format[0]->totalsize);
set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
@@ -1156,6 +1279,8 @@ m68k_gdbarch_init (struct gdbarch_info i
set_gdbarch_frame_align (gdbarch, m68k_frame_align);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
+ if (coldfire || fido)
+ set_gdbarch_decr_pc_after_break (gdbarch, 2);
set_gdbarch_frame_args_skip (gdbarch, 8);
set_gdbarch_dwarf_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
@@ -1172,9 +1297,35 @@ m68k_gdbarch_init (struct gdbarch_info i
set_gdbarch_register_to_value (gdbarch, m68k_register_to_value);
set_gdbarch_value_to_register (gdbarch, m68k_value_to_register);
+ if (has_fp)
+ set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
+
+ if (coldfire)
+ tdep->fpreg_type = &builtin_type_double;
+ else
+ tdep->fpreg_type = &builtin_type_m68881_ext;
+
+ /* 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 (coldfire)
+ 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);
+
/* Disassembler. */
set_gdbarch_print_insn (gdbarch, print_insn_m68k);
@@ -1207,6 +1358,9 @@ m68k_gdbarch_init (struct gdbarch_info i
frame_unwind_append_sniffer (gdbarch, m68k_frame_sniffer);
+ if (tdesc_data)
+ tdesc_use_registers (gdbarch, tdesc_data);
+
return gdbarch;
}
--- gdb/m68k-tdep.h (/patches/gdb/coldfire_1) (revision 4079)
+++ gdb/m68k-tdep.h (/patches/gdb/coldfire_2) (revision 4079)
@@ -76,6 +76,27 @@ struct gdbarch_tdep
/* Convention for returning structures. */
enum struct_return struct_return;
+
+ /* Convention for returning floats. zero in int regs, non-zero in float. */
+ int float_return;
+
+ /* Type of an fpreg. NULL if there are no fpregs. This is a
+ pointer to the pointer to type struct, because when architecture
+ init function is running, the types for the old architecture are swapped
+ out, and the types for the new architecture are not yet swapped in,
+ so all types that don't have specific sizes (like builting_type_double)
+ are NULL. */
+ struct type **fpreg_type;
+
+ /* Is this ColdFire architecture, as opposed to generic m68k? */
+ int coldfire;
+
+ /* Is this fido architecture, as opposed to generic m68k? */
+ int fido;
+
+ /* Flag set if the floating point registers are present, or assumed
+ to be present. */
+ int fpregs_present;
};
/* Initialize a SVR4 architecture variant. */
--- gdb/m68kbsd-tdep.c (/patches/gdb/coldfire_1) (revision 4079)
+++ gdb/m68kbsd-tdep.c (/patches/gdb/coldfire_2) (revision 4079)
@@ -45,10 +45,12 @@
int
m68kbsd_fpreg_offset (int regnum)
{
+ int fp_len = TYPE_LENGTH (*gdbarch_tdep (current_gdbarch)->fpreg_type);
+
if (regnum >= M68K_FPC_REGNUM)
- return 8 * 12 + (regnum - M68K_FPC_REGNUM) * 4;
+ return 8 * fp_len + (regnum - M68K_FPC_REGNUM) * 4;
- return (regnum - M68K_FP0_REGNUM) * 12;
+ return (regnum - M68K_FP0_REGNUM) * fp_len;
}
/* Supply register REGNUM from the buffer specified by FPREGS and LEN
Property changes on:
___________________________________________________________________
Name: svk:merge
+d48a11ec-ee1c-0410-b3f5-c20844f99675:/patches/gdb/coldfire_submission:4065
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-05-05 9:37 ColdFire/fido support Vladimir Prus
@ 2007-05-05 11:02 ` Andreas Schwab
2007-05-06 11:52 ` Vladimir Prus
0 siblings, 1 reply; 19+ messages in thread
From: Andreas Schwab @ 2007-05-05 11:02 UTC (permalink / raw)
To: Vladimir Prus; +Cc: gdb-patches
Vladimir Prus <vladimir@codesourcery.com> writes:
> + /* Is this ColdFire architecture, as opposed to generic m68k? */
> + int coldfire;
> +
> + /* Is this fido architecture, as opposed to generic m68k? */
> + int fido;
How about making this a single enum? They surely can never both be
non-zero at the same time.
Andreas.
--
Andreas Schwab, SuSE Labs, schwab@suse.de
SuSE Linux Products GmbH, Maxfeldstraße 5, 90409 Nürnberg, Germany
PGP key fingerprint = 58CA 54C7 6D53 942B 1756 01D3 44D5 214B 8276 4ED5
"And now for something completely different."
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-05-05 11:02 ` Andreas Schwab
@ 2007-05-06 11:52 ` Vladimir Prus
2007-05-28 11:43 ` Vladimir Prus
0 siblings, 1 reply; 19+ messages in thread
From: Vladimir Prus @ 2007-05-06 11:52 UTC (permalink / raw)
To: Andreas Schwab; +Cc: gdb-patches
[-- Attachment #1: Type: text/plain, Size: 451 bytes --]
On Saturday 05 May 2007 15:02, Andreas Schwab wrote:
> Vladimir Prus <vladimir@codesourcery.com> writes:
>
> > + /* Is this ColdFire architecture, as opposed to generic m68k? */
> > + int coldfire;
> > +
> > + /* Is this fido architecture, as opposed to generic m68k? */
> > + int fido;
>
> How about making this a single enum? They surely can never both be
> non-zero at the same time.
Good idea. Here's a revised patch.
Thanks,
Volodya
[-- Attachment #2: 2.diff --]
[-- Type: text/x-diff, Size: 13793 bytes --]
--- gdb/m68k-tdep.c (/patches/gdb/coldfire_1) (revision 4123)
+++ gdb/m68k-tdep.c (/patches/gdb/coldfire_2) (revision 4123)
@@ -36,6 +36,7 @@
#include "arch-utils.h"
#include "osabi.h"
#include "dis-asm.h"
+#include "target-descriptions.h"
#include "m68k-tdep.h"
\f
@@ -80,15 +81,25 @@ m68k_local_breakpoint_from_pc (CORE_ADDR
static struct type *
m68k_register_type (struct gdbarch *gdbarch, int regnum)
{
- if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
- return builtin_type_m68881_ext;
+ if (gdbarch_tdep (gdbarch)->fpregs_present)
+ {
+ if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
+ return *gdbarch_tdep (gdbarch)->fpreg_type;
- if (regnum == M68K_FPI_REGNUM || regnum == PC_REGNUM)
- return builtin_type_void_func_ptr;
+ if (regnum == M68K_FPI_REGNUM)
+ return builtin_type_void_func_ptr;
+
+ if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM)
+ return builtin_type_int32;
+ }
+ else
+ {
+ if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM)
+ return builtin_type_int0;
+ }
- if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM
- || regnum == PS_REGNUM)
- return builtin_type_int32;
+ if (regnum == PC_REGNUM)
+ return builtin_type_void_func_ptr;
if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
return builtin_type_void_data_ptr;
@@ -96,25 +107,25 @@ m68k_register_type (struct gdbarch *gdba
return builtin_type_int32;
}
-/* Function: m68k_register_name
- Returns the name of the standard m68k register regnum. */
-
-static const char *
-m68k_register_name (int regnum)
-{
- static char *register_names[] = {
+static const char *m68k_register_names[] = {
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
"ps", "pc",
"fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
- "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
+ "fpcontrol", "fpstatus", "fpiaddr"
};
- if (regnum < 0 || regnum >= ARRAY_SIZE (register_names))
+/* Function: m68k_register_name
+ Returns the name of the standard m68k register regnum. */
+
+static const char *
+m68k_register_name (int regnum)
+{
+ if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names))
internal_error (__FILE__, __LINE__,
_("m68k_register_name: illegal register number %d"), regnum);
else
- return register_names[regnum];
+ return m68k_register_names[regnum];
}
\f
/* Return nonzero if a value of type TYPE stored in register REGNUM
@@ -123,6 +134,8 @@ m68k_register_name (int regnum)
static int
m68k_convert_register_p (int regnum, struct type *type)
{
+ if (!gdbarch_tdep (current_gdbarch)->fpregs_present)
+ return 0;
return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7);
}
@@ -134,6 +147,7 @@ m68k_register_to_value (struct frame_inf
struct type *type, gdb_byte *to)
{
gdb_byte from[M68K_MAX_REGISTER_SIZE];
+ struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM);
/* We only support floating-point values. */
if (TYPE_CODE (type) != TYPE_CODE_FLT)
@@ -146,7 +160,7 @@ m68k_register_to_value (struct frame_inf
/* Convert to TYPE. This should be a no-op if TYPE is equivalent to
the extended floating-point format used by the FPU. */
get_frame_register (frame, regnum, from);
- convert_typed_floating (from, builtin_type_m68881_ext, to, type);
+ convert_typed_floating (from, fpreg_type, to, type);
}
/* Write the contents FROM of a value of type TYPE into register
@@ -157,6 +171,7 @@ m68k_value_to_register (struct frame_inf
struct type *type, const gdb_byte *from)
{
gdb_byte to[M68K_MAX_REGISTER_SIZE];
+ struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM);
/* We only support floating-point values. */
if (TYPE_CODE (type) != TYPE_CODE_FLT)
@@ -168,7 +183,7 @@ m68k_value_to_register (struct frame_inf
/* Convert from TYPE. This should be a no-op if TYPE is equivalent
to the extended floating-point format used by the FPU. */
- convert_typed_floating (from, type, to, builtin_type_m68881_ext);
+ convert_typed_floating (from, type, to, fpreg_type);
put_frame_register (frame, regnum, to);
}
@@ -234,11 +249,14 @@ m68k_svr4_extract_return_value (struct t
{
int len = TYPE_LENGTH (type);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
{
+ struct type *fpreg_type = register_type
+ (current_gdbarch, M68K_FP0_REGNUM);
regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
- convert_typed_floating (buf, builtin_type_m68881_ext, valbuf, type);
+ convert_typed_floating (buf, fpreg_type, valbuf, type);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
@@ -272,11 +290,14 @@ m68k_svr4_store_return_value (struct typ
const gdb_byte *valbuf)
{
int len = TYPE_LENGTH (type);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
{
+ struct type *fpreg_type = register_type
+ (current_gdbarch, M68K_FP0_REGNUM);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
- convert_typed_floating (valbuf, type, buf, builtin_type_m68881_ext);
+ convert_typed_floating (valbuf, type, buf, fpreg_type);
regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
@@ -477,7 +498,7 @@ m68k_dwarf_reg_to_regnum (int num)
else if (num < 16)
/* a0..7 */
return (num - 8) + M68K_A0_REGNUM;
- else if (num < 24)
+ else if (num < 24 && gdbarch_tdep (current_gdbarch)->fpregs_present)
/* fp0..7 */
return (num - 16) + M68K_FP0_REGNUM;
else if (num == 25)
@@ -645,7 +666,8 @@ m68k_analyze_register_saves (CORE_ADDR p
while (pc < current_pc)
{
op = read_memory_unsigned_integer (pc, 2);
- if (op == P_FMOVEMX_SP)
+ if (op == P_FMOVEMX_SP
+ && gdbarch_tdep (current_gdbarch)->fpregs_present)
{
/* fmovem.x REGS,-(%sp) */
op = read_memory_unsigned_integer (pc + 2, 2);
@@ -1136,17 +1158,113 @@ m68k_gdbarch_init (struct gdbarch_info i
{
struct gdbarch_tdep *tdep = NULL;
struct gdbarch *gdbarch;
+ struct gdbarch_list *best_arch;
+ struct tdesc_arch_data *tdesc_data = NULL;
+ int i;
+ enum m68k_flavour flavour = m68k_no_flavour;
+ int has_fp = 1;
+ const struct floatformat **long_double_format = floatformats_m68881_ext;
+
+ /* Check any target description for validity. */
+ if (tdesc_has_registers (info.target_desc))
+ {
+ const struct tdesc_feature *feature;
+ int valid_p;
+
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.m68k.core");
+ if (feature != NULL)
+ /* Do nothing. */
+ ;
+
+ if (feature == NULL)
+ {
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.coldfire.core");
+ if (feature != NULL)
+ flavour = m68k_coldfire_flavour;
+ }
+
+ if (feature == NULL)
+ {
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.fido.core");
+ if (feature != NULL)
+ flavour = m68k_fido_flavour;
+ }
+
+ if (feature == NULL)
+ return NULL;
- /* find a candidate among the list of pre-declared architectures. */
- arches = gdbarch_list_lookup_by_info (arches, &info);
- if (arches != NULL)
- return (arches->gdbarch);
+ tdesc_data = tdesc_data_alloc ();
+
+ valid_p = 1;
+ for (i = 0; i <= M68K_PC_REGNUM; i++)
+ valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
+ m68k_register_names[i]);
+
+ if (!valid_p)
+ {
+ tdesc_data_cleanup (tdesc_data);
+ return NULL;
+ }
+
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.coldfire.fp");
+ if (feature != NULL)
+ {
+ valid_p = 1;
+ for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++)
+ valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
+ m68k_register_names[i]);
+ if (!valid_p)
+ {
+ tdesc_data_cleanup (tdesc_data);
+ return NULL;
+ }
+ }
+ else
+ has_fp = 0;
+ }
+
+ /* The mechanism for returning floating values from function
+ and the type of long double depend on whether we're
+ on ColdFire or standard m68k. */
+
+ if (info.bfd_arch_info)
+ {
+ const bfd_arch_info_type *coldfire_arch =
+ bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
+
+ if (coldfire_arch
+ && (*info.bfd_arch_info->compatible)
+ (info.bfd_arch_info, coldfire_arch))
+ flavour = m68k_coldfire_flavour;
+ }
+
+ /* If there is already a candidate, use it. */
+ for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
+ best_arch != NULL;
+ best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
+ {
+ if (flavour != gdbarch_tdep (best_arch->gdbarch)->flavour)
+ continue;
+
+ if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
+ continue;
+
+ break;
+ }
tdep = xmalloc (sizeof (struct gdbarch_tdep));
gdbarch = gdbarch_alloc (&info, tdep);
+ tdep->fpregs_present = has_fp;
+ tdep->flavour = flavour;
- set_gdbarch_long_double_format (gdbarch, floatformats_m68881_ext);
- set_gdbarch_long_double_bit (gdbarch, 96);
+ if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
+ long_double_format = floatformats_ieee_double;
+ set_gdbarch_long_double_format (gdbarch, long_double_format);
+ set_gdbarch_long_double_bit (gdbarch, long_double_format[0]->totalsize);
set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
@@ -1156,6 +1274,8 @@ m68k_gdbarch_init (struct gdbarch_info i
set_gdbarch_frame_align (gdbarch, m68k_frame_align);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
+ if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
+ set_gdbarch_decr_pc_after_break (gdbarch, 2);
set_gdbarch_frame_args_skip (gdbarch, 8);
set_gdbarch_dwarf_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
@@ -1172,9 +1292,35 @@ m68k_gdbarch_init (struct gdbarch_info i
set_gdbarch_register_to_value (gdbarch, m68k_register_to_value);
set_gdbarch_value_to_register (gdbarch, m68k_value_to_register);
+ if (has_fp)
+ set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
+
+ if (flavour == m68k_coldfire_flavour)
+ tdep->fpreg_type = &builtin_type_double;
+ else
+ tdep->fpreg_type = &builtin_type_m68881_ext;
+
+ /* 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);
+
/* Disassembler. */
set_gdbarch_print_insn (gdbarch, print_insn_m68k);
@@ -1207,6 +1353,9 @@ m68k_gdbarch_init (struct gdbarch_info i
frame_unwind_append_sniffer (gdbarch, m68k_frame_sniffer);
+ if (tdesc_data)
+ tdesc_use_registers (gdbarch, tdesc_data);
+
return gdbarch;
}
--- gdb/m68k-tdep.h (/patches/gdb/coldfire_1) (revision 4123)
+++ gdb/m68k-tdep.h (/patches/gdb/coldfire_2) (revision 4123)
@@ -60,6 +60,14 @@ enum struct_return
reg_struct_return /* Return "short" structures in registers. */
};
+/* Particular flavour of m68k. */
+enum m68k_flavour
+ {
+ m68k_no_flavour,
+ m68k_coldfire_flavour,
+ m68k_fido_flavour
+ };
+
/* Target-dependent structure in gdbarch. */
struct gdbarch_tdep
@@ -76,6 +84,24 @@ struct gdbarch_tdep
/* Convention for returning structures. */
enum struct_return struct_return;
+
+ /* Convention for returning floats. zero in int regs, non-zero in float. */
+ int float_return;
+
+ /* Type of an fpreg. NULL if there are no fpregs. This is a
+ pointer to the pointer to type struct, because when architecture
+ init function is running, the types for the old architecture are swapped
+ out, and the types for the new architecture are not yet swapped in,
+ so all types that don't have specific sizes (like builting_type_double)
+ are NULL. */
+ struct type **fpreg_type;
+
+ /* The particular flavour of m68k. */
+ enum m68k_flavour flavour;
+
+ /* Flag set if the floating point registers are present, or assumed
+ to be present. */
+ int fpregs_present;
};
/* Initialize a SVR4 architecture variant. */
--- gdb/m68kbsd-tdep.c (/patches/gdb/coldfire_1) (revision 4123)
+++ gdb/m68kbsd-tdep.c (/patches/gdb/coldfire_2) (revision 4123)
@@ -45,10 +45,12 @@
int
m68kbsd_fpreg_offset (int regnum)
{
+ int fp_len = TYPE_LENGTH (*gdbarch_tdep (current_gdbarch)->fpreg_type);
+
if (regnum >= M68K_FPC_REGNUM)
- return 8 * 12 + (regnum - M68K_FPC_REGNUM) * 4;
+ return 8 * fp_len + (regnum - M68K_FPC_REGNUM) * 4;
- return (regnum - M68K_FP0_REGNUM) * 12;
+ return (regnum - M68K_FP0_REGNUM) * fp_len;
}
/* Supply register REGNUM from the buffer specified by FPREGS and LEN
Property changes on:
___________________________________________________________________
Name: svk:merge
+d48a11ec-ee1c-0410-b3f5-c20844f99675:/patches/gdb/coldfire_submission:4065
[-- Attachment #3: 2.ChangeLog --]
[-- Type: text/plain, Size: 1086 bytes --]
* m68k-tdep.h (enum m68k_flavour): New.
(struct gdbarch_tdep): New fields
float_return, fpreg_type, flavour and
fpregs_present.
* m68k-tdep.c (m68k_register_type): Use
fpregs_present and fpreg_type.
(m68k_register_names): New.
(m68k_register_name): Use the above.
(m68k_convert_register_p): Consult fpregs_present.
(m68k_register_to_value, m68k_value_to_register):
Use register_type to obtain the type of floating
point registers.
(m68k_svr4_extract_return_value): Check tdep->float_return.
Use register_type to get the type of floating
point regiters.
(m68k_svr4_store_return_value): Likewise.
(m68k_dwarf_reg_to_regnum): Check tdep->fpregs_present.
(m68k_analyze_register_saves): Likewise.
(m68k_gdbarch_init): Extract infromation
from XML description, if present. Guess coldfire by
looking at the file, if present. Conditionalize
setting of long double format. Set decr_pc_after_break
to 2 on coldfire and fido. Enable XML-driven
register description.
* m68kbsd-tdep.c (m68kbsd_fpreg_offset): Use
size of tdep->fpreg_type, as opposed to hardcoded value.
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-05-06 11:52 ` Vladimir Prus
@ 2007-05-28 11:43 ` Vladimir Prus
2007-06-05 15:19 ` Daniel Jacobowitz
2007-06-30 15:47 ` Andreas Schwab
0 siblings, 2 replies; 19+ messages in thread
From: Vladimir Prus @ 2007-05-28 11:43 UTC (permalink / raw)
To: Andreas Schwab; +Cc: gdb-patches
[-- Attachment #1: Type: text/plain, Size: 580 bytes --]
On Sunday 06 May 2007 15:52, Vladimir Prus wrote:
> On Saturday 05 May 2007 15:02, Andreas Schwab wrote:
> > Vladimir Prus <vladimir@codesourcery.com> writes:
> >
> > > + /* Is this ColdFire architecture, as opposed to generic m68k? */
> > > + int coldfire;
> > > +
> > > + /* Is this fido architecture, as opposed to generic m68k? */
> > > + int fido;
> >
> > How about making this a single enum? They surely can never both be
> > non-zero at the same time.
>
> Good idea. Here's a revised patch.
Any comments? I attach the patch again for convenience.
- Volodya
[-- Attachment #2: 2.ChangeLog --]
[-- Type: text/plain, Size: 1086 bytes --]
* m68k-tdep.h (enum m68k_flavour): New.
(struct gdbarch_tdep): New fields
float_return, fpreg_type, flavour and
fpregs_present.
* m68k-tdep.c (m68k_register_type): Use
fpregs_present and fpreg_type.
(m68k_register_names): New.
(m68k_register_name): Use the above.
(m68k_convert_register_p): Consult fpregs_present.
(m68k_register_to_value, m68k_value_to_register):
Use register_type to obtain the type of floating
point registers.
(m68k_svr4_extract_return_value): Check tdep->float_return.
Use register_type to get the type of floating
point regiters.
(m68k_svr4_store_return_value): Likewise.
(m68k_dwarf_reg_to_regnum): Check tdep->fpregs_present.
(m68k_analyze_register_saves): Likewise.
(m68k_gdbarch_init): Extract infromation
from XML description, if present. Guess coldfire by
looking at the file, if present. Conditionalize
setting of long double format. Set decr_pc_after_break
to 2 on coldfire and fido. Enable XML-driven
register description.
* m68kbsd-tdep.c (m68kbsd_fpreg_offset): Use
size of tdep->fpreg_type, as opposed to hardcoded value.
[-- Attachment #3: 2.diff --]
[-- Type: text/x-diff, Size: 13793 bytes --]
--- gdb/m68k-tdep.c (/patches/gdb/coldfire_1) (revision 4123)
+++ gdb/m68k-tdep.c (/patches/gdb/coldfire_2) (revision 4123)
@@ -36,6 +36,7 @@
#include "arch-utils.h"
#include "osabi.h"
#include "dis-asm.h"
+#include "target-descriptions.h"
#include "m68k-tdep.h"
\f
@@ -80,15 +81,25 @@ m68k_local_breakpoint_from_pc (CORE_ADDR
static struct type *
m68k_register_type (struct gdbarch *gdbarch, int regnum)
{
- if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
- return builtin_type_m68881_ext;
+ if (gdbarch_tdep (gdbarch)->fpregs_present)
+ {
+ if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
+ return *gdbarch_tdep (gdbarch)->fpreg_type;
- if (regnum == M68K_FPI_REGNUM || regnum == PC_REGNUM)
- return builtin_type_void_func_ptr;
+ if (regnum == M68K_FPI_REGNUM)
+ return builtin_type_void_func_ptr;
+
+ if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM)
+ return builtin_type_int32;
+ }
+ else
+ {
+ if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM)
+ return builtin_type_int0;
+ }
- if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM
- || regnum == PS_REGNUM)
- return builtin_type_int32;
+ if (regnum == PC_REGNUM)
+ return builtin_type_void_func_ptr;
if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
return builtin_type_void_data_ptr;
@@ -96,25 +107,25 @@ m68k_register_type (struct gdbarch *gdba
return builtin_type_int32;
}
-/* Function: m68k_register_name
- Returns the name of the standard m68k register regnum. */
-
-static const char *
-m68k_register_name (int regnum)
-{
- static char *register_names[] = {
+static const char *m68k_register_names[] = {
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
"ps", "pc",
"fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
- "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
+ "fpcontrol", "fpstatus", "fpiaddr"
};
- if (regnum < 0 || regnum >= ARRAY_SIZE (register_names))
+/* Function: m68k_register_name
+ Returns the name of the standard m68k register regnum. */
+
+static const char *
+m68k_register_name (int regnum)
+{
+ if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names))
internal_error (__FILE__, __LINE__,
_("m68k_register_name: illegal register number %d"), regnum);
else
- return register_names[regnum];
+ return m68k_register_names[regnum];
}
\f
/* Return nonzero if a value of type TYPE stored in register REGNUM
@@ -123,6 +134,8 @@ m68k_register_name (int regnum)
static int
m68k_convert_register_p (int regnum, struct type *type)
{
+ if (!gdbarch_tdep (current_gdbarch)->fpregs_present)
+ return 0;
return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7);
}
@@ -134,6 +147,7 @@ m68k_register_to_value (struct frame_inf
struct type *type, gdb_byte *to)
{
gdb_byte from[M68K_MAX_REGISTER_SIZE];
+ struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM);
/* We only support floating-point values. */
if (TYPE_CODE (type) != TYPE_CODE_FLT)
@@ -146,7 +160,7 @@ m68k_register_to_value (struct frame_inf
/* Convert to TYPE. This should be a no-op if TYPE is equivalent to
the extended floating-point format used by the FPU. */
get_frame_register (frame, regnum, from);
- convert_typed_floating (from, builtin_type_m68881_ext, to, type);
+ convert_typed_floating (from, fpreg_type, to, type);
}
/* Write the contents FROM of a value of type TYPE into register
@@ -157,6 +171,7 @@ m68k_value_to_register (struct frame_inf
struct type *type, const gdb_byte *from)
{
gdb_byte to[M68K_MAX_REGISTER_SIZE];
+ struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM);
/* We only support floating-point values. */
if (TYPE_CODE (type) != TYPE_CODE_FLT)
@@ -168,7 +183,7 @@ m68k_value_to_register (struct frame_inf
/* Convert from TYPE. This should be a no-op if TYPE is equivalent
to the extended floating-point format used by the FPU. */
- convert_typed_floating (from, type, to, builtin_type_m68881_ext);
+ convert_typed_floating (from, type, to, fpreg_type);
put_frame_register (frame, regnum, to);
}
@@ -234,11 +249,14 @@ m68k_svr4_extract_return_value (struct t
{
int len = TYPE_LENGTH (type);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
{
+ struct type *fpreg_type = register_type
+ (current_gdbarch, M68K_FP0_REGNUM);
regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
- convert_typed_floating (buf, builtin_type_m68881_ext, valbuf, type);
+ convert_typed_floating (buf, fpreg_type, valbuf, type);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
@@ -272,11 +290,14 @@ m68k_svr4_store_return_value (struct typ
const gdb_byte *valbuf)
{
int len = TYPE_LENGTH (type);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
{
+ struct type *fpreg_type = register_type
+ (current_gdbarch, M68K_FP0_REGNUM);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
- convert_typed_floating (valbuf, type, buf, builtin_type_m68881_ext);
+ convert_typed_floating (valbuf, type, buf, fpreg_type);
regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
@@ -477,7 +498,7 @@ m68k_dwarf_reg_to_regnum (int num)
else if (num < 16)
/* a0..7 */
return (num - 8) + M68K_A0_REGNUM;
- else if (num < 24)
+ else if (num < 24 && gdbarch_tdep (current_gdbarch)->fpregs_present)
/* fp0..7 */
return (num - 16) + M68K_FP0_REGNUM;
else if (num == 25)
@@ -645,7 +666,8 @@ m68k_analyze_register_saves (CORE_ADDR p
while (pc < current_pc)
{
op = read_memory_unsigned_integer (pc, 2);
- if (op == P_FMOVEMX_SP)
+ if (op == P_FMOVEMX_SP
+ && gdbarch_tdep (current_gdbarch)->fpregs_present)
{
/* fmovem.x REGS,-(%sp) */
op = read_memory_unsigned_integer (pc + 2, 2);
@@ -1136,17 +1158,113 @@ m68k_gdbarch_init (struct gdbarch_info i
{
struct gdbarch_tdep *tdep = NULL;
struct gdbarch *gdbarch;
+ struct gdbarch_list *best_arch;
+ struct tdesc_arch_data *tdesc_data = NULL;
+ int i;
+ enum m68k_flavour flavour = m68k_no_flavour;
+ int has_fp = 1;
+ const struct floatformat **long_double_format = floatformats_m68881_ext;
+
+ /* Check any target description for validity. */
+ if (tdesc_has_registers (info.target_desc))
+ {
+ const struct tdesc_feature *feature;
+ int valid_p;
+
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.m68k.core");
+ if (feature != NULL)
+ /* Do nothing. */
+ ;
+
+ if (feature == NULL)
+ {
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.coldfire.core");
+ if (feature != NULL)
+ flavour = m68k_coldfire_flavour;
+ }
+
+ if (feature == NULL)
+ {
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.fido.core");
+ if (feature != NULL)
+ flavour = m68k_fido_flavour;
+ }
+
+ if (feature == NULL)
+ return NULL;
- /* find a candidate among the list of pre-declared architectures. */
- arches = gdbarch_list_lookup_by_info (arches, &info);
- if (arches != NULL)
- return (arches->gdbarch);
+ tdesc_data = tdesc_data_alloc ();
+
+ valid_p = 1;
+ for (i = 0; i <= M68K_PC_REGNUM; i++)
+ valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
+ m68k_register_names[i]);
+
+ if (!valid_p)
+ {
+ tdesc_data_cleanup (tdesc_data);
+ return NULL;
+ }
+
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.coldfire.fp");
+ if (feature != NULL)
+ {
+ valid_p = 1;
+ for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++)
+ valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
+ m68k_register_names[i]);
+ if (!valid_p)
+ {
+ tdesc_data_cleanup (tdesc_data);
+ return NULL;
+ }
+ }
+ else
+ has_fp = 0;
+ }
+
+ /* The mechanism for returning floating values from function
+ and the type of long double depend on whether we're
+ on ColdFire or standard m68k. */
+
+ if (info.bfd_arch_info)
+ {
+ const bfd_arch_info_type *coldfire_arch =
+ bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
+
+ if (coldfire_arch
+ && (*info.bfd_arch_info->compatible)
+ (info.bfd_arch_info, coldfire_arch))
+ flavour = m68k_coldfire_flavour;
+ }
+
+ /* If there is already a candidate, use it. */
+ for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
+ best_arch != NULL;
+ best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
+ {
+ if (flavour != gdbarch_tdep (best_arch->gdbarch)->flavour)
+ continue;
+
+ if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
+ continue;
+
+ break;
+ }
tdep = xmalloc (sizeof (struct gdbarch_tdep));
gdbarch = gdbarch_alloc (&info, tdep);
+ tdep->fpregs_present = has_fp;
+ tdep->flavour = flavour;
- set_gdbarch_long_double_format (gdbarch, floatformats_m68881_ext);
- set_gdbarch_long_double_bit (gdbarch, 96);
+ if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
+ long_double_format = floatformats_ieee_double;
+ set_gdbarch_long_double_format (gdbarch, long_double_format);
+ set_gdbarch_long_double_bit (gdbarch, long_double_format[0]->totalsize);
set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
@@ -1156,6 +1274,8 @@ m68k_gdbarch_init (struct gdbarch_info i
set_gdbarch_frame_align (gdbarch, m68k_frame_align);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
+ if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
+ set_gdbarch_decr_pc_after_break (gdbarch, 2);
set_gdbarch_frame_args_skip (gdbarch, 8);
set_gdbarch_dwarf_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
@@ -1172,9 +1292,35 @@ m68k_gdbarch_init (struct gdbarch_info i
set_gdbarch_register_to_value (gdbarch, m68k_register_to_value);
set_gdbarch_value_to_register (gdbarch, m68k_value_to_register);
+ if (has_fp)
+ set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
+
+ if (flavour == m68k_coldfire_flavour)
+ tdep->fpreg_type = &builtin_type_double;
+ else
+ tdep->fpreg_type = &builtin_type_m68881_ext;
+
+ /* 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);
+
/* Disassembler. */
set_gdbarch_print_insn (gdbarch, print_insn_m68k);
@@ -1207,6 +1353,9 @@ m68k_gdbarch_init (struct gdbarch_info i
frame_unwind_append_sniffer (gdbarch, m68k_frame_sniffer);
+ if (tdesc_data)
+ tdesc_use_registers (gdbarch, tdesc_data);
+
return gdbarch;
}
--- gdb/m68k-tdep.h (/patches/gdb/coldfire_1) (revision 4123)
+++ gdb/m68k-tdep.h (/patches/gdb/coldfire_2) (revision 4123)
@@ -60,6 +60,14 @@ enum struct_return
reg_struct_return /* Return "short" structures in registers. */
};
+/* Particular flavour of m68k. */
+enum m68k_flavour
+ {
+ m68k_no_flavour,
+ m68k_coldfire_flavour,
+ m68k_fido_flavour
+ };
+
/* Target-dependent structure in gdbarch. */
struct gdbarch_tdep
@@ -76,6 +84,24 @@ struct gdbarch_tdep
/* Convention for returning structures. */
enum struct_return struct_return;
+
+ /* Convention for returning floats. zero in int regs, non-zero in float. */
+ int float_return;
+
+ /* Type of an fpreg. NULL if there are no fpregs. This is a
+ pointer to the pointer to type struct, because when architecture
+ init function is running, the types for the old architecture are swapped
+ out, and the types for the new architecture are not yet swapped in,
+ so all types that don't have specific sizes (like builting_type_double)
+ are NULL. */
+ struct type **fpreg_type;
+
+ /* The particular flavour of m68k. */
+ enum m68k_flavour flavour;
+
+ /* Flag set if the floating point registers are present, or assumed
+ to be present. */
+ int fpregs_present;
};
/* Initialize a SVR4 architecture variant. */
--- gdb/m68kbsd-tdep.c (/patches/gdb/coldfire_1) (revision 4123)
+++ gdb/m68kbsd-tdep.c (/patches/gdb/coldfire_2) (revision 4123)
@@ -45,10 +45,12 @@
int
m68kbsd_fpreg_offset (int regnum)
{
+ int fp_len = TYPE_LENGTH (*gdbarch_tdep (current_gdbarch)->fpreg_type);
+
if (regnum >= M68K_FPC_REGNUM)
- return 8 * 12 + (regnum - M68K_FPC_REGNUM) * 4;
+ return 8 * fp_len + (regnum - M68K_FPC_REGNUM) * 4;
- return (regnum - M68K_FP0_REGNUM) * 12;
+ return (regnum - M68K_FP0_REGNUM) * fp_len;
}
/* Supply register REGNUM from the buffer specified by FPREGS and LEN
Property changes on:
___________________________________________________________________
Name: svk:merge
+d48a11ec-ee1c-0410-b3f5-c20844f99675:/patches/gdb/coldfire_submission:4065
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-05-28 11:43 ` Vladimir Prus
@ 2007-06-05 15:19 ` Daniel Jacobowitz
2007-06-08 10:58 ` Vladimir Prus
2007-06-30 15:47 ` Andreas Schwab
1 sibling, 1 reply; 19+ messages in thread
From: Daniel Jacobowitz @ 2007-06-05 15:19 UTC (permalink / raw)
To: Vladimir Prus; +Cc: Andreas Schwab, gdb-patches
On Mon, May 28, 2007 at 03:42:47PM +0400, Vladimir Prus wrote:
> On Sunday 06 May 2007 15:52, Vladimir Prus wrote:
> > On Saturday 05 May 2007 15:02, Andreas Schwab wrote:
> > > Vladimir Prus <vladimir@codesourcery.com> writes:
> > >
> > > > + /* Is this ColdFire architecture, as opposed to generic m68k? */
> > > > + int coldfire;
> > > > +
> > > > + /* Is this fido architecture, as opposed to generic m68k? */
> > > > + int fido;
> > >
> > > How about making this a single enum? They surely can never both be
> > > non-zero at the same time.
> >
> > Good idea. Here's a revised patch.
>
> Any comments? I attach the patch again for convenience.
This is mostly OK. Please add a Makefile.in update for the new
#include. Also, we've added XML support for another target. So it
needs a new section in the manual describing which targets support
XML registers, and which registers are required.
> + if (feature == NULL)
> + {
> + feature = tdesc_find_feature (info.target_desc,
> + "org.gnu.gdb.coldfire.core");
> + if (feature != NULL)
> + flavour = m68k_coldfire_flavour;
> + }
> + /* The mechanism for returning floating values from function
> + and the type of long double depend on whether we're
> + on ColdFire or standard m68k. */
> +
> + if (info.bfd_arch_info)
> + {
> + const bfd_arch_info_type *coldfire_arch =
> + bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
> +
> + if (coldfire_arch
> + && (*info.bfd_arch_info->compatible)
> + (info.bfd_arch_info, coldfire_arch))
> + flavour = m68k_coldfire_flavour;
> + }
This sets flavour partly based on the target, and partly based on the
object file. That's a bit confusing - we can determine float return
behavior strictly from the object file, and it's only the object
file's behavior that matters.
--
Daniel Jacobowitz
CodeSourcery
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-05 15:19 ` Daniel Jacobowitz
@ 2007-06-08 10:58 ` Vladimir Prus
2007-06-12 13:38 ` Daniel Jacobowitz
0 siblings, 1 reply; 19+ messages in thread
From: Vladimir Prus @ 2007-06-08 10:58 UTC (permalink / raw)
To: Daniel Jacobowitz; +Cc: Andreas Schwab, gdb-patches
On Tuesday 05 June 2007 19:18, Daniel Jacobowitz wrote:
> > + /* The mechanism for returning floating values from function
> > + and the type of long double depend on whether we're
> > + on ColdFire or standard m68k. */
> > +
> > + if (info.bfd_arch_info)
> > + {
> > + const bfd_arch_info_type *coldfire_arch =
> > + bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
> > +
> > + if (coldfire_arch
> > + && (*info.bfd_arch_info->compatible)
> > + (info.bfd_arch_info, coldfire_arch))
> > + flavour = m68k_coldfire_flavour;
> > + }
>
> This sets flavour partly based on the target, and partly based on the
> object file. That's a bit confusing - we can determine float return
> behavior strictly from the object file, and it's only the object
> file's behavior that matters.
Not necessary. You can connect to a stub without having a file at all,
and you'd still want to have some coldfire-specific behaviour, for example
this:
if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
set_gdbarch_decr_pc_after_break (gdbarch, 2);
if you determine flavour based solely on file, then if you connect to a stub
without having any file at all, no flavour will be detected, and breakpoints won't
work correctly.
I suppose I can add file-based detection for fido, just like it's done for coldfire,
but I don't think removing XML-based detection is right. What do you think?
- Volodya
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-08 10:58 ` Vladimir Prus
@ 2007-06-12 13:38 ` Daniel Jacobowitz
2007-06-15 10:17 ` Vladimir Prus
0 siblings, 1 reply; 19+ messages in thread
From: Daniel Jacobowitz @ 2007-06-12 13:38 UTC (permalink / raw)
To: Vladimir Prus; +Cc: Andreas Schwab, gdb-patches
On Fri, Jun 08, 2007 at 02:58:36PM +0400, Vladimir Prus wrote:
> > This sets flavour partly based on the target, and partly based on the
> > object file. That's a bit confusing - we can determine float return
> > behavior strictly from the object file, and it's only the object
> > file's behavior that matters.
>
> Not necessary. You can connect to a stub without having a file at all,
> and you'd still want to have some coldfire-specific behaviour, for example
> this:
>
> if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
> set_gdbarch_decr_pc_after_break (gdbarch, 2);
>
> if you determine flavour based solely on file, then if you connect to a stub
> without having any file at all, no flavour will be detected, and breakpoints won't
> work correctly.
>
> I suppose I can add file-based detection for fido, just like it's done for coldfire,
> but I don't think removing XML-based detection is right. What do you think?
Right, sorry - I know what I meant to say, but I didn't say it.
Float return behavior is not a property of the target at all; it's a
property of the compiler options used. decr_pc_after_break is a
target property, though, so we should trust the target. This isn't
important, though, so feel free to commit without changing this. If
it causes any problems we can clean it up later.
--
Daniel Jacobowitz
CodeSourcery
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-12 13:38 ` Daniel Jacobowitz
@ 2007-06-15 10:17 ` Vladimir Prus
2007-06-15 14:47 ` Daniel Jacobowitz
0 siblings, 1 reply; 19+ messages in thread
From: Vladimir Prus @ 2007-06-15 10:17 UTC (permalink / raw)
To: Daniel Jacobowitz; +Cc: Andreas Schwab, gdb-patches
[-- Attachment #1: Type: text/plain, Size: 743 bytes --]
On Tuesday 12 June 2007 17:38, Daniel Jacobowitz wrote:
> > I suppose I can add file-based detection for fido, just like it's done for coldfire,
> > but I don't think removing XML-based detection is right. What do you think?
>
> Right, sorry - I know what I meant to say, but I didn't say it.
>
> Float return behavior is not a property of the target at all; it's a
> property of the compiler options used. decr_pc_after_break is a
> target property, though, so we should trust the target. This isn't
> important, though, so feel free to commit without changing this. If
> it causes any problems we can clean it up later.
Ok, excellent.
I attach a patch that differs only by non-taking of address of builtin_types. OK?
- Volodya
[-- Attachment #2: 2.diff --]
[-- Type: text/x-diff, Size: 13936 bytes --]
--- gdb/m68k-tdep.c (/patches/gdb/coldfire_1) (revision 4302)
+++ gdb/m68k-tdep.c (/patches/gdb/coldfire_2) (revision 4302)
@@ -36,6 +36,7 @@
#include "arch-utils.h"
#include "osabi.h"
#include "dis-asm.h"
+#include "target-descriptions.h"
#include "m68k-tdep.h"
\f
@@ -80,15 +81,32 @@ m68k_local_breakpoint_from_pc (CORE_ADDR
static struct type *
m68k_register_type (struct gdbarch *gdbarch, int regnum)
{
- if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
- return builtin_type_m68881_ext;
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- if (regnum == M68K_FPI_REGNUM || regnum == PC_REGNUM)
- return builtin_type_void_func_ptr;
+ if (tdep->fpregs_present)
+ {
+ if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
+ {
+ if (tdep->flavour == m68k_coldfire_flavour)
+ return builtin_type (gdbarch)->builtin_double;
+ else
+ return builtin_type_m68881_ext;
+ }
- if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM
- || regnum == PS_REGNUM)
- return builtin_type_int32;
+ if (regnum == M68K_FPI_REGNUM)
+ return builtin_type_void_func_ptr;
+
+ if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM)
+ return builtin_type_int32;
+ }
+ else
+ {
+ if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM)
+ return builtin_type_int0;
+ }
+
+ if (regnum == PC_REGNUM)
+ return builtin_type_void_func_ptr;
if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
return builtin_type_void_data_ptr;
@@ -96,25 +114,25 @@ m68k_register_type (struct gdbarch *gdba
return builtin_type_int32;
}
-/* Function: m68k_register_name
- Returns the name of the standard m68k register regnum. */
-
-static const char *
-m68k_register_name (int regnum)
-{
- static char *register_names[] = {
+static const char *m68k_register_names[] = {
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
"ps", "pc",
"fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
- "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
+ "fpcontrol", "fpstatus", "fpiaddr"
};
- if (regnum < 0 || regnum >= ARRAY_SIZE (register_names))
+/* Function: m68k_register_name
+ Returns the name of the standard m68k register regnum. */
+
+static const char *
+m68k_register_name (int regnum)
+{
+ if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names))
internal_error (__FILE__, __LINE__,
_("m68k_register_name: illegal register number %d"), regnum);
else
- return register_names[regnum];
+ return m68k_register_names[regnum];
}
\f
/* Return nonzero if a value of type TYPE stored in register REGNUM
@@ -123,6 +141,8 @@ m68k_register_name (int regnum)
static int
m68k_convert_register_p (int regnum, struct type *type)
{
+ if (!gdbarch_tdep (current_gdbarch)->fpregs_present)
+ return 0;
return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7);
}
@@ -134,6 +154,7 @@ m68k_register_to_value (struct frame_inf
struct type *type, gdb_byte *to)
{
gdb_byte from[M68K_MAX_REGISTER_SIZE];
+ struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM);
/* We only support floating-point values. */
if (TYPE_CODE (type) != TYPE_CODE_FLT)
@@ -146,7 +167,7 @@ m68k_register_to_value (struct frame_inf
/* Convert to TYPE. This should be a no-op if TYPE is equivalent to
the extended floating-point format used by the FPU. */
get_frame_register (frame, regnum, from);
- convert_typed_floating (from, builtin_type_m68881_ext, to, type);
+ convert_typed_floating (from, fpreg_type, to, type);
}
/* Write the contents FROM of a value of type TYPE into register
@@ -157,6 +178,7 @@ m68k_value_to_register (struct frame_inf
struct type *type, const gdb_byte *from)
{
gdb_byte to[M68K_MAX_REGISTER_SIZE];
+ struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM);
/* We only support floating-point values. */
if (TYPE_CODE (type) != TYPE_CODE_FLT)
@@ -168,7 +190,7 @@ m68k_value_to_register (struct frame_inf
/* Convert from TYPE. This should be a no-op if TYPE is equivalent
to the extended floating-point format used by the FPU. */
- convert_typed_floating (from, type, to, builtin_type_m68881_ext);
+ convert_typed_floating (from, type, to, fpreg_type);
put_frame_register (frame, regnum, to);
}
@@ -234,11 +256,14 @@ m68k_svr4_extract_return_value (struct t
{
int len = TYPE_LENGTH (type);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
{
+ struct type *fpreg_type = register_type
+ (current_gdbarch, M68K_FP0_REGNUM);
regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
- convert_typed_floating (buf, builtin_type_m68881_ext, valbuf, type);
+ convert_typed_floating (buf, fpreg_type, valbuf, type);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
@@ -272,11 +297,14 @@ m68k_svr4_store_return_value (struct typ
const gdb_byte *valbuf)
{
int len = TYPE_LENGTH (type);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
{
+ struct type *fpreg_type = register_type
+ (current_gdbarch, M68K_FP0_REGNUM);
gdb_byte buf[M68K_MAX_REGISTER_SIZE];
- convert_typed_floating (valbuf, type, buf, builtin_type_m68881_ext);
+ convert_typed_floating (valbuf, type, buf, fpreg_type);
regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
@@ -477,7 +505,7 @@ m68k_dwarf_reg_to_regnum (int num)
else if (num < 16)
/* a0..7 */
return (num - 8) + M68K_A0_REGNUM;
- else if (num < 24)
+ else if (num < 24 && gdbarch_tdep (current_gdbarch)->fpregs_present)
/* fp0..7 */
return (num - 16) + M68K_FP0_REGNUM;
else if (num == 25)
@@ -646,7 +674,8 @@ m68k_analyze_register_saves (CORE_ADDR p
while (pc < current_pc)
{
op = read_memory_unsigned_integer (pc, 2);
- if (op == P_FMOVEMX_SP)
+ if (op == P_FMOVEMX_SP
+ && gdbarch_tdep (current_gdbarch)->fpregs_present)
{
/* fmovem.x REGS,-(%sp) */
op = read_memory_unsigned_integer (pc + 2, 2);
@@ -1004,17 +1033,113 @@ m68k_gdbarch_init (struct gdbarch_info i
{
struct gdbarch_tdep *tdep = NULL;
struct gdbarch *gdbarch;
+ struct gdbarch_list *best_arch;
+ struct tdesc_arch_data *tdesc_data = NULL;
+ int i;
+ enum m68k_flavour flavour = m68k_no_flavour;
+ int has_fp = 1;
+ const struct floatformat **long_double_format = floatformats_m68881_ext;
+
+ /* Check any target description for validity. */
+ if (tdesc_has_registers (info.target_desc))
+ {
+ const struct tdesc_feature *feature;
+ int valid_p;
+
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.m68k.core");
+ if (feature != NULL)
+ /* Do nothing. */
+ ;
- /* find a candidate among the list of pre-declared architectures. */
- arches = gdbarch_list_lookup_by_info (arches, &info);
- if (arches != NULL)
- return (arches->gdbarch);
+ if (feature == NULL)
+ {
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.coldfire.core");
+ if (feature != NULL)
+ flavour = m68k_coldfire_flavour;
+ }
+
+ if (feature == NULL)
+ {
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.fido.core");
+ if (feature != NULL)
+ flavour = m68k_fido_flavour;
+ }
+
+ if (feature == NULL)
+ return NULL;
+
+ tdesc_data = tdesc_data_alloc ();
+
+ valid_p = 1;
+ for (i = 0; i <= M68K_PC_REGNUM; i++)
+ valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
+ m68k_register_names[i]);
+
+ if (!valid_p)
+ {
+ tdesc_data_cleanup (tdesc_data);
+ return NULL;
+ }
+
+ feature = tdesc_find_feature (info.target_desc,
+ "org.gnu.gdb.coldfire.fp");
+ if (feature != NULL)
+ {
+ valid_p = 1;
+ for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++)
+ valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
+ m68k_register_names[i]);
+ if (!valid_p)
+ {
+ tdesc_data_cleanup (tdesc_data);
+ return NULL;
+ }
+ }
+ else
+ has_fp = 0;
+ }
+
+ /* The mechanism for returning floating values from function
+ and the type of long double depend on whether we're
+ on ColdFire or standard m68k. */
+
+ if (info.bfd_arch_info)
+ {
+ const bfd_arch_info_type *coldfire_arch =
+ bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
+
+ if (coldfire_arch
+ && (*info.bfd_arch_info->compatible)
+ (info.bfd_arch_info, coldfire_arch))
+ flavour = m68k_coldfire_flavour;
+ }
+
+ /* If there is already a candidate, use it. */
+ for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
+ best_arch != NULL;
+ best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
+ {
+ if (flavour != gdbarch_tdep (best_arch->gdbarch)->flavour)
+ continue;
+
+ if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
+ continue;
+
+ break;
+ }
tdep = xmalloc (sizeof (struct gdbarch_tdep));
gdbarch = gdbarch_alloc (&info, tdep);
+ tdep->fpregs_present = has_fp;
+ tdep->flavour = flavour;
- set_gdbarch_long_double_format (gdbarch, floatformats_m68881_ext);
- set_gdbarch_long_double_bit (gdbarch, 96);
+ if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
+ long_double_format = floatformats_ieee_double;
+ set_gdbarch_long_double_format (gdbarch, long_double_format);
+ set_gdbarch_long_double_bit (gdbarch, long_double_format[0]->totalsize);
set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
@@ -1024,6 +1149,8 @@ m68k_gdbarch_init (struct gdbarch_info i
set_gdbarch_frame_align (gdbarch, m68k_frame_align);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
+ if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
+ set_gdbarch_decr_pc_after_break (gdbarch, 2);
set_gdbarch_frame_args_skip (gdbarch, 8);
set_gdbarch_dwarf_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
@@ -1040,9 +1167,30 @@ m68k_gdbarch_init (struct gdbarch_info i
set_gdbarch_register_to_value (gdbarch, m68k_register_to_value);
set_gdbarch_value_to_register (gdbarch, m68k_value_to_register);
+ 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);
+
/* Disassembler. */
set_gdbarch_print_insn (gdbarch, print_insn_m68k);
@@ -1075,6 +1223,9 @@ m68k_gdbarch_init (struct gdbarch_info i
frame_unwind_append_sniffer (gdbarch, m68k_frame_sniffer);
+ if (tdesc_data)
+ tdesc_use_registers (gdbarch, tdesc_data);
+
return gdbarch;
}
--- gdb/m68k-tdep.h (/patches/gdb/coldfire_1) (revision 4302)
+++ gdb/m68k-tdep.h (/patches/gdb/coldfire_2) (revision 4302)
@@ -60,6 +60,14 @@ enum struct_return
reg_struct_return /* Return "short" structures in registers. */
};
+/* Particular flavour of m68k. */
+enum m68k_flavour
+ {
+ m68k_no_flavour,
+ m68k_coldfire_flavour,
+ m68k_fido_flavour
+ };
+
/* Target-dependent structure in gdbarch. */
struct gdbarch_tdep
@@ -76,6 +84,24 @@ struct gdbarch_tdep
/* Convention for returning structures. */
enum struct_return struct_return;
+
+ /* Convention for returning floats. zero in int regs, non-zero in float. */
+ int float_return;
+
+ /* Type of an fpreg. NULL if there are no fpregs. This is a
+ pointer to the pointer to type struct, because when architecture
+ init function is running, the types for the old architecture are swapped
+ out, and the types for the new architecture are not yet swapped in,
+ so all types that don't have specific sizes (like builting_type_double)
+ are NULL. */
+ struct type **fpreg_type;
+
+ /* The particular flavour of m68k. */
+ enum m68k_flavour flavour;
+
+ /* Flag set if the floating point registers are present, or assumed
+ to be present. */
+ int fpregs_present;
};
/* Initialize a SVR4 architecture variant. */
--- gdb/m68kbsd-tdep.c (/patches/gdb/coldfire_1) (revision 4302)
+++ gdb/m68kbsd-tdep.c (/patches/gdb/coldfire_2) (revision 4302)
@@ -45,10 +45,12 @@
int
m68kbsd_fpreg_offset (int regnum)
{
+ int fp_len = TYPE_LENGTH (*gdbarch_tdep (current_gdbarch)->fpreg_type);
+
if (regnum >= M68K_FPC_REGNUM)
- return 8 * 12 + (regnum - M68K_FPC_REGNUM) * 4;
+ return 8 * fp_len + (regnum - M68K_FPC_REGNUM) * 4;
- return (regnum - M68K_FP0_REGNUM) * 12;
+ return (regnum - M68K_FP0_REGNUM) * fp_len;
}
/* Supply register REGNUM from the buffer specified by FPREGS and LEN
Property changes on:
___________________________________________________________________
Name: svk:merge
+d48a11ec-ee1c-0410-b3f5-c20844f99675:/patches/gdb/coldfire_1:4294
+d48a11ec-ee1c-0410-b3f5-c20844f99675:/patches/gdb/coldfire_submission:4065
e7755896-6108-0410-9592-8049d3e74e28:/mirrors/gdb/trunk:173448
[-- Attachment #3: 2.ChangeLog --]
[-- Type: text/plain, Size: 1126 bytes --]
* m68k-tdep.h (enum m68k_flavour): New.
(struct gdbarch_tdep): New fields
float_return, fpreg_type, flavour and
fpregs_present.
* m68k-tdep.c (m68k_register_type): Use
fpregs_present and conditionalize floating
registers type on flavour.
(m68k_register_names): New.
(m68k_register_name): Use the above.
(m68k_convert_register_p): Consult fpregs_present.
(m68k_register_to_value, m68k_value_to_register):
Use register_type to obtain the type of floating
point registers.
(m68k_svr4_extract_return_value): Check tdep->float_return.
Use register_type to get the type of floating
point regiters.
(m68k_svr4_store_return_value): Likewise.
(m68k_dwarf_reg_to_regnum): Check tdep->fpregs_present.
(m68k_analyze_register_saves): Likewise.
(m68k_gdbarch_init): Extract infromation
from XML description, if present. Guess coldfire by
looking at the file, if present. Conditionalize
setting of long double format. Set decr_pc_after_break
to 2 on coldfire and fido. Enable XML-driven
register description.
* m68kbsd-tdep.c (m68kbsd_fpreg_offset): Use
size of tdep->fpreg_type, as opposed to hardcoded value.
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-15 10:17 ` Vladimir Prus
@ 2007-06-15 14:47 ` Daniel Jacobowitz
2007-06-15 19:05 ` Vladimir Prus
0 siblings, 1 reply; 19+ messages in thread
From: Daniel Jacobowitz @ 2007-06-15 14:47 UTC (permalink / raw)
To: Vladimir Prus; +Cc: Andreas Schwab, gdb-patches
On Fri, Jun 15, 2007 at 02:17:24PM +0400, Vladimir Prus wrote:
> On Tuesday 12 June 2007 17:38, Daniel Jacobowitz wrote:
>
> > > I suppose I can add file-based detection for fido, just like it's done for coldfire,
> > > but I don't think removing XML-based detection is right. What do you think?
> >
> > Right, sorry - I know what I meant to say, but I didn't say it.
> >
> > Float return behavior is not a property of the target at all; it's a
> > property of the compiler options used. decr_pc_after_break is a
> > target property, though, so we should trust the target. This isn't
> > important, though, so feel free to commit without changing this. If
> > it causes any problems we can clean it up later.
>
> Ok, excellent.
>
> I attach a patch that differs only by non-taking of address of builtin_types. OK?
I also wrote:
> This is mostly OK. Please add a Makefile.in update for the new
> #include. Also, we've added XML support for another target. So it
> needs a new section in the manual describing which targets support
> XML registers, and which registers are required.
It does still need those. Other than that it's OK.
--
Daniel Jacobowitz
CodeSourcery
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-15 14:47 ` Daniel Jacobowitz
@ 2007-06-15 19:05 ` Vladimir Prus
2007-06-16 10:21 ` Eli Zaretskii
0 siblings, 1 reply; 19+ messages in thread
From: Vladimir Prus @ 2007-06-15 19:05 UTC (permalink / raw)
To: Daniel Jacobowitz; +Cc: Andreas Schwab, gdb-patches, Eli Zaretskii
[-- Attachment #1: Type: text/plain, Size: 1298 bytes --]
On Friday 15 June 2007 18:47, Daniel Jacobowitz wrote:
> On Fri, Jun 15, 2007 at 02:17:24PM +0400, Vladimir Prus wrote:
> > On Tuesday 12 June 2007 17:38, Daniel Jacobowitz wrote:
> >
> > > > I suppose I can add file-based detection for fido, just like it's done for coldfire,
> > > > but I don't think removing XML-based detection is right. What do you think?
> > >
> > > Right, sorry - I know what I meant to say, but I didn't say it.
> > >
> > > Float return behavior is not a property of the target at all; it's a
> > > property of the compiler options used. decr_pc_after_break is a
> > > target property, though, so we should trust the target. This isn't
> > > important, though, so feel free to commit without changing this. If
> > > it causes any problems we can clean it up later.
> >
> > Ok, excellent.
> >
> > I attach a patch that differs only by non-taking of address of builtin_types. OK?
>
> I also wrote:
>
> > This is mostly OK. Please add a Makefile.in update for the new
> > #include. Also, we've added XML support for another target. So it
> > needs a new section in the manual describing which targets support
> > XML registers, and which registers are required.
>
> It does still need those. Other than that it's OK.
Does this doco patch look good?
- Volodya
[-- Attachment #2: docs.diff --]
[-- Type: text/x-diff, Size: 953 bytes --]
--- gdb.texinfo (revision 4281)
+++ gdb.texinfo (local)
@@ -25751,6 +25751,22 @@ it should contain at least registers @sa
@samp{wCGR0} through @samp{wCGR3}. The @samp{wCID}, @samp{wCon},
@samp{wCSSF}, and @samp{wCASF} registers are optional.
+@subsection M68K Features
+@cindex target descriptions, M68K features
+
+An M68K target is required to have either the
+@samp{org.gnu.gdb.m68k.core} feature or the
+@samp{org.gnu.gdb.coldfire.core} feature or the
+@samp{org.gnu.gdb.fido.core} feature. Which feature is present
+determines which flavour of m68k is used. The present feature
+should contain registers @samp{d0} through @samp{d7},
+@samp{a0} through @samp{a5}, @samp{fp}, @samp{sp}, @samp{ps} and
+@samp{pc}.
+
+The @samp{org.gnu.gdb.coldfire.fp} feature is optional. If present, it
+should contain registers @samp{fp0} through @samp{fp7},
+@samp{fpcontrol}, @samp{fpstatus} and @samp{fpiaddr}.
+
@include gpl.texi
@raisesections
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-15 19:05 ` Vladimir Prus
@ 2007-06-16 10:21 ` Eli Zaretskii
2007-06-19 16:39 ` Vladimir Prus
0 siblings, 1 reply; 19+ messages in thread
From: Eli Zaretskii @ 2007-06-16 10:21 UTC (permalink / raw)
To: Vladimir Prus; +Cc: drow, schwab, gdb-patches
> From: Vladimir Prus <vladimir@codesourcery.com>
> Date: Fri, 15 Jun 2007 23:05:25 +0400
> Cc: Andreas Schwab <schwab@suse.de>, gdb-patches@sources.redhat.com, Eli Zaretskii <eliz@gnu.org>
>
> Does this doco patch look good?
It's okay, but I'd prefer to convert the two subsections--the old ARM
one and the new one you wrote--into @node's, and add a menu in their
parent. With two targets (and more to come, I presume), it is no
longer a good idea to hide those subsections from the menu traversing
commands of an Info reader.
> +An M68K target is required to have either the
> +@samp{org.gnu.gdb.m68k.core} feature or the
> +@samp{org.gnu.gdb.coldfire.core} feature or the
> +@samp{org.gnu.gdb.fido.core} feature. Which feature is present
> +determines which flavour of m68k is used. The present feature
> +should contain registers @samp{d0} through @samp{d7},
> +@samp{a0} through @samp{a5}, @samp{fp}, @samp{sp}, @samp{ps} and
> +@samp{pc}.
> +
> +The @samp{org.gnu.gdb.coldfire.fp} feature is optional. If present, it
> +should contain registers @samp{fp0} through @samp{fp7},
> +@samp{fpcontrol}, @samp{fpstatus} and @samp{fpiaddr}.
Isn't it better to use an @itemize list here? How about the following
rewording:
@node M68K Features
@subsection M68K Features
@cindex target descriptions, M68K features
An M68K target can have either one of the following features:
@itemize @bullet{}
@item
@samp{org.gnu.gdb.m68k.core}
@itemx
@samp{org.gnu.gdb.coldfire.core}
@itemx
@samp{org.gnu.gdb.fido.core}
The feature that is present determines which flavor of m86k is
used. The feature that is present should contain registers
@samp{d0} through @samp{d7}, @samp{a0} through @samp{a5}, @samp{fp},
@samp{sp}, @samp{ps} and @samp{pc}.
@item
@samp{org.gnu.gdb.coldfire.fp}
This feature is optional. If present, it should contain registers
@samp{fp0} through @samp{fp7}, @samp{fpcontrol}, @samp{fpstatus} and
@samp{fpiaddr}.
@end itemize
Finally, please use the US English variant of spelling: "flavor", not
"flavour".
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-16 10:21 ` Eli Zaretskii
@ 2007-06-19 16:39 ` Vladimir Prus
2007-06-19 16:53 ` Eli Zaretskii
0 siblings, 1 reply; 19+ messages in thread
From: Vladimir Prus @ 2007-06-19 16:39 UTC (permalink / raw)
To: Eli Zaretskii; +Cc: drow, schwab, gdb-patches
On Saturday 16 June 2007 14:20, Eli Zaretskii wrote:
> > From: Vladimir Prus <vladimir@codesourcery.com>
> > Date: Fri, 15 Jun 2007 23:05:25 +0400
> > Cc: Andreas Schwab <schwab@suse.de>, gdb-patches@sources.redhat.com, Eli Zaretskii <eliz@gnu.org>
> >
> > Does this doco patch look good?
>
> It's okay, but I'd prefer to convert the two subsections--the old ARM
> one and the new one you wrote--into @node's, and add a menu in their
> parent. With two targets (and more to come, I presume), it is no
> longer a good idea to hide those subsections from the menu traversing
> commands of an Info reader.
Okay, I'll do this.
> > +An M68K target is required to have either the
> > +@samp{org.gnu.gdb.m68k.core} feature or the
> > +@samp{org.gnu.gdb.coldfire.core} feature or the
> > +@samp{org.gnu.gdb.fido.core} feature. Which feature is present
> > +determines which flavour of m68k is used. The present feature
> > +should contain registers @samp{d0} through @samp{d7},
> > +@samp{a0} through @samp{a5}, @samp{fp}, @samp{sp}, @samp{ps} and
> > +@samp{pc}.
> > +
> > +The @samp{org.gnu.gdb.coldfire.fp} feature is optional. If present, it
> > +should contain registers @samp{fp0} through @samp{fp7},
> > +@samp{fpcontrol}, @samp{fpstatus} and @samp{fpiaddr}.
>
> Isn't it better to use an @itemize list here? How about the following
> rewording:
>
> @node M68K Features
> @subsection M68K Features
> @cindex target descriptions, M68K features
>
> An M68K target can have either one of the following features:
> @itemize @bullet{}
> @item
> @samp{org.gnu.gdb.m68k.core}
> @itemx
> @samp{org.gnu.gdb.coldfire.core}
> @itemx
> @samp{org.gnu.gdb.fido.core}
> The feature that is present determines which flavor of m86k is
> used. The feature that is present should contain registers
> @samp{d0} through @samp{d7}, @samp{a0} through @samp{a5}, @samp{fp},
> @samp{sp}, @samp{ps} and @samp{pc}.
>
> @item
> @samp{org.gnu.gdb.coldfire.fp}
> This feature is optional. If present, it should contain registers
> @samp{fp0} through @samp{fp7}, @samp{fpcontrol}, @samp{fpstatus} and
> @samp{fpiaddr}.
> @end itemize
When I try copy-pasting this, I get:
@itemx not meaningful inside `itemize' block.
It also seems that the general structure says that both .*core* and coldfire.fp are optional,
while I meant to say that one of .*core.* is required, while coldfire.fp is optional.
>
> Finally, please use the US English variant of spelling: "flavor", not
> "flavour".
Ok.
- Volodya
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-19 16:39 ` Vladimir Prus
@ 2007-06-19 16:53 ` Eli Zaretskii
2007-06-19 17:10 ` Daniel Jacobowitz
0 siblings, 1 reply; 19+ messages in thread
From: Eli Zaretskii @ 2007-06-19 16:53 UTC (permalink / raw)
To: Vladimir Prus; +Cc: drow, schwab, gdb-patches
> From: Vladimir Prus <vladimir@codesourcery.com>
> Date: Tue, 19 Jun 2007 20:39:35 +0400
> Cc: drow@false.org,
> schwab@suse.de,
> gdb-patches@sources.redhat.com
>
> @itemx not meaningful inside `itemize' block.
Yes, I should have used @table. Sorry.
> It also seems that the general structure says that both .*core* and coldfire.fp are optional,
> while I meant to say that one of .*core.* is required, while coldfire.fp is optional.
But that's what the text says (I simply copied it from what you
wrote): one of the first 3, and only one, must be present, while the
last one is optional.
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-19 16:53 ` Eli Zaretskii
@ 2007-06-19 17:10 ` Daniel Jacobowitz
2007-06-19 18:00 ` Eli Zaretskii
0 siblings, 1 reply; 19+ messages in thread
From: Daniel Jacobowitz @ 2007-06-19 17:10 UTC (permalink / raw)
To: Eli Zaretskii; +Cc: Vladimir Prus, schwab, gdb-patches
On Tue, Jun 19, 2007 at 12:53:40PM -0400, Eli Zaretskii wrote:
> > From: Vladimir Prus <vladimir@codesourcery.com>
> > Date: Tue, 19 Jun 2007 20:39:35 +0400
> > Cc: drow@false.org,
> > schwab@suse.de,
> > gdb-patches@sources.redhat.com
> >
> > @itemx not meaningful inside `itemize' block.
>
> Yes, I should have used @table. Sorry.
>
> > It also seems that the general structure says that both .*core* and coldfire.fp are optional,
> > while I meant to say that one of .*core.* is required, while coldfire.fp is optional.
>
> But that's what the text says (I simply copied it from what you
> wrote): one of the first 3, and only one, must be present, while the
> last one is optional.
You put "An M68K target can have either one of the following
features:" before the top of the table, and the table had two rows -
one for all the core features, one for the FP feature. I read that
the same way Vladimir did. Maybe that sentence should be inside the
description of the three @item / @itemx / @itemx core features?
--
Daniel Jacobowitz
CodeSourcery
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-19 17:10 ` Daniel Jacobowitz
@ 2007-06-19 18:00 ` Eli Zaretskii
2007-06-20 9:14 ` Vladimir Prus
0 siblings, 1 reply; 19+ messages in thread
From: Eli Zaretskii @ 2007-06-19 18:00 UTC (permalink / raw)
To: Daniel Jacobowitz; +Cc: vladimir, schwab, gdb-patches
> Date: Tue, 19 Jun 2007 13:10:30 -0400
> From: Daniel Jacobowitz <drow@false.org>
> Cc: Vladimir Prus <vladimir@codesourcery.com>, schwab@suse.de,
> gdb-patches@sources.redhat.com
>
> Maybe that sentence should be inside the
> description of the three @item / @itemx / @itemx core features?
Fine with me.
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-19 18:00 ` Eli Zaretskii
@ 2007-06-20 9:14 ` Vladimir Prus
2007-06-20 18:15 ` Eli Zaretskii
0 siblings, 1 reply; 19+ messages in thread
From: Vladimir Prus @ 2007-06-20 9:14 UTC (permalink / raw)
To: Eli Zaretskii; +Cc: Daniel Jacobowitz, schwab, gdb-patches
[-- Attachment #1: Type: text/plain, Size: 411 bytes --]
On Tuesday 19 June 2007 22:00, Eli Zaretskii wrote:
> > Date: Tue, 19 Jun 2007 13:10:30 -0400
> > From: Daniel Jacobowitz <drow@false.org>
> > Cc: Vladimir Prus <vladimir@codesourcery.com>, schwab@suse.de,
> > gdb-patches@sources.redhat.com
> >
> > Maybe that sentence should be inside the
> > description of the three @item / @itemx / @itemx core features?
>
> Fine with me.
Is the attached OK?
- Volodya
[-- Attachment #2: doc.diff --]
[-- Type: text/x-diff, Size: 1344 bytes --]
--- gdb.texinfo (revision 4281)
+++ gdb.texinfo (local)
@@ -25736,6 +25736,13 @@ The names of registers are not case sens
of recognizing standard features, but @value{GDBN} will only display
registers using the capitalization used in the description.
+@menu
+* ARM Features::
+* M68K Features::
+@end menu
+
+
+@node ARM Features
@subsection ARM Features
@cindex target descriptions, ARM features
@@ -25751,6 +25758,26 @@ it should contain at least registers @sa
@samp{wCGR0} through @samp{wCGR3}. The @samp{wCID}, @samp{wCon},
@samp{wCSSF}, and @samp{wCASF} registers are optional.
+@node M68K Features
+@subsection M68K Features
+@cindex target descriptions, M68K features
+
+@table @code
+@item @samp{org.gnu.gdb.m68k.core}
+@itemx @samp{org.gnu.gdb.coldfire.core}
+@itemx @samp{org.gnu.gdb.fido.core}
+One of those features must be always present.
+The feature that is present determines which flavor of m86k is
+used. The feature that is present should contain registers
+@samp{d0} through @samp{d7}, @samp{a0} through @samp{a5}, @samp{fp},
+@samp{sp}, @samp{ps} and @samp{pc}.
+
+@item @samp{org.gnu.gdb.coldfire.fp}
+This feature is optional. If present, it should contain registers
+@samp{fp0} through @samp{fp7}, @samp{fpcontrol}, @samp{fpstatus} and
+@samp{fpiaddr}.
+@end table
+
@include gpl.texi
@raisesections
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-20 9:14 ` Vladimir Prus
@ 2007-06-20 18:15 ` Eli Zaretskii
0 siblings, 0 replies; 19+ messages in thread
From: Eli Zaretskii @ 2007-06-20 18:15 UTC (permalink / raw)
To: Vladimir Prus; +Cc: drow, schwab, gdb-patches
> From: Vladimir Prus <vladimir@codesourcery.com>
> Date: Wed, 20 Jun 2007 13:14:06 +0400
> Cc: Daniel Jacobowitz <drow@false.org>,
> schwab@suse.de,
> gdb-patches@sources.redhat.com
>
> > > Maybe that sentence should be inside the
> > > description of the three @item / @itemx / @itemx core features?
> >
> > Fine with me.
>
> Is the attached OK?
Yes, thanks.
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-05-28 11:43 ` Vladimir Prus
2007-06-05 15:19 ` Daniel Jacobowitz
@ 2007-06-30 15:47 ` Andreas Schwab
2007-06-30 16:00 ` Daniel Jacobowitz
1 sibling, 1 reply; 19+ messages in thread
From: Andreas Schwab @ 2007-06-30 15:47 UTC (permalink / raw)
To: Vladimir Prus; +Cc: gdb-patches
Vladimir Prus <vladimir@codesourcery.com> writes:
> + /* The mechanism for returning floating values from function
> + and the type of long double depend on whether we're
> + on ColdFire or standard m68k. */
> +
> + if (info.bfd_arch_info)
> + {
> + const bfd_arch_info_type *coldfire_arch =
> + bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
> +
> + if (coldfire_arch
> + && (*info.bfd_arch_info->compatible)
> + (info.bfd_arch_info, coldfire_arch))
> + flavour = m68k_coldfire_flavour;
> + }
This always sets flavour to m68k_coldfire_flavour, since any m68k arch
is always compatible with the generic m68k architecture.
Andreas.
2007-06-30 Andreas Schwab <schwab@suse.de>
* m68k-tdep.c (m68k_gdbarch_init): Don't infer coldfire flavour
from the generic m68k arch.
--- gdb/m68k-tdep.c.~1.120.~ 2007-06-19 11:04:57.000000000 +0200
+++ gdb/m68k-tdep.c 2007-06-30 17:26:39.000000000 +0200
@@ -1110,14 +1110,14 @@ m68k_gdbarch_init (struct gdbarch_info i
and the type of long double depend on whether we're
on ColdFire or standard m68k. */
- if (info.bfd_arch_info)
+ if (info.bfd_arch_info && info.bfd_arch_info->mach != 0)
{
const bfd_arch_info_type *coldfire_arch =
bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
if (coldfire_arch
- && (*info.bfd_arch_info->compatible)
- (info.bfd_arch_info, coldfire_arch))
+ && ((*info.bfd_arch_info->compatible)
+ (info.bfd_arch_info, coldfire_arch)))
flavour = m68k_coldfire_flavour;
}
--
Andreas Schwab, SuSE Labs, schwab@suse.de
SuSE Linux Products GmbH, Maxfeldstraße 5, 90409 Nürnberg, Germany
PGP key fingerprint = 58CA 54C7 6D53 942B 1756 01D3 44D5 214B 8276 4ED5
"And now for something completely different."
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: ColdFire/fido support
2007-06-30 15:47 ` Andreas Schwab
@ 2007-06-30 16:00 ` Daniel Jacobowitz
0 siblings, 0 replies; 19+ messages in thread
From: Daniel Jacobowitz @ 2007-06-30 16:00 UTC (permalink / raw)
To: Andreas Schwab; +Cc: Vladimir Prus, gdb-patches
On Sat, Jun 30, 2007 at 05:35:45PM +0200, Andreas Schwab wrote:
> Vladimir Prus <vladimir@codesourcery.com> writes:
>
> > + /* The mechanism for returning floating values from function
> > + and the type of long double depend on whether we're
> > + on ColdFire or standard m68k. */
> > +
> > + if (info.bfd_arch_info)
> > + {
> > + const bfd_arch_info_type *coldfire_arch =
> > + bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
> > +
> > + if (coldfire_arch
> > + && (*info.bfd_arch_info->compatible)
> > + (info.bfd_arch_info, coldfire_arch))
> > + flavour = m68k_coldfire_flavour;
> > + }
>
> This always sets flavour to m68k_coldfire_flavour, since any m68k arch
> is always compatible with the generic m68k architecture.
>
> Andreas.
>
> 2007-06-30 Andreas Schwab <schwab@suse.de>
>
> * m68k-tdep.c (m68k_gdbarch_init): Don't infer coldfire flavour
> from the generic m68k arch.
Whoops. OK, thanks!
--
Daniel Jacobowitz
CodeSourcery
^ permalink raw reply [flat|nested] 19+ messages in thread
end of thread, other threads:[~2007-06-30 15:47 UTC | newest]
Thread overview: 19+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2007-05-05 9:37 ColdFire/fido support Vladimir Prus
2007-05-05 11:02 ` Andreas Schwab
2007-05-06 11:52 ` Vladimir Prus
2007-05-28 11:43 ` Vladimir Prus
2007-06-05 15:19 ` Daniel Jacobowitz
2007-06-08 10:58 ` Vladimir Prus
2007-06-12 13:38 ` Daniel Jacobowitz
2007-06-15 10:17 ` Vladimir Prus
2007-06-15 14:47 ` Daniel Jacobowitz
2007-06-15 19:05 ` Vladimir Prus
2007-06-16 10:21 ` Eli Zaretskii
2007-06-19 16:39 ` Vladimir Prus
2007-06-19 16:53 ` Eli Zaretskii
2007-06-19 17:10 ` Daniel Jacobowitz
2007-06-19 18:00 ` Eli Zaretskii
2007-06-20 9:14 ` Vladimir Prus
2007-06-20 18:15 ` Eli Zaretskii
2007-06-30 15:47 ` Andreas Schwab
2007-06-30 16:00 ` Daniel Jacobowitz
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox