projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Pass Ctrl-C to the target in target_terminal_inferior
[deliverable/binutils-gdb.git] / gdb / m68k-tdep.c
diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c
index b91384c64911bd7e96720d67d252984694e1ca22..5d7b65d285e5baf530221bd31fe71f1a3e93fd64 100644 (file)
--- a/gdb/m68k-tdep.c
+++ b/gdb/m68k-tdep.c
@@ -1,13 +1,12 @@
 /* Target-dependent code for the Motorola 68000 series.
 
 /* 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 Free Software Foundation, Inc.
+   Copyright (C) 1990-2016 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -16,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "dwarf2-frame.h"
 
 #include "defs.h"
 #include "dwarf2-frame.h"
@@ -29,8 +26,6 @@
 #include "symtab.h"
 #include "gdbcore.h"
 #include "value.h"
 #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 "inferior.h"
 #include "regcache.h"
 #include "arch-utils.h"
@@ -55,7 +50,7 @@
 #define P_MOVEL_SP     0x2f00
 #define P_MOVEML_SP    0x48e7
 
 #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 SP_ARG0 (1 * 4)
 
 #if !defined (BPT_VECTOR)
@@ -63,12 +58,57 @@
 #endif
 
 static const gdb_byte *
 #endif
 
 static const gdb_byte *
-m68k_local_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+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;
 }
 {
   static gdb_byte break_insn[] = {0x4e, (0x40 | BPT_VECTOR)};
   *lenptr = sizeof (break_insn);
   return break_insn;
 }
+\f
+
+/* Construct types for ISA-specific registers.  */
+static struct type *
+m68k_ps_type (struct gdbarch *gdbarch)
+{
+  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 *
+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
    register N.  This should be int for D0-D7, SR, FPCONTROL and
 
 /* Return the GDB type object for the "standard" data type of data in
    register N.  This should be int for D0-D7, SR, FPCONTROL and
@@ -81,37 +121,41 @@ m68k_local_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 static struct type *
 m68k_register_type (struct gdbarch *gdbarch, int regnum)
 {
 static struct type *
 m68k_register_type (struct gdbarch *gdbarch, int regnum)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (tdep->fpregs_present)
     {
 
   if (tdep->fpregs_present)
     {
-      if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
+      if (regnum >= gdbarch_fp0_regnum (gdbarch)
+         && regnum <= gdbarch_fp0_regnum (gdbarch) + 7)
        {
          if (tdep->flavour == m68k_coldfire_flavour)
            return builtin_type (gdbarch)->builtin_double;
          else
        {
          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)
        }
 
       if (regnum == M68K_FPI_REGNUM)
-       return builtin_type_void_func_ptr;
+       return builtin_type (gdbarch)->builtin_func_ptr;
 
       if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM)
 
       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)
     }
   else
     {
       if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM)
-       return builtin_type_int0;
+       return builtin_type (gdbarch)->builtin_int0;
     }
 
     }
 
-  if (regnum == PC_REGNUM)
-    return builtin_type_void_func_ptr;
+  if (regnum == gdbarch_pc_regnum (gdbarch))
+    return builtin_type (gdbarch)->builtin_func_ptr;
 
   if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
 
   if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
-    return builtin_type_void_data_ptr;
+    return builtin_type (gdbarch)->builtin_data_ptr;
+
+  if (regnum == M68K_PS_REGNUM)
+    return m68k_ps_type (gdbarch);
 
 
-  return builtin_type_int32;
+  return builtin_type (gdbarch)->builtin_int32;
 }
 
 static const char *m68k_register_names[] = {
 }
 
 static const char *m68k_register_names[] = {
@@ -123,14 +167,18 @@ static const char *m68k_register_names[] = {
   };
 
 /* Function: m68k_register_name
   };
 
 /* 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 *
 
 static const char *
-m68k_register_name (int regnum)
+m68k_register_name (struct gdbarch *gdbarch, int regnum)
 {
   if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names))
     internal_error (__FILE__, __LINE__,
 {
   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];
 }
   else
     return m68k_register_names[regnum];
 }
@@ -139,35 +187,46 @@ m68k_register_name (int regnum)
    needs any special handling.  */
 
 static int
    needs any special handling.  */
 
 static int
-m68k_convert_register_p (int regnum, struct type *type)
+m68k_convert_register_p (struct gdbarch *gdbarch,
+                        int regnum, struct type *type)
 {
 {
-  if (!gdbarch_tdep (current_gdbarch)->fpregs_present)
+  if (!gdbarch_tdep (gdbarch)->fpregs_present)
     return 0;
     return 0;
-  return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7);
+  return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7
+         && 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.  */
 
 }
 
 /* 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,
 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];
 {
   gdb_byte from[M68K_MAX_REGISTER_SIZE];
-  struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM);
+  struct type *fpreg_type = register_type (get_frame_arch (frame),
+                                          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."));
 
   /* 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;
+      *optimizedp = *unavailablep = 0;
+      return 0;
     }
 
     }
 
-  /* 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 to TYPE.  */
+
+  /* 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);
   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
 }
 
 /* Write the contents FROM of a value of type TYPE into register
@@ -178,7 +237,8 @@ m68k_value_to_register (struct frame_info *frame, int regnum,
                        struct type *type, const gdb_byte *from)
 {
   gdb_byte to[M68K_MAX_REGISTER_SIZE];
                        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);
+  struct type *fpreg_type = register_type (get_frame_arch (frame),
+                                          M68K_FP0_REGNUM);
 
   /* We only support floating-point values.  */
   if (TYPE_CODE (type) != TYPE_CODE_FLT)
 
   /* We only support floating-point values.  */
   if (TYPE_CODE (type) != TYPE_CODE_FLT)
@@ -188,8 +248,7 @@ m68k_value_to_register (struct frame_info *frame, int regnum,
       return;
     }
 
       return;
     }
 
