This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.
Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
---|---|---|
Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |
Other format: | [Raw text] |
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
--- 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" @@ -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]; } /* 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:
2.ChangeLog
Description: Text document
Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
---|---|---|
Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |