X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fm68k-tdep.c;h=58cbf90426c34c92f96fa7018f7585b720fb6c47;hb=eb7b504651ff7b44a7328cd967629d8f1d114a4b;hp=28e38eb44259d197a994070bc9e3045d12afa72f;hpb=0fb0cc7590113e9b459dfcc48dc71c9d419d9580;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c index 28e38eb442..58cbf90426 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-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -28,14 +26,14 @@ #include "symtab.h" #include "gdbcore.h" #include "value.h" -#include "gdb_string.h" -#include "gdb_assert.h" #include "inferior.h" #include "regcache.h" #include "arch-utils.h" #include "osabi.h" #include "dis-asm.h" #include "target-descriptions.h" +#include "floatformat.h" +#include "target-float.h" #include "m68k-tdep.h" @@ -54,46 +52,59 @@ #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) #define BPT_VECTOR 0xf #endif -static const gdb_byte * -m68k_local_breakpoint_from_pc (struct gdbarch *gdbarch, - CORE_ADDR *pcptr, int *lenptr) -{ - static gdb_byte break_insn[] = {0x4e, (0x40 | BPT_VECTOR)}; - *lenptr = sizeof (break_insn); - return break_insn; -} - +constexpr gdb_byte m68k_break_insn[] = {0x4e, (0x40 | BPT_VECTOR)}; -/* Type for %ps. */ -struct type *m68k_ps_type; +typedef BP_MANIPULATION (m68k_break_insn) m68k_breakpoint; + /* 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", 32); + 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 * +m68881_ext_type (struct gdbarch *gdbarch) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + if (!tdep->m68881_ext_type) + tdep->m68881_ext_type + = arch_float_type (gdbarch, -1, "builtin_type_m68881_ext", + floatformats_m68881_ext); + + return tdep->m68881_ext_type; } /* Return the GDB type object for the "standard" data type of data in @@ -117,19 +128,19 @@ m68k_register_type (struct gdbarch *gdbarch, int regnum) if (tdep->flavour == m68k_coldfire_flavour) return builtin_type (gdbarch)->builtin_double; else - return builtin_type_m68881_ext; + return m68881_ext_type (gdbarch); } if (regnum == M68K_FPI_REGNUM) return builtin_type (gdbarch)->builtin_func_ptr; if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM) - return builtin_type_int32; + return builtin_type (gdbarch)->builtin_int32; } else { if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM) - return builtin_type_int0; + return builtin_type (gdbarch)->builtin_int0; } if (regnum == gdbarch_pc_regnum (gdbarch)) @@ -139,9 +150,9 @@ 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_int32; + return builtin_type (gdbarch)->builtin_int32; } static const char *m68k_register_names[] = { @@ -153,14 +164,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]; } @@ -169,36 +184,40 @@ 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 != builtin_type_m68881_ext); + /* We only support floating-point values. */ + && TYPE_CODE (type) == TYPE_CODE_FLT + && 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) { + struct gdbarch *gdbarch = get_frame_arch (frame); gdb_byte from[M68K_MAX_REGISTER_SIZE]; - struct type *fpreg_type = register_type (get_frame_arch (frame), - M68K_FP0_REGNUM); + struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM); - /* We only support floating-point values. */ - if (TYPE_CODE (type) != TYPE_CODE_FLT) - { - warning (_("Cannot convert floating-point register value " - "to non-floating-point type.")); - return; - } + gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT); /* Convert to TYPE. */ - get_frame_register (frame, regnum, from); - convert_typed_floating (from, fpreg_type, to, type); + if (!get_frame_register_bytes (frame, regnum, 0, + register_size (gdbarch, regnum), + from, optimizedp, unavailablep)) + return 0; + + target_float_convert (from, fpreg_type, to, type); + *optimizedp = *unavailablep = 0; + return 1; } /* Write the contents FROM of a value of type TYPE into register @@ -221,7 +240,7 @@ m68k_value_to_register (struct frame_info *frame, int regnum, } /* Convert from TYPE. */ - convert_typed_floating (from, type, to, fpreg_type); + target_float_convert (from, type, to, fpreg_type); put_frame_register (frame, regnum, to); } @@ -238,7 +257,7 @@ m68k_value_to_register (struct frame_info *frame, int regnum, The 68020/030/040/060 do support an FPU, either as a coprocessor (68881/2) or built-in (68040/68060). That's why System V release 4 - (SVR4) instroduces a new calling convention specified by the SVR4 + (SVR4) introduces a new calling convention specified by the SVR4 psABI. Integer values are returned in %d0/%d1, pointer return values in %a0 and floating values in %fp0. When calling functions returning a structure the caller should pass a pointer to a buffer @@ -267,14 +286,14 @@ m68k_extract_return_value (struct type *type, struct regcache *regcache, if (len <= 4) { - regcache_raw_read (regcache, M68K_D0_REGNUM, buf); + regcache->raw_read (M68K_D0_REGNUM, buf); memcpy (valbuf, buf + (4 - len), len); } else if (len <= 8) { - regcache_raw_read (regcache, M68K_D0_REGNUM, buf); + regcache->raw_read (M68K_D0_REGNUM, buf); memcpy (valbuf, buf + (8 - len), len - 4); - regcache_raw_read (regcache, M68K_D1_REGNUM, valbuf + (len - 4)); + regcache->raw_read (M68K_D1_REGNUM, valbuf + (len - 4)); } else internal_error (__FILE__, __LINE__, @@ -285,19 +304,18 @@ 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 *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT) { struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM); - regcache_raw_read (regcache, M68K_FP0_REGNUM, buf); - convert_typed_floating (buf, fpreg_type, valbuf, type); + regcache->raw_read (M68K_FP0_REGNUM, buf); + target_float_convert (buf, fpreg_type, valbuf, type); } - else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4) - regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf); + else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4) + regcache->raw_read (M68K_A0_REGNUM, valbuf); else m68k_extract_return_value (type, regcache, valbuf); } @@ -311,12 +329,11 @@ m68k_store_return_value (struct type *type, struct regcache *regcache, int len = TYPE_LENGTH (type); if (len <= 4) - regcache_raw_write_part (regcache, M68K_D0_REGNUM, 4 - len, len, valbuf); + regcache->raw_write_part (M68K_D0_REGNUM, 4 - len, len, valbuf); else if (len <= 8) { - regcache_raw_write_part (regcache, M68K_D0_REGNUM, 8 - len, - len - 4, valbuf); - regcache_raw_write (regcache, M68K_D1_REGNUM, valbuf + (len - 4)); + regcache->raw_write_part (M68K_D0_REGNUM, 8 - len, len - 4, valbuf); + regcache->raw_write (M68K_D1_REGNUM, valbuf + (len - 4)); } else internal_error (__FILE__, __LINE__, @@ -327,28 +344,27 @@ 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 *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT) { struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM); gdb_byte buf[M68K_MAX_REGISTER_SIZE]; - convert_typed_floating (valbuf, type, buf, fpreg_type); - regcache_raw_write (regcache, M68K_FP0_REGNUM, buf); + target_float_convert (valbuf, type, buf, fpreg_type); + regcache->raw_write (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); + regcache->raw_write (M68K_A0_REGNUM, valbuf); + regcache->raw_write (M68K_D0_REGNUM, valbuf); } else 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 @@ -358,7 +374,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; @@ -373,14 +390,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)) { @@ -408,13 +426,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: @@ -447,7 +466,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); } @@ -473,10 +492,12 @@ m68k_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp) static CORE_ADDR m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, - struct value **args, CORE_ADDR sp, int struct_return, + struct value **args, CORE_ADDR sp, + function_call_return_method return_method, 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; @@ -502,23 +523,23 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function, } /* Store struct value address. */ - if (struct_return) + if (return_method == return_method_struct) { - store_unsigned_integer (buf, 4, struct_addr); - regcache_cooked_write (regcache, tdep->struct_value_regnum, buf); + store_unsigned_integer (buf, 4, byte_order, struct_addr); + regcache->cooked_write (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); - regcache_cooked_write (regcache, M68K_SP_REGNUM, buf); + store_unsigned_integer (buf, 4, byte_order, sp); + regcache->cooked_write (M68K_SP_REGNUM, buf); /* ...and fake a frame pointer. */ - regcache_cooked_write (regcache, M68K_FP_REGNUM, buf); + regcache->cooked_write (M68K_FP_REGNUM, buf); /* DWARF2/GCC uses the stack address *before* the function call as a frame's CFA. */ @@ -543,7 +564,7 @@ m68k_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int num) /* pc */ return M68K_PC_REGNUM; else - return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); + return -1; } @@ -595,15 +616,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) { @@ -613,14 +636,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; } } @@ -630,7 +653,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 @@ -640,7 +663,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) { @@ -659,7 +682,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; @@ -672,13 +695,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; } @@ -695,6 +718,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; @@ -704,12 +729,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; @@ -737,7 +762,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) @@ -793,15 +818,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 */ @@ -818,7 +844,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); @@ -841,12 +866,14 @@ 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; if (*this_cache) - return *this_cache; + return (struct m68k_frame_cache *) *this_cache; cache = m68k_alloc_frame_cache (); *this_cache = cache; @@ -861,7 +888,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; @@ -884,7 +911,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 @@ -935,6 +963,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, @@ -972,7 +1001,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) @@ -980,7 +1009,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) { @@ -989,26 +1019,37 @@ m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) return 0; } - buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT); + buf = (gdb_byte *) 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 @@ -1026,7 +1067,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) @@ -1048,9 +1089,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) { @@ -1104,7 +1142,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) { @@ -1131,7 +1169,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 = XCNEW (struct gdbarch_tdep); gdbarch = gdbarch_alloc (&info, tdep); tdep->fpregs_present = has_fp; tdep->flavour = flavour; @@ -1142,9 +1187,10 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); + set_gdbarch_breakpoint_kind_from_pc (gdbarch, m68k_breakpoint::kind_from_pc); + set_gdbarch_sw_breakpoint_from_kind (gdbarch, m68k_breakpoint::bp_from_kind); - /* Stack grows down. */ + /* Stack grows down. */ set_gdbarch_inner_than (gdbarch, core_addr_lessthan); set_gdbarch_frame_align (gdbarch, m68k_frame_align); @@ -1161,7 +1207,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); @@ -1185,13 +1230,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); - - - /* Disassembler. */ - set_gdbarch_print_insn (gdbarch, print_insn_m68k); + set_gdbarch_return_in_first_hidden_param_p (gdbarch, + m68k_return_in_first_hidden_param_p); #if defined JB_PC && defined JB_ELEMENT_SIZE tdep->jb_pc = JB_PC; @@ -1238,13 +1281,8 @@ m68k_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file) return; } -extern initialize_file_ftype _initialize_m68k_tdep; /* -Wmissing-prototypes */ - 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 (); }