-  /* Convert from TYPE.  This should be a no-op if TYPE is equivalent
-     to the extended floating-point format used by the FPU.  */
+  /* Convert from TYPE.  */
   convert_typed_floating (from, type, to, fpreg_type);
   put_frame_register (frame, regnum, to);
 }
   convert_typed_floating (from, type, to, fpreg_type);
   put_frame_register (frame, regnum, to);
 }
@@ -254,18 +313,17 @@ static void
 m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache,
                                gdb_byte *valbuf)
 {
 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];
   gdb_byte buf[M68K_MAX_REGISTER_SIZE];
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (tdep->float_return && 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);
+      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 (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);
     regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
   else
     m68k_extract_return_value (type, regcache, valbuf);
@@ -296,18 +354,17 @@ static void
 m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
                              const gdb_byte *valbuf)
 {
 m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
                              const gdb_byte *valbuf)
 {
-  int len = TYPE_LENGTH (type);
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (tdep->float_return && 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);
+      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);
     }
       gdb_byte buf[M68K_MAX_REGISTER_SIZE];
       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);
     {
       regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf);
       regcache_raw_write (regcache, M68K_D0_REGNUM, valbuf);
@@ -316,8 +373,8 @@ m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
     m68k_store_return_value (type, regcache, valbuf);
 }
 
     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
    GDBARCH.  */
 
 static int
@@ -327,7 +384,8 @@ m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
   enum type_code code = TYPE_CODE (type);
   int len = TYPE_LENGTH (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;
 
   if (tdep->struct_return == pcc_struct_return)
     return 0;
@@ -342,14 +400,15 @@ m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
    from WRITEBUF into REGCACHE.  */
 
 static enum return_value_convention
    from WRITEBUF into REGCACHE.  */
 
 static enum return_value_convention
-m68k_return_value (struct gdbarch *gdbarch, struct type *type,
-                  struct regcache *regcache, gdb_byte *readbuf,
-                  const gdb_byte *writebuf)
+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.  */
 {
   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))
     {
        && !m68k_reg_struct_return_p (gdbarch, type))
       || (code == TYPE_CODE_FLT && TYPE_LENGTH (type) == 12))
     {
@@ -377,13 +436,14 @@ m68k_return_value (struct gdbarch *gdbarch, struct type *type,
 }
 
 static enum return_value_convention
 }
 
 static enum return_value_convention
