X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fm68k-tdep.c;h=c0662e4a0fb0a98b58ea9f66b8c2d33ca8ced1bb;hb=e76ff5abe375e1e7535f7827db01bce70bc9710d;hp=dda67e3aa83c62da3da3374fd5cae5ef14b58e73;hpb=270677457f363b213b10923759f4f96ed1aa868b;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c index dda67e3aa8..c0662e4a0f 100644 --- a/gdb/m68k-tdep.c +++ b/gdb/m68k-tdep.c @@ -1,8 +1,6 @@ /* Target-dependent code for the Motorola 68000 series. - Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001, - 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 - Free Software Foundation, Inc. + Copyright (C) 1990-2013 Free Software Foundation, Inc. This file is part of GDB. @@ -54,7 +52,7 @@ #define P_MOVEL_SP 0x2f00 #define P_MOVEML_SP 0x48e7 -/* Offset from SP to first arg on stack at first instruction of a function */ +/* Offset from SP to first arg on stack at first instruction of a function. */ #define SP_ARG0 (1 * 4) #if !defined (BPT_VECTOR) @@ -71,29 +69,34 @@ m68k_local_breakpoint_from_pc (struct gdbarch *gdbarch, } -/* Type for %ps. */ -struct type *m68k_ps_type; - /* Construct types for ISA-specific registers. */ -static void -m68k_init_types (void) +static struct type * +m68k_ps_type (struct gdbarch *gdbarch) { - struct type *type; - - type = init_flags_type ("builtin_type_m68k_ps", 4); - append_flags_type_flag (type, 0, "C"); - append_flags_type_flag (type, 1, "V"); - append_flags_type_flag (type, 2, "Z"); - append_flags_type_flag (type, 3, "N"); - append_flags_type_flag (type, 4, "X"); - append_flags_type_flag (type, 8, "I0"); - append_flags_type_flag (type, 9, "I1"); - append_flags_type_flag (type, 10, "I2"); - append_flags_type_flag (type, 12, "M"); - append_flags_type_flag (type, 13, "S"); - append_flags_type_flag (type, 14, "T0"); - append_flags_type_flag (type, 15, "T1"); - m68k_ps_type = type; + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + if (!tdep->m68k_ps_type) + { + struct type *type; + + type = arch_flags_type (gdbarch, "builtin_type_m68k_ps", 4); + append_flags_type_flag (type, 0, "C"); + append_flags_type_flag (type, 1, "V"); + append_flags_type_flag (type, 2, "Z"); + append_flags_type_flag (type, 3, "N"); + append_flags_type_flag (type, 4, "X"); + append_flags_type_flag (type, 8, "I0"); + append_flags_type_flag (type, 9, "I1"); + append_flags_type_flag (type, 10, "I2"); + append_flags_type_flag (type, 12, "M"); + append_flags_type_flag (type, 13, "S"); + append_flags_type_flag (type, 14, "T0"); + append_flags_type_flag (type, 15, "T1"); + + tdep->m68k_ps_type = type; + } + + return tdep->m68k_ps_type; } static struct type * @@ -103,7 +106,7 @@ m68881_ext_type (struct gdbarch *gdbarch) if (!tdep->m68881_ext_type) tdep->m68881_ext_type - = init_float_type (-1, "builtin_type_m68881_ext", + = arch_float_type (gdbarch, -1, "builtin_type_m68881_ext", floatformats_m68881_ext); return tdep->m68881_ext_type; @@ -152,7 +155,7 @@ m68k_register_type (struct gdbarch *gdbarch, int regnum) return builtin_type (gdbarch)->builtin_data_ptr; if (regnum == M68K_PS_REGNUM) - return m68k_ps_type; + return m68k_ps_type (gdbarch); return builtin_type (gdbarch)->builtin_int32; } @@ -166,14 +169,18 @@ static const char *m68k_register_names[] = { }; /* Function: m68k_register_name - Returns the name of the standard m68k register regnum. */ + Returns the name of the standard m68k register regnum. */ static const char * m68k_register_name (struct gdbarch *gdbarch, int regnum) { if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names)) internal_error (__FILE__, __LINE__, - _("m68k_register_name: illegal register number %d"), regnum); + _("m68k_register_name: illegal register number %d"), + regnum); + else if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM + && gdbarch_tdep (gdbarch)->fpregs_present == 0) + return ""; else return m68k_register_names[regnum]; } @@ -182,20 +189,22 @@ m68k_register_name (struct gdbarch *gdbarch, int regnum) needs any special handling. */ static int -m68k_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type) +m68k_convert_register_p (struct gdbarch *gdbarch, + int regnum, struct type *type) { if (!gdbarch_tdep (gdbarch)->fpregs_present) return 0; return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7 - && type != m68881_ext_type (gdbarch)); + && type != register_type (gdbarch, M68K_FP0_REGNUM)); } /* Read a value of type TYPE from register REGNUM in frame FRAME, and return its contents in TO. */ -static void +static int m68k_register_to_value (struct frame_info *frame, int regnum, - struct type *type, gdb_byte *to) + struct type *type, gdb_byte *to, + int *optimizedp, int *unavailablep) { gdb_byte from[M68K_MAX_REGISTER_SIZE]; struct type *fpreg_type = register_type (get_frame_arch (frame), @@ -206,12 +215,20 @@ m68k_register_to_value (struct frame_info *frame, int regnum, { warning (_("Cannot convert floating-point register value " "to non-floating-point type.")); - return; + *optimizedp = *unavailablep = 0; + return 0; } /* Convert to TYPE. */ - get_frame_register (frame, regnum, from); + + /* Convert to TYPE. */ + if (!get_frame_register_bytes (frame, regnum, 0, TYPE_LENGTH (type), + from, optimizedp, unavailablep)) + return 0; + convert_typed_floating (from, fpreg_type, to, type); + *optimizedp = *unavailablep = 0; + return 1; } /* Write the contents FROM of a value of type TYPE into register @@ -298,7 +315,6 @@ static void m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache, gdb_byte *valbuf) { - int len = TYPE_LENGTH (type); gdb_byte buf[M68K_MAX_REGISTER_SIZE]; struct gdbarch *gdbarch = get_regcache_arch (regcache); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); @@ -309,7 +325,7 @@ m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache, regcache_raw_read (regcache, M68K_FP0_REGNUM, buf); convert_typed_floating (buf, fpreg_type, valbuf, type); } - else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4) + else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4) regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf); else m68k_extract_return_value (type, regcache, valbuf); @@ -340,7 +356,6 @@ static void m68k_svr4_store_return_value (struct type *type, struct regcache *regcache, const gdb_byte *valbuf) { - int len = TYPE_LENGTH (type); struct gdbarch *gdbarch = get_regcache_arch (regcache); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); @@ -351,7 +366,7 @@ m68k_svr4_store_return_value (struct type *type, struct regcache *regcache, 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) + else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4) { regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf); regcache_raw_write (regcache, M68K_D0_REGNUM, valbuf); @@ -360,8 +375,8 @@ m68k_svr4_store_return_value (struct type *type, struct regcache *regcache, m68k_store_return_value (type, regcache, valbuf); } -/* Return non-zero if TYPE, which is assumed to be a structure or - union type, should be returned in registers for architecture +/* Return non-zero if TYPE, which is assumed to be a structure, union or + complex type, should be returned in registers for architecture GDBARCH. */ static int @@ -371,7 +386,8 @@ m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type) enum type_code code = TYPE_CODE (type); int len = TYPE_LENGTH (type); - gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION); + gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION + || code == TYPE_CODE_COMPLEX); if (tdep->struct_return == pcc_struct_return) return 0; @@ -386,14 +402,15 @@ m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type) from WRITEBUF into REGCACHE. */ static enum return_value_convention -m68k_return_value (struct gdbarch *gdbarch, struct type *func_type, +m68k_return_value (struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { enum type_code code = TYPE_CODE (type); /* GCC returns a `long double' in memory too. */ - if (((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION) + if (((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION + || code == TYPE_CODE_COMPLEX) && !m68k_reg_struct_return_p (gdbarch, type)) || (code == TYPE_CODE_FLT && TYPE_LENGTH (type) == 12)) { @@ -421,13 +438,14 @@ m68k_return_value (struct gdbarch *gdbarch, struct type *func_type, } static enum return_value_convention -m68k_svr4_return_value (struct gdbarch *gdbarch, struct type *func_type, +m68k_svr4_return_value (struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { enum type_code code = TYPE_CODE (type); - if ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION) + if ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION + || code == TYPE_CODE_COMPLEX) && !m68k_reg_struct_return_p (gdbarch, type)) { /* The System V ABI says that: @@ -460,7 +478,7 @@ m68k_svr4_return_value (struct gdbarch *gdbarch, struct type *func_type, if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1) { type = check_typedef (TYPE_FIELD_TYPE (type, 0)); - return m68k_svr4_return_value (gdbarch, func_type, type, regcache, + return m68k_svr4_return_value (gdbarch, function, type, regcache, readbuf, writebuf); } @@ -490,6 +508,7 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function, CORE_ADDR struct_addr) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); gdb_byte buf[4]; int i; @@ -517,17 +536,17 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Store struct value address. */ if (struct_return) { - store_unsigned_integer (buf, 4, struct_addr); + store_unsigned_integer (buf, 4, byte_order, struct_addr); regcache_cooked_write (regcache, tdep->struct_value_regnum, buf); } /* Store return address. */ sp -= 4; - store_unsigned_integer (buf, 4, bp_addr); + store_unsigned_integer (buf, 4, byte_order, bp_addr); write_memory (sp, buf, 4); /* Finally, update the stack pointer... */ - store_unsigned_integer (buf, 4, sp); + store_unsigned_integer (buf, 4, byte_order, sp); regcache_cooked_write (regcache, M68K_SP_REGNUM, buf); /* ...and fake a frame pointer. */ @@ -608,15 +627,17 @@ m68k_alloc_frame_cache (void) Otherwise, return PC. */ static CORE_ADDR -m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc, +m68k_analyze_frame_setup (struct gdbarch *gdbarch, + CORE_ADDR pc, CORE_ADDR current_pc, struct m68k_frame_cache *cache) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int op; if (pc >= current_pc) return current_pc; - op = read_memory_unsigned_integer (pc, 2); + op = read_memory_unsigned_integer (pc, 2, byte_order); if (op == P_LINKW_FP || op == P_LINKL_FP || op == P_PEA_FP) { @@ -626,14 +647,14 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc, { /* link.w %fp, #-N */ /* link.w %fp, #0; adda.l #-N, %sp */ - cache->locals = -read_memory_integer (pc + 2, 2); + cache->locals = -read_memory_integer (pc + 2, 2, byte_order); if (pc + 4 < current_pc && cache->locals == 0) { - op = read_memory_unsigned_integer (pc + 4, 2); + op = read_memory_unsigned_integer (pc + 4, 2, byte_order); if (op == P_ADDAL_SP) { - cache->locals = read_memory_integer (pc + 6, 4); + cache->locals = read_memory_integer (pc + 6, 4, byte_order); return pc + 10; } } @@ -643,7 +664,7 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc, else if (op == P_LINKL_FP) { /* link.l %fp, #-N */ - cache->locals = -read_memory_integer (pc + 2, 4); + cache->locals = -read_memory_integer (pc + 2, 4, byte_order); return pc + 6; } else @@ -653,7 +674,7 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc, if (pc + 2 < current_pc) { - op = read_memory_unsigned_integer (pc + 2, 2); + op = read_memory_unsigned_integer (pc + 2, 2, byte_order); if (op == P_MOVEAL_SP_FP) { @@ -672,7 +693,7 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc, cache->locals = (op & 07000) == 0 ? 8 : (op & 07000) >> 9; if (pc + 2 < current_pc) { - op = read_memory_unsigned_integer (pc + 2, 2); + op = read_memory_unsigned_integer (pc + 2, 2, byte_order); if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP) { cache->locals += (op & 07000) == 0 ? 8 : (op & 07000) >> 9; @@ -685,13 +706,13 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc, { /* adda.w #-N,%sp */ /* lea (-N,%sp),%sp */ - cache->locals = -read_memory_integer (pc + 2, 2); + cache->locals = -read_memory_integer (pc + 2, 2, byte_order); return pc + 4; } else if (op == P_ADDAL_SP) { /* adda.l #-N,%sp */ - cache->locals = -read_memory_integer (pc + 2, 4); + cache->locals = -read_memory_integer (pc + 2, 4, byte_order); return pc + 6; } @@ -708,6 +729,8 @@ m68k_analyze_register_saves (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct m68k_frame_cache *cache) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + if (cache->locals >= 0) { CORE_ADDR offset; @@ -717,12 +740,12 @@ m68k_analyze_register_saves (struct gdbarch *gdbarch, CORE_ADDR pc, offset = -4 - cache->locals; while (pc < current_pc) { - op = read_memory_unsigned_integer (pc, 2); + op = read_memory_unsigned_integer (pc, 2, byte_order); if (op == P_FMOVEMX_SP && gdbarch_tdep (gdbarch)->fpregs_present) { /* fmovem.x REGS,-(%sp) */ - op = read_memory_unsigned_integer (pc + 2, 2); + op = read_memory_unsigned_integer (pc + 2, 2, byte_order); if ((op & 0xff00) == 0xe000) { mask = op & 0xff; @@ -750,7 +773,7 @@ m68k_analyze_register_saves (struct gdbarch *gdbarch, CORE_ADDR pc, else if (op == P_MOVEML_SP) { /* movem.l REGS,-(%sp) */ - mask = read_memory_unsigned_integer (pc + 2, 2); + mask = read_memory_unsigned_integer (pc + 2, 2, byte_order); for (i = 0; i < 16; i++, mask >>= 1) { if (mask & 1) @@ -806,15 +829,16 @@ static CORE_ADDR m68k_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct m68k_frame_cache *cache) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); unsigned int op; - pc = m68k_analyze_frame_setup (pc, current_pc, cache); + pc = m68k_analyze_frame_setup (gdbarch, pc, current_pc, cache); pc = m68k_analyze_register_saves (gdbarch, pc, current_pc, cache); if (pc >= current_pc) return current_pc; /* Check for GOT setup. */ - op = read_memory_unsigned_integer (pc, 4); + op = read_memory_unsigned_integer (pc, 4, byte_order); if (op == P_LEA_PC_A5) { /* lea (%pc,N),%a5 */ @@ -831,7 +855,6 @@ m68k_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc) { struct m68k_frame_cache cache; CORE_ADDR pc; - int op; cache.locals = -1; pc = m68k_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache); @@ -854,6 +877,8 @@ m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) static struct m68k_frame_cache * m68k_frame_cache (struct frame_info *this_frame, void **this_cache) { + struct gdbarch *gdbarch = get_frame_arch (this_frame); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct m68k_frame_cache *cache; gdb_byte buf[4]; int i; @@ -874,7 +899,7 @@ m68k_frame_cache (struct frame_info *this_frame, void **this_cache) in progress when the signal occurred. */ get_frame_register (this_frame, M68K_FP_REGNUM, buf); - cache->base = extract_unsigned_integer (buf, 4); + cache->base = extract_unsigned_integer (buf, 4, byte_order); if (cache->base == 0) return cache; @@ -897,7 +922,8 @@ m68k_frame_cache (struct frame_info *this_frame, void **this_cache) functions this might work too. */ get_frame_register (this_frame, M68K_SP_REGNUM, buf); - cache->base = extract_unsigned_integer (buf, 4) + cache->sp_offset; + cache->base = extract_unsigned_integer (buf, 4, byte_order) + + cache->sp_offset; } /* Now that we have the base address for the stack frame we can @@ -948,6 +974,7 @@ m68k_frame_prev_register (struct frame_info *this_frame, void **this_cache, static const struct frame_unwind m68k_frame_unwind = { NORMAL_FRAME, + default_frame_unwind_stop_reason, m68k_frame_this_id, m68k_frame_prev_register, NULL, @@ -985,7 +1012,7 @@ m68k_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) /* Figure out where the longjmp will land. Slurp the args out of the stack. We expect the first arg to be a pointer to the jmp_buf structure from which we extract the pc (JB_PC) that we will land at. The pc is copied into PC. - This routine returns true on success. */ + This routine returns true on success. */ static int m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) @@ -993,7 +1020,8 @@ m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) gdb_byte *buf; CORE_ADDR sp, jb_addr; struct gdbarch *gdbarch = get_frame_arch (frame); - struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame)); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); if (tdep->jb_pc < 0) { @@ -1005,23 +1033,34 @@ m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT); sp = get_frame_register_unsigned (frame, gdbarch_sp_regnum (gdbarch)); - if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */ + if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack. */ buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT)) return 0; jb_addr = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch) - / TARGET_CHAR_BIT); + / TARGET_CHAR_BIT, byte_order); if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf, - gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT)) + gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT), + byte_order) return 0; *pc = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch) - / TARGET_CHAR_BIT); + / TARGET_CHAR_BIT, byte_order); return 1; } +/* This is the implementation of gdbarch method + return_in_first_hidden_param_p. */ + +static int +m68k_return_in_first_hidden_param_p (struct gdbarch *gdbarch, + struct type *type) +{ + return 0; +} + /* System V Release 4 (SVR4). */ void @@ -1039,7 +1078,7 @@ m68k_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) /* Function: m68k_gdbarch_init Initializer function for the m68k gdbarch vector. - Called by gdbarch. Sets up the gdbarch vector(s) for this target. */ + Called by gdbarch. Sets up the gdbarch vector(s) for this target. */ static struct gdbarch * m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) @@ -1061,9 +1100,6 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) feature = tdesc_find_feature (info.target_desc, "org.gnu.gdb.m68k.core"); - if (feature != NULL) - /* Do nothing. */ - ; if (feature == NULL) { @@ -1117,7 +1153,7 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* The mechanism for returning floating values from function and the type of long double depend on whether we're - on ColdFire or standard m68k. */ + on ColdFire or standard m68k. */ if (info.bfd_arch_info && info.bfd_arch_info->mach != 0) { @@ -1144,7 +1180,14 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) break; } - tdep = xmalloc (sizeof (struct gdbarch_tdep)); + if (best_arch != NULL) + { + if (tdesc_data != NULL) + tdesc_data_cleanup (tdesc_data); + return best_arch->gdbarch; + } + + tdep = xzalloc (sizeof (struct gdbarch_tdep)); gdbarch = gdbarch_alloc (&info, tdep); tdep->fpregs_present = has_fp; tdep->flavour = flavour; @@ -1157,7 +1200,7 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue); set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc); - /* Stack grows down. */ + /* Stack grows down. */ set_gdbarch_inner_than (gdbarch, core_addr_lessthan); set_gdbarch_frame_align (gdbarch, m68k_frame_align); @@ -1174,7 +1217,6 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM); set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM); set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM); - set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM); set_gdbarch_convert_register_p (gdbarch, m68k_convert_register_p); set_gdbarch_register_to_value (gdbarch, m68k_register_to_value); set_gdbarch_value_to_register (gdbarch, m68k_value_to_register); @@ -1198,9 +1240,11 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tdep->float_return = 0; } - /* Function call & return */ + /* Function call & return. */ set_gdbarch_push_dummy_call (gdbarch, m68k_push_dummy_call); set_gdbarch_return_value (gdbarch, m68k_return_value); + set_gdbarch_return_in_first_hidden_param_p (gdbarch, + m68k_return_in_first_hidden_param_p); /* Disassembler. */ @@ -1257,7 +1301,4 @@ void _initialize_m68k_tdep (void) { gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep); - - /* Initialize the m68k-specific register types. */ - m68k_init_types (); }