-m68k_svr4_return_value (struct gdbarch *gdbarch, struct type *type,
-                       struct regcache *regcache, gdb_byte *readbuf,
-                       const gdb_byte *writebuf)
+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);
 
 {
   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:
       && !m68k_reg_struct_return_p (gdbarch, type))
     {
       /* The System V ABI says that:
@@ -416,7 +476,7 @@ m68k_svr4_return_value (struct gdbarch *gdbarch, struct type *type,
   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
     {
       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
     {
       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
-      return m68k_svr4_return_value (gdbarch, type, regcache,
+      return m68k_svr4_return_value (gdbarch, function, type, regcache,
                                     readbuf, writebuf);
     }
 
                                     readbuf, writebuf);
     }
 
@@ -446,6 +506,7 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                      CORE_ADDR struct_addr)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
                      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;
 
   gdb_byte buf[4];
   int i;
 
@@ -473,17 +534,17 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   /* Store struct value address.  */
   if (struct_return)
     {
   /* 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;
       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...  */
   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.  */
   regcache_cooked_write (regcache, M68K_SP_REGNUM, buf);
 
   /* ...and fake a frame pointer.  */
@@ -497,7 +558,7 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum.  */
 
 static int
 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum.  */
 
 static int
-m68k_dwarf_reg_to_regnum (int num)
+m68k_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int num)
 {
   if (num < 8)
     /* d0..7 */
 {
   if (num < 8)
     /* d0..7 */
@@ -505,15 +566,14 @@ m68k_dwarf_reg_to_regnum (int num)
   else if (num < 16)
     /* a0..7 */
     return (num - 8) + M68K_A0_REGNUM;
   else if (num < 16)
     /* a0..7 */
     return (num - 8) + M68K_A0_REGNUM;
-  else if (num < 24 && gdbarch_tdep (current_gdbarch)->fpregs_present)
+  else if (num < 24 && gdbarch_tdep (gdbarch)->fpregs_present)
     /* fp0..7 */
     return (num - 16) + M68K_FP0_REGNUM;
   else if (num == 25)
     /* pc */
     return M68K_PC_REGNUM;
   else
     /* fp0..7 */
     return (num - 16) + M68K_FP0_REGNUM;
   else if (num == 25)
     /* pc */
     return M68K_PC_REGNUM;
   else
-    return gdbarch_num_regs (current_gdbarch)
-          + gdbarch_num_pseudo_regs (current_gdbarch);
+    return -1;
 }
 
 \f
 }
 
 \f
@@ -565,15 +625,17 @@ m68k_alloc_frame_cache (void)
    Otherwise, return PC.  */
 
 static CORE_ADDR
    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)
 {
                          struct m68k_frame_cache *cache)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int op;
 
   if (pc >= current_pc)
     return current_pc;
 
   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)
     {
 
   if (op == P_LINKW_FP || op == P_LINKL_FP || op == P_PEA_FP)
     {
@@ -583,14 +645,14 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc,
        {
          /* link.w %fp, #-N */
          /* link.w %fp, #0; adda.l #-N, %sp */
        {
          /* 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)
            {
 
          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)
                {
              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;
                }
            }
                  return pc + 10;
                }
            }
@@ -600,7 +662,7 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc,
       else if (op == P_LINKL_FP)
        {
          /* link.l %fp, #-N */
       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
          return pc + 6;
        }
       else
@@ -610,7 +672,7 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc,
 
          if (pc + 2 < 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)
                {
 
              if (op == P_MOVEAL_SP_FP)
                {
@@ -629,7 +691,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)
        {
       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;
          if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
            {
              cache->locals += (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
@@ -642,13 +704,13 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc,
     {
       /* adda.w #-N,%sp */
       /* lea (-N,%sp),%sp */
     {
       /* 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 */
       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;
     }
 
       return pc + 6;
     }
 
@@ -661,9 +723,12 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc,
    smaller.  Otherwise, return PC.  */
 
 static CORE_ADDR
    smaller.  Otherwise, return PC.  */
 
 static CORE_ADDR
-m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc,
+m68k_analyze_register_saves (struct gdbarch *gdbarch, CORE_ADDR pc,
+                            CORE_ADDR current_pc,
                             struct m68k_frame_cache *cache)
 {
                             struct m68k_frame_cache *cache)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
   if (cache->locals >= 0)
     {
       CORE_ADDR offset;
   if (cache->locals >= 0)
     {
       CORE_ADDR offset;
@@ -673,12 +738,12 @@ m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc,
       offset = -4 - cache->locals;
       while (pc < current_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
          if (op == P_FMOVEMX_SP
-             && gdbarch_tdep (current_gdbarch)->fpregs_present)
+             && gdbarch_tdep (gdbarch)->fpregs_present)
            {
              /* fmovem.x REGS,-(%sp) */
            {
              /* 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;
              if ((op & 0xff00) == 0xe000)
                {
                  mask = op & 0xff;
@@ -706,7 +771,7 @@ m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc,
          else if (op == P_MOVEML_SP)
            {
              /* movem.l REGS,-(%sp) */
          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)
              for (i = 0; i < 16; i++, mask >>= 1)
                {
                  if (mask & 1)
@@ -759,22 +824,23 @@ m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc,
    */
 
 static CORE_ADDR
    */
 
 static CORE_ADDR
-m68k_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
-                      struct m68k_frame_cache *cache)
+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;
 
   unsigned int op;
 
-  pc = m68k_analyze_frame_setup (pc, current_pc, cache);
-  pc = m68k_analyze_register_saves (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.  */
   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 */
   if (op == P_LEA_PC_A5)
     {
       /* lea (%pc,N),%a5 */
-      return pc + 6;
+      return pc + 8;
     }
 
   return pc;
     }
 
   return pc;
@@ -783,14 +849,13 @@ m68k_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
 /* Return PC of first real instruction.  */
 
 static CORE_ADDR
 /* Return PC of first real instruction.  */
 
 static CORE_ADDR
-m68k_skip_prologue (CORE_ADDR start_pc)
+m68k_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 {
   struct m68k_frame_cache cache;
   CORE_ADDR pc;
 {
   struct m68k_frame_cache cache;
   CORE_ADDR pc;
-  int op;
 
   cache.locals = -1;
 
   cache.locals = -1;
-  pc = m68k_analyze_prologue (start_pc, (CORE_ADDR) -1, &cache);
+  pc = m68k_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache);
   if (cache.locals < 0)
     return start_pc;
   return pc;
   if (cache.locals < 0)
     return start_pc;
   return pc;
@@ -801,21 +866,23 @@ m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
   gdb_byte buf[8];
 
 {
   gdb_byte buf[8];
 
-  frame_unwind_register (next_frame, PC_REGNUM, buf);
-  return extract_typed_address (buf, builtin_type_void_func_ptr);
+  frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
+  return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
 }
 \f
 /* Normal frames.  */
 
 static struct m68k_frame_cache *
 }
 \f
 /* Normal frames.  */
 
 static struct m68k_frame_cache *
-m68k_frame_cache (struct frame_info *next_frame, void **this_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)
   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;
 
   cache = m68k_alloc_frame_cache ();
   *this_cache = cache;
@@ -829,17 +896,18 @@ m68k_frame_cache (struct frame_info *next_frame, void **this_cache)
      They (usually) share their frame pointer with the frame that was
      in progress when the signal occurred.  */
 
      They (usually) share their frame pointer with the frame that was
      in progress when the signal occurred.  */
 
-  frame_unwind_register (next_frame, M68K_FP_REGNUM, buf);
-  cache->base = extract_unsigned_integer (buf, 4);
+  get_frame_register (this_frame, M68K_FP_REGNUM, buf);
+  cache->base = extract_unsigned_integer (buf, 4, byte_order);
   if (cache->base == 0)
     return cache;
 
   /* For normal frames, %pc is stored at 4(%fp).  */
   cache->saved_regs[M68K_PC_REGNUM] = 4;
 
   if (cache->base == 0)
     return cache;
 
   /* For normal frames, %pc is stored at 4(%fp).  */
   cache->saved_regs[M68K_PC_REGNUM] = 4;
 
-  cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME);
+  cache->pc = get_frame_func (this_frame);
   if (cache->pc != 0)
   if (cache->pc != 0)
-    m68k_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache);
+    m68k_analyze_prologue (get_frame_arch (this_frame), cache->pc,
+                          get_frame_pc (this_frame), cache);
 
   if (cache->locals < 0)
     {
 
   if (cache->locals < 0)
     {
@@ -851,8 +919,9 @@ m68k_frame_cache (struct frame_info *next_frame, void **this_cache)
         frame by looking at the stack pointer.  For truly "frameless"
         functions this might work too.  */
 
         frame by looking at the stack pointer.  For truly "frameless"
         functions this might work too.  */
 
-      frame_unwind_register (next_frame, M68K_SP_REGNUM, buf);
-      cache->base = extract_unsigned_integer (buf, 4) + cache->sp_offset;
+      get_frame_register (this_frame, M68K_SP_REGNUM, buf);
+      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
     }
 
   /* Now that we have the base address for the stack frame we can
@@ -869,10 +938,10 @@ m68k_frame_cache (struct frame_info *next_frame, void **this_cache)
 }
 
 static void
 }
 
 static void
-m68k_frame_this_id (struct frame_info *next_frame, void **this_cache,
+m68k_frame_this_id (struct frame_info *this_frame, void **this_cache,
                    struct frame_id *this_id)
 {
                    struct frame_id *this_id)
 {
-  struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache);
+  struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 
   /* This marks the outermost frame.  */
   if (cache->base == 0)
 
   /* This marks the outermost frame.  */
   if (cache->base == 0)
@@ -882,70 +951,38 @@ m68k_frame_this_id (struct frame_info *next_frame, void **this_cache,
   *this_id = frame_id_build (cache->base + 8, cache->pc);
 }
 
   *this_id = frame_id_build (cache->base + 8, cache->pc);
 }
 
-static void
-m68k_frame_prev_register (struct frame_info *next_frame, void **this_cache,
-                         int regnum, int *optimizedp,
-                         enum lval_type *lvalp, CORE_ADDR *addrp,
-                         int *realnump, gdb_byte *valuep)
+static struct value *
+m68k_frame_prev_register (struct frame_info *this_frame, void **this_cache,
+                         int regnum)
 {
 {
-  struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache);
+  struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 
   gdb_assert (regnum >= 0);
 
   if (regnum == M68K_SP_REGNUM && cache->saved_sp)
 
   gdb_assert (regnum >= 0);
 
   if (regnum == M68K_SP_REGNUM && cache->saved_sp)
-    {
-      *optimizedp = 0;
-      *lvalp = not_lval;
-      *addrp = 0;
-      *realnump = -1;
-      if (valuep)
-       {
-         /* Store the value.  */
-         store_unsigned_integer (valuep, 4, cache->saved_sp);
-       }
-      return;
-    }
+    return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 
   if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1)
 
   if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1)
-    {
-      *optimizedp = 0;
-      *lvalp = lval_memory;
-      *addrp = cache->saved_regs[regnum];
-      *realnump = -1;
-      if (valuep)
-       {
-         /* Read the value in from memory.  */
-         read_memory (*addrp, valuep,
-                      register_size (current_gdbarch, regnum));
-       }
-      return;
-    }
+    return frame_unwind_got_memory (this_frame, regnum,
+                                   cache->saved_regs[regnum]);
 
 
-  *optimizedp = 0;
-  *lvalp = lval_register;
-  *addrp = 0;
-  *realnump = regnum;
-  if (valuep)
-    frame_unwind_register (next_frame, (*realnump), valuep);
+  return frame_unwind_got_register (this_frame, regnum, regnum);
 }
 
 static const struct frame_unwind m68k_frame_unwind =
 {
   NORMAL_FRAME,
 }
 
 static const struct frame_unwind m68k_frame_unwind =
 {
   NORMAL_FRAME,
+  default_frame_unwind_stop_reason,
   m68k_frame_this_id,
   m68k_frame_this_id,
-  m68k_frame_prev_register
+  m68k_frame_prev_register,
+  NULL,
+  default_frame_sniffer
 };
 };
-
-static const struct frame_unwind *
-m68k_frame_sniffer (struct frame_info *next_frame)
-{
-  return &m68k_frame_unwind;
-}
 \f
 static CORE_ADDR
 \f
 static CORE_ADDR
-m68k_frame_base_address (struct frame_info *next_frame, void **this_cache)
+m68k_frame_base_address (struct frame_info *this_frame, void **this_cache)
 {
 {
-  struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache);
+  struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 
   return cache->base;
 }
 
   return cache->base;
 }
@@ -959,30 +996,30 @@ static const struct frame_base m68k_frame_base =
 };
 
 static struct frame_id
 };
 
 static struct frame_id
-m68k_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+m68k_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 {
 {
-  gdb_byte buf[4];
   CORE_ADDR fp;
 
   CORE_ADDR fp;
 
-  frame_unwind_register (next_frame, M68K_FP_REGNUM, buf);
-  fp = extract_unsigned_integer (buf, 4);
+  fp = get_frame_register_unsigned (this_frame, M68K_FP_REGNUM);
 
   /* See the end of m68k_push_dummy_call.  */
 
   /* See the end of m68k_push_dummy_call.  */
-  return frame_id_build (fp + 8, frame_pc_unwind (next_frame));
+  return frame_id_build (fp + 8, get_frame_pc (this_frame));
 }
 \f
 
 /* 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.
 }
 \f
 
 /* 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)
 {
   gdb_byte *buf;
   CORE_ADDR sp, jb_addr;
 
 static int
 m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
 {
   gdb_byte *buf;
   CORE_ADDR sp, jb_addr;
-  struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
+  struct gdbarch *gdbarch = 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)
     {
 
   if (tdep->jb_pc < 0)
     {
@@ -991,27 +1028,37 @@ m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
       return 0;
     }
 
       return 0;
     }
 
-  buf = alloca (gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT);
-  sp = get_frame_register_unsigned (frame, SP_REGNUM);
+  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 */
-                         buf,
-                         gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT))
+  if (target_read_memory (sp + SP_ARG0,        /* Offset of first arg on stack.  */
+                         buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
     return 0;
 
     return 0;
 
-  jb_addr = extract_unsigned_integer (buf, gdbarch_ptr_bit (current_gdbarch)
-                                            / TARGET_CHAR_BIT);
+  jb_addr = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
+                                            / TARGET_CHAR_BIT, byte_order);
 
   if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
 
   if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
-                         gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT))
+                         gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT),
+                         byte_order)
     return 0;
 
     return 0;
 
-  *pc = extract_unsigned_integer (buf, gdbarch_ptr_bit (current_gdbarch)
-                                        / TARGET_CHAR_BIT);
+  *pc = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
+                                        / TARGET_CHAR_BIT, byte_order);
   return 1;
 }
 \f
 
   return 1;
 }
 \f
 
+/* 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
 /* System V Release 4 (SVR4).  */
 
 void
@@ -1029,7 +1076,7 @@ m68k_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 
 /* Function: m68k_gdbarch_init
    Initializer function for the m68k gdbarch vector.
 
 /* 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)
 
 static struct gdbarch *
 m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
@@ -1051,9 +1098,6 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
       feature = tdesc_find_feature (info.target_desc,
                                    "org.gnu.gdb.m68k.core");
 
       feature = tdesc_find_feature (info.target_desc,
                                    "org.gnu.gdb.m68k.core");
-      if (feature != NULL)
-       /* Do nothing.  */
-       ;
 
       if (feature == NULL)
        {
 
       if (feature == NULL)
        {
@@ -1107,16 +1151,16 @@ 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
 
   /* 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)
+  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
     {
       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;
     }
   
        flavour = m68k_coldfire_flavour;
     }
   
@@ -1134,7 +1178,14 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       break;
     }
 
       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;
   gdbarch = gdbarch_alloc (&info, tdep);
   tdep->fpregs_present = has_fp;
   tdep->flavour = flavour;
@@ -1147,7 +1198,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);
 
   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);
 
   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
   set_gdbarch_frame_align (gdbarch, m68k_frame_align);
 
@@ -1156,7 +1207,6 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
     set_gdbarch_decr_pc_after_break (gdbarch, 2);
 
   set_gdbarch_frame_args_skip (gdbarch, 8);
     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);
   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
 
   set_gdbarch_register_type (gdbarch, m68k_register_type);
   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
 
   set_gdbarch_register_type (gdbarch, m68k_register_type);
@@ -1165,7 +1215,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_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);
   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);
@@ -1189,9 +1238,11 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
       tdep->float_return = 0;
     }
 
       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_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.  */
 
 
   /* Disassembler.  */
@@ -1207,11 +1258,11 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   tdep->struct_return = reg_struct_return;
 
   /* Frame unwinder.  */
   tdep->struct_return = reg_struct_return;
 
   /* Frame unwinder.  */
-  set_gdbarch_unwind_dummy_id (gdbarch, m68k_unwind_dummy_id);
+  set_gdbarch_dummy_id (gdbarch, m68k_dummy_id);
   set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc);
 
   /* Hook in the DWARF CFI frame unwinder.  */
   set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc);
 
   /* Hook in the DWARF CFI frame unwinder.  */
-  frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
+  dwarf2_append_unwinders (gdbarch);
 
   frame_base_set_default (gdbarch, &m68k_frame_base);
 
 
   frame_base_set_default (gdbarch, &m68k_frame_base);
 
@@ -1224,19 +1275,19 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   if (tdep->jb_pc >= 0)
     set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target);
 
   if (tdep->jb_pc >= 0)
     set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target);
 
-  frame_unwind_append_sniffer (gdbarch, m68k_frame_sniffer);
+  frame_unwind_append_unwinder (gdbarch, &m68k_frame_unwind);
 
   if (tdesc_data)
 
   if (tdesc_data)
-    tdesc_use_registers (gdbarch, tdesc_data);
+    tdesc_use_registers (gdbarch, info.target_desc, tdesc_data);
 
   return gdbarch;
 }
 
 
 static void
 
   return gdbarch;
 }
 
 
 static void
-m68k_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
+m68k_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
 {
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (tdep == NULL)
     return;
 
   if (tdep == NULL)
     return;
GDB Binutils - Deliverables
This page took 0.037188 seconds and 4 git commands to generate.