gdb/
[binutils-gdb.git] / gdb / mips-linux-tdep.c
index 73c6da5ffc61e3113e80f96dee985a3c12d3871c..c78d5d649f1d7be61258384accf961b81b7ef1f9 100644 (file)
@@ -1,12 +1,13 @@
 /* Target-dependent code for GNU/Linux on MIPS processors.
 
 /* Target-dependent code for GNU/Linux on MIPS processors.
 
-   Copyright 2001, 2002, 2004 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+   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,
@@ -15,9 +16,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., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "gdbcore.h"
 
 #include "defs.h"
 #include "gdbcore.h"
 #include "gdb_string.h"
 #include "gdb_assert.h"
 #include "frame.h"
 #include "gdb_string.h"
 #include "gdb_assert.h"
 #include "frame.h"
+#include "regcache.h"
 #include "trad-frame.h"
 #include "tramp-frame.h"
 #include "trad-frame.h"
 #include "tramp-frame.h"
+#include "gdbtypes.h"
+#include "solib.h"
+#include "solib-svr4.h"
+#include "solist.h"
+#include "symtab.h"
+#include "target-descriptions.h"
+#include "regset.h"
+#include "mips-linux-tdep.h"
+#include "glibc-tdep.h"
+#include "linux-tdep.h"
+#include "xml-syscall.h"
 
 
-/* Copied from <asm/elf.h>.  */
-#define ELF_NGREG       45
-#define ELF_NFPREG      33
-
-typedef unsigned char elf_greg_t[4];
-typedef elf_greg_t elf_gregset_t[ELF_NGREG];
-
-typedef unsigned char elf_fpreg_t[8];
-typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];
-
-/* 0 - 31 are integer registers, 32 - 63 are fp registers.  */
-#define FPR_BASE        32
-#define PC              64
-#define CAUSE           65
-#define BADVADDR        66
-#define MMHI            67
-#define MMLO            68
-#define FPC_CSR         69
-#define FPC_EIR         70
-
-#define EF_REG0                        6
-#define EF_REG31               37
-#define EF_LO                  38
-#define EF_HI                  39
-#define EF_CP0_EPC             40
-#define EF_CP0_BADVADDR                41
-#define EF_CP0_STATUS          42
-#define EF_CP0_CAUSE           43
-
-#define EF_SIZE                        180
+static struct target_so_ops mips_svr4_so_ops;
 
 /* Figure out where the longjmp will land.
 
 /* Figure out where the longjmp will land.
-   We expect the first arg to be a pointer to the jmp_buf structure from
-   which we extract the pc (MIPS_LINUX_JB_PC) that we will land at.  The pc
-   is copied into PC.  This routine returns 1 on success.  */
+   We expect the first arg to be a pointer to the jmp_buf structure
+   from which we extract the pc (MIPS_LINUX_JB_PC) that we will land
+   at.  The pc is copied into PC.  This routine returns 1 on
+   success.  */
 
 #define MIPS_LINUX_JB_ELEMENT_SIZE 4
 #define MIPS_LINUX_JB_PC 0
 
 static int
 
 #define MIPS_LINUX_JB_ELEMENT_SIZE 4
 #define MIPS_LINUX_JB_PC 0
 
 static int
-mips_linux_get_longjmp_target (CORE_ADDR *pc)
+mips_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
 {
   CORE_ADDR jb_addr;
 {
   CORE_ADDR jb_addr;
-  char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  char buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
 
 
-  jb_addr = read_register (A0_REGNUM);
+  jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
 
   if (target_read_memory (jb_addr
 
   if (target_read_memory (jb_addr
-                         + MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE,
-                         buf, TARGET_PTR_BIT / TARGET_CHAR_BIT))
+                           + MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE,
+                         buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
     return 0;
 
     return 0;
 
-  *pc = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
+  *pc = extract_unsigned_integer (buf,
+                                 gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT,
+                                 byte_order);
 
   return 1;
 }
 
 /* Transform the bits comprising a 32-bit register to the right size
 
   return 1;
 }
 
 /* Transform the bits comprising a 32-bit register to the right size
-   for supply_register().  This is needed when mips_regsize() is 8.  */
+   for regcache_raw_supply().  This is needed when mips_isa_regsize()
+   is 8.  */
 
 static void
 
 static void
-supply_32bit_reg (int regnum, const void *addr)
+supply_32bit_reg (struct regcache *regcache, int regnum, const void *addr)
 {
 {
-  char buf[MAX_REGISTER_SIZE];
-  store_signed_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum),
-                        extract_signed_integer (addr, 4));
-  supply_register (regnum, buf);
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  gdb_byte buf[MAX_REGISTER_SIZE];
+  store_signed_integer (buf, register_size (gdbarch, regnum), byte_order,
+                        extract_signed_integer (addr, 4, byte_order));
+  regcache_raw_supply (regcache, regnum, buf);
 }
 
 /* Unpack an elf_gregset_t into GDB's register cache.  */
 
 }
 
 /* Unpack an elf_gregset_t into GDB's register cache.  */
 
-void 
-supply_gregset (elf_gregset_t *gregsetp)
+void
+mips_supply_gregset (struct regcache *regcache,
+                    const mips_elf_gregset_t *gregsetp)
 {
   int regi;
 {
   int regi;
-  elf_greg_t *regp = *gregsetp;
+  const mips_elf_greg_t *regp = *gregsetp;
   char zerobuf[MAX_REGISTER_SIZE];
   char zerobuf[MAX_REGISTER_SIZE];
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
   memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
 
   memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
-  for (regi = EF_REG0; regi <= EF_REG31; regi++)
-    supply_32bit_reg ((regi - EF_REG0), (char *)(regp + regi));
+  for (regi = EF_REG0 + 1; regi <= EF_REG31; regi++)
+    supply_32bit_reg (regcache, regi - EF_REG0, regp + regi);
+
+  if (mips_linux_restart_reg_p (gdbarch))
+    supply_32bit_reg (regcache, MIPS_RESTART_REGNUM, regp + EF_REG0);
 
 
-  supply_32bit_reg (mips_regnum (current_gdbarch)->lo,
-                   (char *)(regp + EF_LO));
-  supply_32bit_reg (mips_regnum (current_gdbarch)->hi,
-                   (char *)(regp + EF_HI));
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->lo, regp + EF_LO);
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->hi, regp + EF_HI);
 
 
-  supply_32bit_reg (mips_regnum (current_gdbarch)->pc,
-                   (char *)(regp + EF_CP0_EPC));
-  supply_32bit_reg (mips_regnum (current_gdbarch)->badvaddr,
-                   (char *)(regp + EF_CP0_BADVADDR));
-  supply_32bit_reg (PS_REGNUM, (char *)(regp + EF_CP0_STATUS));
-  supply_32bit_reg (mips_regnum (current_gdbarch)->cause,
-                   (char *)(regp + EF_CP0_CAUSE));
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->pc,
+                   regp + EF_CP0_EPC);
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
+                   regp + EF_CP0_BADVADDR);
+  supply_32bit_reg (regcache, MIPS_PS_REGNUM, regp + EF_CP0_STATUS);
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->cause,
+                   regp + EF_CP0_CAUSE);
 
   /* Fill inaccessible registers with zero.  */
 
   /* Fill inaccessible registers with zero.  */
-  supply_register (UNUSED_REGNUM, zerobuf);
-  for (regi = FIRST_EMBED_REGNUM; regi < LAST_EMBED_REGNUM; regi++)
-    supply_register (regi, zerobuf);
+  regcache_raw_supply (regcache, MIPS_ZERO_REGNUM, zerobuf);
+  regcache_raw_supply (regcache, MIPS_UNUSED_REGNUM, zerobuf);
+  for (regi = MIPS_FIRST_EMBED_REGNUM;
+       regi <= MIPS_LAST_EMBED_REGNUM;
+       regi++)
+    regcache_raw_supply (regcache, regi, zerobuf);
+}
+
+static void
+mips_supply_gregset_wrapper (const struct regset *regset,
+                             struct regcache *regcache,
+                            int regnum, const void *gregs, size_t len)
+{
+  gdb_assert (len == sizeof (mips_elf_gregset_t));
+
+  mips_supply_gregset (regcache, (const mips_elf_gregset_t *)gregs);
 }
 
 /* Pack our registers (or one register) into an elf_gregset_t.  */
 
 void
 }
 
 /* Pack our registers (or one register) into an elf_gregset_t.  */
 
 void
-fill_gregset (elf_gregset_t *gregsetp, int regno)
+mips_fill_gregset (const struct regcache *regcache,
+                  mips_elf_gregset_t *gregsetp, int regno)
 {
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int regaddr, regi;
   int regaddr, regi;
-  elf_greg_t *regp = *gregsetp;
+  mips_elf_greg_t *regp = *gregsetp;
   void *dst;
 
   if (regno == -1)
     {
   void *dst;
 
   if (regno == -1)
     {
-      memset (regp, 0, sizeof (elf_gregset_t));
-      for (regi = 0; regi < 32; regi++)
-        fill_gregset (gregsetp, regi);
-      fill_gregset (gregsetp, mips_regnum (current_gdbarch)->lo);
-      fill_gregset (gregsetp, mips_regnum (current_gdbarch)->hi);
-      fill_gregset (gregsetp, mips_regnum (current_gdbarch)->pc);
-      fill_gregset (gregsetp, mips_regnum (current_gdbarch)->badvaddr);
-      fill_gregset (gregsetp, PS_REGNUM);
-      fill_gregset (gregsetp, mips_regnum (current_gdbarch)->cause);
-
+      memset (regp, 0, sizeof (mips_elf_gregset_t));
+      for (regi = 1; regi < 32; regi++)
+       mips_fill_gregset (regcache, gregsetp, regi);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->badvaddr);
+      mips_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
+      mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->cause);
+      mips_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
       return;
    }
 
       return;
    }
 
-  if (regno < 32)
+  if (regno > 0 && regno < 32)
     {
       dst = regp + regno + EF_REG0;
     {
       dst = regp + regno + EF_REG0;
-      regcache_collect (regno, dst);
+      regcache_raw_collect (regcache, regno, dst);
       return;
     }
 
       return;
     }
 
-  if (regno == mips_regnum (current_gdbarch)->lo)
-    regaddr = EF_LO;
-  else if (regno == mips_regnum (current_gdbarch)->hi)
+  if (regno == mips_regnum (gdbarch)->lo)
+     regaddr = EF_LO;
+  else if (regno == mips_regnum (gdbarch)->hi)
     regaddr = EF_HI;
     regaddr = EF_HI;
-  else if (regno == mips_regnum (current_gdbarch)->pc)
+  else if (regno == mips_regnum (gdbarch)->pc)
     regaddr = EF_CP0_EPC;
     regaddr = EF_CP0_EPC;
-  else if (regno == mips_regnum (current_gdbarch)->badvaddr)
+  else if (regno == mips_regnum (gdbarch)->badvaddr)
     regaddr = EF_CP0_BADVADDR;
     regaddr = EF_CP0_BADVADDR;
-  else if (regno == PS_REGNUM)
+  else if (regno == MIPS_PS_REGNUM)
     regaddr = EF_CP0_STATUS;
     regaddr = EF_CP0_STATUS;
-  else if (regno == mips_regnum (current_gdbarch)->cause)
+  else if (regno == mips_regnum (gdbarch)->cause)
     regaddr = EF_CP0_CAUSE;
     regaddr = EF_CP0_CAUSE;
+  else if (mips_linux_restart_reg_p (gdbarch)
+          && regno == MIPS_RESTART_REGNUM)
+    regaddr = EF_REG0;
   else
     regaddr = -1;
 
   if (regaddr != -1)
     {
       dst = regp + regaddr;
   else
     regaddr = -1;
 
   if (regaddr != -1)
     {
       dst = regp + regaddr;
-      regcache_collect (regno, dst);
+      regcache_raw_collect (regcache, regno, dst);
     }
 }
 
     }
 }
 
+static void
+mips_fill_gregset_wrapper (const struct regset *regset,
+                          const struct regcache *regcache,
+                          int regnum, void *gregs, size_t len)
+{
+  gdb_assert (len == sizeof (mips_elf_gregset_t));
+
+  mips_fill_gregset (regcache, (mips_elf_gregset_t *)gregs, regnum);
+}
+
 /* Likewise, unpack an elf_fpregset_t.  */
 
 void
 /* Likewise, unpack an elf_fpregset_t.  */
 
 void
-supply_fpregset (elf_fpregset_t *fpregsetp)
+mips_supply_fpregset (struct regcache *regcache,
+                     const mips_elf_fpregset_t *fpregsetp)
 {
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int regi;
   char zerobuf[MAX_REGISTER_SIZE];
 
   memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi < 32; regi++)
   int regi;
   char zerobuf[MAX_REGISTER_SIZE];
 
   memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi < 32; regi++)
-    supply_register (FP0_REGNUM + regi,
-                    (char *)(*fpregsetp + regi));
+    regcache_raw_supply (regcache,
+                        gdbarch_fp0_regnum (gdbarch) + regi,
+                        *fpregsetp + regi);
+
+  regcache_raw_supply (regcache,
+                      mips_regnum (gdbarch)->fp_control_status,
+                      *fpregsetp + 32);
+
+  /* FIXME: how can we supply FCRIR?  The ABI doesn't tell us.  */
+  regcache_raw_supply (regcache,
+                      mips_regnum (gdbarch)->fp_implementation_revision,
+                      zerobuf);
+}
 
 
-  supply_register (mips_regnum (current_gdbarch)->fp_control_status,
-                  (char *)(*fpregsetp + 32));
+static void
+mips_supply_fpregset_wrapper (const struct regset *regset,
+                              struct regcache *regcache,
+                             int regnum, const void *gregs, size_t len)
+{
+  gdb_assert (len == sizeof (mips_elf_fpregset_t));
 
 
-  /* FIXME: how can we supply FCRIR?  The ABI doesn't tell us. */
-  supply_register (mips_regnum (current_gdbarch)->fp_implementation_revision,
-                  zerobuf);
+  mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *)gregs);
 }
 
 /* Likewise, pack one or all floating point registers into an
    elf_fpregset_t.  */
 
 void
 }
 
 /* Likewise, pack one or all floating point registers into an
    elf_fpregset_t.  */
 
 void
-fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
+mips_fill_fpregset (const struct regcache *regcache,
+                   mips_elf_fpregset_t *fpregsetp, int regno)
 {
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   char *from, *to;
 
   char *from, *to;
 
-  if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
+  if ((regno >= gdbarch_fp0_regnum (gdbarch))
+      && (regno < gdbarch_fp0_regnum (gdbarch) + 32))
     {
     {
-      from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
-      to = (char *) (*fpregsetp + regno - FP0_REGNUM);
-      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno - FP0_REGNUM));
+      to = (char *) (*fpregsetp + regno - gdbarch_fp0_regnum (gdbarch));
+      regcache_raw_collect (regcache, regno, to);
     }
     }
-  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
+  else if (regno == mips_regnum (gdbarch)->fp_control_status)
     {
     {
-      from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
       to = (char *) (*fpregsetp + 32);
       to = (char *) (*fpregsetp + 32);
-      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno));
+      regcache_raw_collect (regcache, regno, to);
     }
   else if (regno == -1)
     {
       int regi;
 
       for (regi = 0; regi < 32; regi++)
     }
   else if (regno == -1)
     {
       int regi;
 
       for (regi = 0; regi < 32; regi++)
-       fill_fpregset (fpregsetp, FP0_REGNUM + regi);
-      fill_fpregset(fpregsetp, mips_regnum (current_gdbarch)->fp_control_status);
+       mips_fill_fpregset (regcache, fpregsetp,
+                           gdbarch_fp0_regnum (gdbarch) + regi);
+      mips_fill_fpregset (regcache, fpregsetp,
+                         mips_regnum (gdbarch)->fp_control_status);
     }
 }
 
     }
 }
 
-/* Map gdb internal register number to ptrace ``address''.
-   These ``addresses'' are normally defined in <asm/ptrace.h>.  */
-
-static CORE_ADDR
-mips_linux_register_addr (int regno, CORE_ADDR blockend)
+static void
+mips_fill_fpregset_wrapper (const struct regset *regset,
+                           const struct regcache *regcache,
+                           int regnum, void *gregs, size_t len)
 {
 {
-  int regaddr;
-
-  if (regno < 0 || regno >= NUM_REGS)
-    error ("Bogon register number %d.", regno);
-
-  if (regno < 32)
-    regaddr = regno;
-  else if ((regno >= mips_regnum (current_gdbarch)->fp0)
-          && (regno < mips_regnum (current_gdbarch)->fp0 + 32))
-    regaddr = FPR_BASE + (regno - mips_regnum (current_gdbarch)->fp0);
-  else if (regno == mips_regnum (current_gdbarch)->pc)
-    regaddr = PC;
-  else if (regno == mips_regnum (current_gdbarch)->cause)
-    regaddr = CAUSE;
-  else if (regno == mips_regnum (current_gdbarch)->badvaddr)
-    regaddr = BADVADDR;
-  else if (regno == mips_regnum (current_gdbarch)->lo)
-    regaddr = MMLO;
-  else if (regno == mips_regnum (current_gdbarch)->hi)
-    regaddr = MMHI;
-  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
-    regaddr = FPC_CSR;
-  else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
-    regaddr = FPC_EIR;
-  else
-    error ("Unknowable register number %d.", regno);
+  gdb_assert (len == sizeof (mips_elf_fpregset_t));
 
 
-  return regaddr;
-}
-
-
-/* Fetch (and possibly build) an appropriate link_map_offsets
-   structure for native GNU/Linux MIPS targets using the struct offsets
-   defined in link.h (but without actual reference to that file).
-
-   This makes it possible to access GNU/Linux MIPS shared libraries from a
-   GDB that was built on a different host platform (for cross debugging).  */
-
-static struct link_map_offsets *
-mips_linux_svr4_fetch_link_map_offsets (void)
-{ 
-  static struct link_map_offsets lmo;
-  static struct link_map_offsets *lmp = NULL;
-
-  if (lmp == NULL)
-    { 
-      lmp = &lmo;
-
-      lmo.r_debug_size = 8;    /* The actual size is 20 bytes, but
-                                  this is all we need.  */
-      lmo.r_map_offset = 4;
-      lmo.r_map_size   = 4;
-
-      lmo.link_map_size = 20;
-
-      lmo.l_addr_offset = 0;
-      lmo.l_addr_size   = 4;
-
-      lmo.l_name_offset = 4;
-      lmo.l_name_size   = 4;
-
-      lmo.l_next_offset = 12;
-      lmo.l_next_size   = 4;
-
-      lmo.l_prev_offset = 16;
-      lmo.l_prev_size   = 4;
-    }
-
-  return lmp;
+  mips_fill_fpregset (regcache, (mips_elf_fpregset_t *)gregs, regnum);
 }
 
 /* Support for 64-bit ABIs.  */
 
 }
 
 /* Support for 64-bit ABIs.  */
 
-/* Copied from <asm/elf.h>.  */
-#define MIPS64_ELF_NGREG       45
-#define MIPS64_ELF_NFPREG      33
-
-typedef unsigned char mips64_elf_greg_t[8];
-typedef mips64_elf_greg_t mips64_elf_gregset_t[MIPS64_ELF_NGREG];
-
-typedef unsigned char mips64_elf_fpreg_t[8];
-typedef mips64_elf_fpreg_t mips64_elf_fpregset_t[MIPS64_ELF_NFPREG];
-
-/* 0 - 31 are integer registers, 32 - 63 are fp registers.  */
-#define MIPS64_FPR_BASE                 32
-#define MIPS64_PC                       64
-#define MIPS64_CAUSE                    65
-#define MIPS64_BADVADDR                 66
-#define MIPS64_MMHI                     67
-#define MIPS64_MMLO                     68
-#define MIPS64_FPC_CSR                  69
-#define MIPS64_FPC_EIR                  70
-
-#define MIPS64_EF_REG0                  0
-#define MIPS64_EF_REG31                        31
-#define MIPS64_EF_LO                   32
-#define MIPS64_EF_HI                   33
-#define MIPS64_EF_CP0_EPC              34
-#define MIPS64_EF_CP0_BADVADDR         35
-#define MIPS64_EF_CP0_STATUS           36
-#define MIPS64_EF_CP0_CAUSE            37
-
-#define MIPS64_EF_SIZE                 304
-
 /* Figure out where the longjmp will land.
 /* Figure out where the longjmp will land.
-   We expect the first arg to be a pointer to the jmp_buf structure from
-   which we extract the pc (MIPS_LINUX_JB_PC) that we will land at.  The pc
-   is copied into PC.  This routine returns 1 on success.  */
+   We expect the first arg to be a pointer to the jmp_buf structure
+   from which we extract the pc (MIPS_LINUX_JB_PC) that we will land
+   at.  The pc is copied into PC.  This routine returns 1 on
+   success.  */
 
 /* Details about jmp_buf.  */
 
 #define MIPS64_LINUX_JB_PC 0
 
 static int
 
 /* Details about jmp_buf.  */
 
 #define MIPS64_LINUX_JB_PC 0
 
 static int
-mips64_linux_get_longjmp_target (CORE_ADDR *pc)
+mips64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
 {
   CORE_ADDR jb_addr;
 {
   CORE_ADDR jb_addr;
-  void *buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
-  int element_size = TARGET_PTR_BIT == 32 ? 4 : 8;
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  void *buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
+  int element_size = gdbarch_ptr_bit (gdbarch) == 32 ? 4 : 8;
 
 
-  jb_addr = read_register (A0_REGNUM);
+  jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
 
   if (target_read_memory (jb_addr + MIPS64_LINUX_JB_PC * element_size,
 
   if (target_read_memory (jb_addr + MIPS64_LINUX_JB_PC * element_size,
-                         buf, TARGET_PTR_BIT / TARGET_CHAR_BIT))
+                         buf,
+                         gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
     return 0;
 
     return 0;
 
-  *pc = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
+  *pc = extract_unsigned_integer (buf,
+                                 gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT,
+                                 byte_order);
 
   return 1;
 }
 
 
   return 1;
 }
 
-/* Unpack an elf_gregset_t into GDB's register cache.  */
+/* Register set support functions.  These operate on standard 64-bit
+   regsets, but work whether the target is 32-bit or 64-bit.  A 32-bit
+   target will still use the 64-bit format for PTRACE_GETREGS.  */
+
+/* Supply a 64-bit register.  */
 
 
-static void 
-mips64_supply_gregset (mips64_elf_gregset_t *gregsetp)
+static void
+supply_64bit_reg (struct regcache *regcache, int regnum,
+                 const gdb_byte *buf)
+{
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
+      && register_size (gdbarch, regnum) == 4)
+    regcache_raw_supply (regcache, regnum, buf + 4);
+  else
+    regcache_raw_supply (regcache, regnum, buf);
+}
+
+/* Unpack a 64-bit elf_gregset_t into GDB's register cache.  */
+
+void
+mips64_supply_gregset (struct regcache *regcache,
+                      const mips64_elf_gregset_t *gregsetp)
 {
   int regi;
 {
   int regi;
-  mips64_elf_greg_t *regp = *gregsetp;
-  char zerobuf[MAX_REGISTER_SIZE];
+  const mips64_elf_greg_t *regp = *gregsetp;
+  gdb_byte zerobuf[MAX_REGISTER_SIZE];
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
   memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
 
   memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
-  for (regi = MIPS64_EF_REG0; regi <= MIPS64_EF_REG31; regi++)
-    supply_register ((regi - MIPS64_EF_REG0), (char *)(regp + regi));
+  for (regi = MIPS64_EF_REG0 + 1; regi <= MIPS64_EF_REG31; regi++)
+    supply_64bit_reg (regcache, regi - MIPS64_EF_REG0,
+                     (const gdb_byte *)(regp + regi));
+
+  if (mips_linux_restart_reg_p (gdbarch))
+    supply_64bit_reg (regcache, MIPS_RESTART_REGNUM,
+                     (const gdb_byte *)(regp + MIPS64_EF_REG0));
 
 
-  supply_register (mips_regnum (current_gdbarch)->lo,
-                  (char *)(regp + MIPS64_EF_LO));
-  supply_register (mips_regnum (current_gdbarch)->hi,
-                  (char *)(regp + MIPS64_EF_HI));
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->lo,
+                   (const gdb_byte *) (regp + MIPS64_EF_LO));
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->hi,
+                   (const gdb_byte *) (regp + MIPS64_EF_HI));
 
 
-  supply_register (mips_regnum (current_gdbarch)->pc,
-                  (char *)(regp + MIPS64_EF_CP0_EPC));
-  supply_register (mips_regnum (current_gdbarch)->badvaddr,
-                  (char *)(regp + MIPS64_EF_CP0_BADVADDR));
-  supply_register (PS_REGNUM, (char *)(regp + MIPS64_EF_CP0_STATUS));
-  supply_register (mips_regnum (current_gdbarch)->cause,
-                  (char *)(regp + MIPS64_EF_CP0_CAUSE));
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->pc,
+                   (const gdb_byte *) (regp + MIPS64_EF_CP0_EPC));
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
+                   (const gdb_byte *) (regp + MIPS64_EF_CP0_BADVADDR));
+  supply_64bit_reg (regcache, MIPS_PS_REGNUM,
+                   (const gdb_byte *) (regp + MIPS64_EF_CP0_STATUS));
+  supply_64bit_reg (regcache, mips_regnum (gdbarch)->cause,
+                   (const gdb_byte *) (regp + MIPS64_EF_CP0_CAUSE));
 
   /* Fill inaccessible registers with zero.  */
 
   /* Fill inaccessible registers with zero.  */
-  supply_register (UNUSED_REGNUM, zerobuf);
-  for (regi = FIRST_EMBED_REGNUM; regi < LAST_EMBED_REGNUM; regi++)
-    supply_register (regi, zerobuf);
+  regcache_raw_supply (regcache, MIPS_ZERO_REGNUM, zerobuf);
+  regcache_raw_supply (regcache, MIPS_UNUSED_REGNUM, zerobuf);
+  for (regi = MIPS_FIRST_EMBED_REGNUM;
+       regi <= MIPS_LAST_EMBED_REGNUM;
+       regi++)
+    regcache_raw_supply (regcache, regi, zerobuf);
 }
 
 }
 
-/* Pack our registers (or one register) into an elf_gregset_t.  */
-
 static void
 static void
-mips64_fill_gregset (mips64_elf_gregset_t *gregsetp, int regno)
+mips64_supply_gregset_wrapper (const struct regset *regset,
+                               struct regcache *regcache,
+                              int regnum, const void *gregs, size_t len)
+{
+  gdb_assert (len == sizeof (mips64_elf_gregset_t));
+
+  mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *)gregs);
+}
+
+/* Pack our registers (or one register) into a 64-bit elf_gregset_t.  */
+
+void
+mips64_fill_gregset (const struct regcache *regcache,
+                    mips64_elf_gregset_t *gregsetp, int regno)
 {
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   int regaddr, regi;
   mips64_elf_greg_t *regp = *gregsetp;
   int regaddr, regi;
   mips64_elf_greg_t *regp = *gregsetp;
-  void *src, *dst;
+  void *dst;
 
   if (regno == -1)
     {
       memset (regp, 0, sizeof (mips64_elf_gregset_t));
 
   if (regno == -1)
     {
       memset (regp, 0, sizeof (mips64_elf_gregset_t));
-      for (regi = 0; regi < 32; regi++)
-        mips64_fill_gregset (gregsetp, regi);
-      mips64_fill_gregset (gregsetp, mips_regnum (current_gdbarch)->lo);
-      mips64_fill_gregset (gregsetp, mips_regnum (current_gdbarch)->hi);
-      mips64_fill_gregset (gregsetp, mips_regnum (current_gdbarch)->pc);
-      mips64_fill_gregset (gregsetp, mips_regnum (current_gdbarch)->badvaddr);
-      mips64_fill_gregset (gregsetp, PS_REGNUM);
-      mips64_fill_gregset (gregsetp, mips_regnum (current_gdbarch)->cause);
-
+      for (regi = 1; regi < 32; regi++)
+        mips64_fill_gregset (regcache, gregsetp, regi);
+      mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
+      mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
+      mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
+      mips64_fill_gregset (regcache, gregsetp,
+                          mips_regnum (gdbarch)->badvaddr);
+      mips64_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
+      mips64_fill_gregset (regcache, gregsetp,  mips_regnum (gdbarch)->cause);
+      mips64_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
       return;
    }
 
       return;
    }
 
-  if (regno < 32)
-    {
-      dst = regp + regno + MIPS64_EF_REG0;
-      regcache_collect (regno, dst);
-      return;
-    }
-
-  if (regno == mips_regnum (current_gdbarch)->lo)
+  if (regno > 0 && regno < 32)
+    regaddr = regno + MIPS64_EF_REG0;
+  else if (regno == mips_regnum (gdbarch)->lo)
     regaddr = MIPS64_EF_LO;
     regaddr = MIPS64_EF_LO;
-  else if (regno == mips_regnum (current_gdbarch)->hi)
+  else if (regno == mips_regnum (gdbarch)->hi)
     regaddr = MIPS64_EF_HI;
     regaddr = MIPS64_EF_HI;
-  else if (regno == mips_regnum (current_gdbarch)->pc)
+  else if (regno == mips_regnum (gdbarch)->pc)
     regaddr = MIPS64_EF_CP0_EPC;
     regaddr = MIPS64_EF_CP0_EPC;
-  else if (regno == mips_regnum (current_gdbarch)->badvaddr)
+  else if (regno == mips_regnum (gdbarch)->badvaddr)
     regaddr = MIPS64_EF_CP0_BADVADDR;
     regaddr = MIPS64_EF_CP0_BADVADDR;
-  else if (regno == PS_REGNUM)
+  else if (regno == MIPS_PS_REGNUM)
     regaddr = MIPS64_EF_CP0_STATUS;
     regaddr = MIPS64_EF_CP0_STATUS;
-  else if (regno == mips_regnum (current_gdbarch)->cause)
+  else if (regno == mips_regnum (gdbarch)->cause)
     regaddr = MIPS64_EF_CP0_CAUSE;
     regaddr = MIPS64_EF_CP0_CAUSE;
+  else if (mips_linux_restart_reg_p (gdbarch)
+          && regno == MIPS_RESTART_REGNUM)
+    regaddr = MIPS64_EF_REG0;
   else
     regaddr = -1;
 
   if (regaddr != -1)
     {
   else
     regaddr = -1;
 
   if (regaddr != -1)
     {
+      gdb_byte buf[MAX_REGISTER_SIZE];
+      LONGEST val;
+
+      regcache_raw_collect (regcache, regno, buf);
+      val = extract_signed_integer (buf, register_size (gdbarch, regno),
+                                   byte_order);
       dst = regp + regaddr;
       dst = regp + regaddr;
-      regcache_collect (regno, dst);
+      store_signed_integer (dst, 8, byte_order, val);
     }
 }
 
     }
 }
 
+static void
+mips64_fill_gregset_wrapper (const struct regset *regset,
+                            const struct regcache *regcache,
+                            int regnum, void *gregs, size_t len)
+{
+  gdb_assert (len == sizeof (mips64_elf_gregset_t));
+
+  mips64_fill_gregset (regcache, (mips64_elf_gregset_t *)gregs, regnum);
+}
+
 /* Likewise, unpack an elf_fpregset_t.  */
 
 /* Likewise, unpack an elf_fpregset_t.  */
 
-static void
-mips64_supply_fpregset (mips64_elf_fpregset_t *fpregsetp)
+void
+mips64_supply_fpregset (struct regcache *regcache,
+                       const mips64_elf_fpregset_t *fpregsetp)
 {
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int regi;
   int regi;
-  char zerobuf[MAX_REGISTER_SIZE];
 
 
-  memset (zerobuf, 0, MAX_REGISTER_SIZE);
-
-  for (regi = 0; regi < 32; regi++)
-    supply_register (FP0_REGNUM + regi,
-                    (char *)(*fpregsetp + regi));
+  /* See mips_linux_o32_sigframe_init for a description of the
+     peculiar FP register layout.  */
+  if (register_size (gdbarch, gdbarch_fp0_regnum (gdbarch)) == 4)
+    for (regi = 0; regi < 32; regi++)
+      {
+       const gdb_byte *reg_ptr = (const gdb_byte *)(*fpregsetp + (regi & ~1));
+       if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
+         reg_ptr += 4;
+       regcache_raw_supply (regcache,
+                            gdbarch_fp0_regnum (gdbarch) + regi,
+                            reg_ptr);
+      }
+  else
+    for (regi = 0; regi < 32; regi++)
+      regcache_raw_supply (regcache,
+                          gdbarch_fp0_regnum (gdbarch) + regi,
+                          (const char *)(*fpregsetp + regi));
+
+  supply_32bit_reg (regcache, mips_regnum (gdbarch)->fp_control_status,
+                   (const gdb_byte *)(*fpregsetp + 32));
+
+  /* The ABI doesn't tell us how to supply FCRIR, and core dumps don't
+     include it - but the result of PTRACE_GETFPREGS does.  The best we
+     can do is to assume that its value is present.  */
+  supply_32bit_reg (regcache,
+                   mips_regnum (gdbarch)->fp_implementation_revision,
+                   (const gdb_byte *)(*fpregsetp + 32) + 4);
+}
 
 
-  supply_register (mips_regnum (current_gdbarch)->fp_control_status,
-                  (char *)(*fpregsetp + 32));
+static void
+mips64_supply_fpregset_wrapper (const struct regset *regset,
+                                struct regcache *regcache,
+                               int regnum, const void *gregs, size_t len)
+{
+  gdb_assert (len == sizeof (mips64_elf_fpregset_t));
 
 
-  /* FIXME: how can we supply FCRIR?  The ABI doesn't tell us. */
-  supply_register (mips_regnum (current_gdbarch)->fp_implementation_revision,
-                  zerobuf);
+  mips64_supply_fpregset (regcache, (const mips64_elf_fpregset_t *)gregs);
 }
 
 /* Likewise, pack one or all floating point registers into an
    elf_fpregset_t.  */
 
 }
 
 /* Likewise, pack one or all floating point registers into an
    elf_fpregset_t.  */
 
-static void
-mips64_fill_fpregset (mips64_elf_fpregset_t *fpregsetp, int regno)
+void
+mips64_fill_fpregset (const struct regcache *regcache,
+                     mips64_elf_fpregset_t *fpregsetp, int regno)
 {
 {
-  char *from, *to;
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  gdb_byte *to;
 
 
-  if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
+  if ((regno >= gdbarch_fp0_regnum (gdbarch))
+      && (regno < gdbarch_fp0_regnum (gdbarch) + 32))
     {
     {
-      from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
-      to = (char *) (*fpregsetp + regno - FP0_REGNUM);
-      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno - FP0_REGNUM));
+      /* See mips_linux_o32_sigframe_init for a description of the
+        peculiar FP register layout.  */
+      if (register_size (gdbarch, regno) == 4)
+       {
+         int regi = regno - gdbarch_fp0_regnum (gdbarch);
+
+         to = (gdb_byte *) (*fpregsetp + (regi & ~1));
+         if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
+           to += 4;
+         regcache_raw_collect (regcache, regno, to);
+       }
+      else
+       {
+         to = (gdb_byte *) (*fpregsetp + regno
+                            - gdbarch_fp0_regnum (gdbarch));
+         regcache_raw_collect (regcache, regno, to);
+       }
     }
     }
-  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
+  else if (regno == mips_regnum (gdbarch)->fp_control_status)
     {
     {
-      from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno)];
-      to = (char *) (*fpregsetp + 32);
-      memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regno));
+      gdb_byte buf[MAX_REGISTER_SIZE];
+      LONGEST val;
+
+      regcache_raw_collect (regcache, regno, buf);
+      val = extract_signed_integer (buf, register_size (gdbarch, regno),
+                                   byte_order);
+      to = (gdb_byte *) (*fpregsetp + 32);
+      store_signed_integer (to, 4, byte_order, val);
+    }
+  else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
+    {
+      gdb_byte buf[MAX_REGISTER_SIZE];
+      LONGEST val;
+
+      regcache_raw_collect (regcache, regno, buf);
+      val = extract_signed_integer (buf, register_size (gdbarch, regno),
+                                   byte_order);
+      to = (gdb_byte *) (*fpregsetp + 32) + 4;
+      store_signed_integer (to, 4, byte_order, val);
     }
   else if (regno == -1)
     {
       int regi;
 
       for (regi = 0; regi < 32; regi++)
     }
   else if (regno == -1)
     {
       int regi;
 
       for (regi = 0; regi < 32; regi++)
-       mips64_fill_fpregset (fpregsetp, FP0_REGNUM + regi);
-      mips64_fill_fpregset(fpregsetp,
-                          mips_regnum (current_gdbarch)->fp_control_status);
+       mips64_fill_fpregset (regcache, fpregsetp,
+                             gdbarch_fp0_regnum (gdbarch) + regi);
+      mips64_fill_fpregset (regcache, fpregsetp,
+                           mips_regnum (gdbarch)->fp_control_status);
+      mips64_fill_fpregset (regcache, fpregsetp,
+                           (mips_regnum (gdbarch)
+                             ->fp_implementation_revision));
     }
 }
 
     }
 }
 
-
-/* Map gdb internal register number to ptrace ``address''.
-   These ``addresses'' are normally defined in <asm/ptrace.h>.  */
-
-static CORE_ADDR
-mips64_linux_register_addr (int regno, CORE_ADDR blockend)
+static void
+mips64_fill_fpregset_wrapper (const struct regset *regset,
+                             const struct regcache *regcache,
+                             int regnum, void *gregs, size_t len)
 {
 {
-  int regaddr;
-
-  if (regno < 0 || regno >= NUM_REGS)
-    error ("Bogon register number %d.", regno);
-
-  if (regno < 32)
-    regaddr = regno;
-  else if ((regno >= mips_regnum (current_gdbarch)->fp0)
-          && (regno < mips_regnum (current_gdbarch)->fp0 + 32))
-    regaddr = MIPS64_FPR_BASE + (regno - FP0_REGNUM);
-  else if (regno == mips_regnum (current_gdbarch)->pc)
-    regaddr = MIPS64_PC;
-  else if (regno == mips_regnum (current_gdbarch)->cause)
-    regaddr = MIPS64_CAUSE;
-  else if (regno == mips_regnum (current_gdbarch)->badvaddr)
-    regaddr = MIPS64_BADVADDR;
-  else if (regno == mips_regnum (current_gdbarch)->lo)
-    regaddr = MIPS64_MMLO;
-  else if (regno == mips_regnum (current_gdbarch)->hi)
-    regaddr = MIPS64_MMHI;
-  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
-    regaddr = MIPS64_FPC_CSR;
-  else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
-    regaddr = MIPS64_FPC_EIR;
-  else
-    error ("Unknowable register number %d.", regno);
+  gdb_assert (len == sizeof (mips64_elf_fpregset_t));
 
 
-  return regaddr;
+  mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *)gregs, regnum);
 }
 
 }
 
-/*  Use a local version of this function to get the correct types for
-    regsets, until multi-arch core support is ready.  */
-
-static void
-fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
-                     int which, CORE_ADDR reg_addr)
+const struct regset *
+mips_linux_regset_from_core_section (struct gdbarch *gdbarch,
+                                    const char *sect_name, size_t sect_size)
 {
 {
-  elf_gregset_t gregset;
-  elf_fpregset_t fpregset;
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  mips_elf_gregset_t gregset;
+  mips_elf_fpregset_t fpregset;
   mips64_elf_gregset_t gregset64;
   mips64_elf_fpregset_t fpregset64;
 
   mips64_elf_gregset_t gregset64;
   mips64_elf_fpregset_t fpregset64;
 
-  if (which == 0)
+  if (strcmp (sect_name, ".reg") == 0)
     {
     {
-      if (core_reg_size == sizeof (gregset))
+      if (sect_size == sizeof (gregset))
        {
        {
-         memcpy ((char *) &gregset, core_reg_sect, sizeof (gregset));
-         supply_gregset (&gregset);
+         if (tdep->gregset == NULL)
+           tdep->gregset = regset_alloc (gdbarch,
+                                          mips_supply_gregset_wrapper,
+                                         mips_fill_gregset_wrapper);
+         return tdep->gregset;
        }
        }
-      else if (core_reg_size == sizeof (gregset64))
+      else if (sect_size == sizeof (gregset64))
        {
        {
-         memcpy ((char *) &gregset64, core_reg_sect, sizeof (gregset64));
-         mips64_supply_gregset (&gregset64);
+         if (tdep->gregset64 == NULL)
+           tdep->gregset64 = regset_alloc (gdbarch,
+                                            mips64_supply_gregset_wrapper,
+                                           mips64_fill_gregset_wrapper);
+         return tdep->gregset64;
        }
       else
        {
        }
       else
        {
-         warning ("wrong size gregset struct in core file");
+         warning (_("wrong size gregset struct in core file"));
        }
     }
        }
     }
-  else if (which == 2)
+  else if (strcmp (sect_name, ".reg2") == 0)
     {
     {
-      if (core_reg_size == sizeof (fpregset))
+      if (sect_size == sizeof (fpregset))
        {
        {
-         memcpy ((char *) &fpregset, core_reg_sect, sizeof (fpregset));
-         supply_fpregset (&fpregset);
+         if (tdep->fpregset == NULL)
+           tdep->fpregset = regset_alloc (gdbarch,
+                                           mips_supply_fpregset_wrapper,
+                                          mips_fill_fpregset_wrapper);
+         return tdep->fpregset;
        }
        }
-      else if (core_reg_size == sizeof (fpregset64))
+      else if (sect_size == sizeof (fpregset64))
        {
        {
-         memcpy ((char *) &fpregset64, core_reg_sect, sizeof (fpregset64));
-         mips64_supply_fpregset (&fpregset64);
+         if (tdep->fpregset64 == NULL)
+           tdep->fpregset64 = regset_alloc (gdbarch,
+                                             mips64_supply_fpregset_wrapper,
+                                            mips64_fill_fpregset_wrapper);
+         return tdep->fpregset64;
        }
       else
        {
        }
       else
        {
-         warning ("wrong size fpregset struct in core file");
+         warning (_("wrong size fpregset struct in core file"));
        }
     }
        }
     }
-}
-
-/* Register that we are able to handle ELF file formats using standard
-   procfs "regset" structures.  */
-
-static struct core_fns regset_core_fns =
-{
-  bfd_target_elf_flavour,              /* core_flavour */
-  default_check_format,                        /* check_format */
-  default_core_sniffer,                        /* core_sniffer */
-  fetch_core_registers,                        /* core_read_registers */
-  NULL                                 /* next */
-};
-
-/* Fetch (and possibly build) an appropriate link_map_offsets
-   structure for native GNU/Linux MIPS targets using the struct offsets
-   defined in link.h (but without actual reference to that file).
-
-   This makes it possible to access GNU/Linux MIPS shared libraries from a
-   GDB that was built on a different host platform (for cross debugging).  */
-
-static struct link_map_offsets *
-mips64_linux_svr4_fetch_link_map_offsets (void)
-{ 
-  static struct link_map_offsets lmo;
-  static struct link_map_offsets *lmp = NULL;
-
-  if (lmp == NULL)
-    { 
-      lmp = &lmo;
-
-      lmo.r_debug_size = 16;   /* The actual size is 40 bytes, but
-                                  this is all we need.  */
-      lmo.r_map_offset = 8;
-      lmo.r_map_size   = 8;
-
-      lmo.link_map_size = 40;
-
-      lmo.l_addr_offset = 0;
-      lmo.l_addr_size   = 8;
-
-      lmo.l_name_offset = 8;
-      lmo.l_name_size   = 8;
-
-      lmo.l_next_offset = 24;
-      lmo.l_next_size   = 8;
-
-      lmo.l_prev_offset = 32;
-      lmo.l_prev_size   = 8;
-    }
 
 
-  return lmp;
+  return NULL;
 }
 
 }
 
-/* Handle for obtaining pointer to the current register_addr() function
-   for a given architecture.  */
-static struct gdbarch_data *register_addr_data;
-
-CORE_ADDR
-register_addr (int regno, CORE_ADDR blockend)
+static const struct target_desc *
+mips_linux_core_read_description (struct gdbarch *gdbarch,
+                                 struct target_ops *target,
+                                 bfd *abfd)
 {
 {
-  CORE_ADDR (*register_addr_ptr) (int, CORE_ADDR) =
-    gdbarch_data (current_gdbarch, register_addr_data);
+  asection *section = bfd_get_section_by_name (abfd, ".reg");
+  if (! section)
+    return NULL;
 
 
-  gdb_assert (register_addr_ptr != 0);
+  switch (bfd_section_size (abfd, section))
+    {
+    case sizeof (mips_elf_gregset_t):
+      return mips_tdesc_gp32;
 
 
-  return register_addr_ptr (regno, blockend);
-}
+    case sizeof (mips64_elf_gregset_t):
+      return mips_tdesc_gp64;
 
 
-static void
-set_mips_linux_register_addr (struct gdbarch *gdbarch,
-                              CORE_ADDR (*register_addr_ptr) (int, CORE_ADDR))
-{
-  deprecated_set_gdbarch_data (gdbarch, register_addr_data, register_addr_ptr);
+    default:
+      return NULL;
+    }
 }
 
 }
 
-static void *
-init_register_addr_data (struct gdbarch *gdbarch)
-{
-  return 0;
-}
 
 
-/* Check the code at PC for a dynamic linker lazy resolution stub.  Because
-   they aren't in the .plt section, we pattern-match on the code generated
-   by GNU ld.  They look like this:
+/* Check the code at PC for a dynamic linker lazy resolution stub.
+   Because they aren't in the .plt section, we pattern-match on the
+   code generated by GNU ld.  They look like this:
 
    lw t9,0x8010(gp)
    addu t7,ra
    jalr t9,ra
    addiu t8,zero,INDEX
 
 
    lw t9,0x8010(gp)
    addu t7,ra
    jalr t9,ra
    addiu t8,zero,INDEX
 
-   (with the appropriate doubleword instructions for N64).  Also return the
-   dynamic symbol index used in the last instruction.  */
+   (with the appropriate doubleword instructions for N64).  Also
+   return the dynamic symbol index used in the last instruction.  */
 
 static int
 mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name)
 {
   unsigned char buf[28], *p;
   ULONGEST insn, insn1;
 
 static int
 mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name)
 {
   unsigned char buf[28], *p;
   ULONGEST insn, insn1;
-  int n64 = (mips_abi (current_gdbarch) == MIPS_ABI_N64);
+  int n64 = (mips_abi (target_gdbarch) == MIPS_ABI_N64);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 
   read_memory (pc - 12, buf, 28);
 
 
   read_memory (pc - 12, buf, 28);
 
@@ -714,7 +711,7 @@ mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name)
   p = buf + 12;
   while (p >= buf)
     {
   p = buf + 12;
   while (p >= buf)
     {
-      insn = extract_unsigned_integer (p, 4);
+      insn = extract_unsigned_integer (p, 4, byte_order);
       if (insn == insn1)
        break;
       p -= 4;
       if (insn == insn1)
        break;
       p -= 4;
@@ -722,7 +719,7 @@ mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name)
   if (p < buf)
     return 0;
 
   if (p < buf)
     return 0;
 
-  insn = extract_unsigned_integer (p + 4, 4);
+  insn = extract_unsigned_integer (p + 4, 4, byte_order);
   if (n64)
     {
       /* daddu t7,ra */
   if (n64)
     {
       /* daddu t7,ra */
@@ -735,13 +732,13 @@ mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name)
       if (insn != 0x03e07821)
        return 0;
     }
       if (insn != 0x03e07821)
        return 0;
     }
-  
-  insn = extract_unsigned_integer (p + 8, 4);
+
+  insn = extract_unsigned_integer (p + 8, 4, byte_order);
   /* jalr t9,ra */
   if (insn != 0x0320f809)
     return 0;
 
   /* jalr t9,ra */
   if (insn != 0x0320f809)
     return 0;
 
-  insn = extract_unsigned_integer (p + 12, 4);
+  insn = extract_unsigned_integer (p + 12, 4, byte_order);
   if (n64)
     {
       /* daddiu t8,zero,0 */
   if (n64)
     {
       /* daddiu t8,zero,0 */
@@ -758,19 +755,19 @@ mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name)
   return (insn & 0xffff);
 }
 
   return (insn & 0xffff);
 }
 
-/* Return non-zero iff PC belongs to the dynamic linker resolution code
-   or to a stub.  */
+/* Return non-zero iff PC belongs to the dynamic linker resolution
+   code, a PLT entry, or a lazy binding stub.  */
 
 
-int
+static int
 mips_linux_in_dynsym_resolve_code (CORE_ADDR pc)
 {
 mips_linux_in_dynsym_resolve_code (CORE_ADDR pc)
 {
-  /* Check whether PC is in the dynamic linker.  This also checks whether
-     it is in the .plt section, which MIPS does not use.  */
-  if (in_solib_dynsym_resolve_code (pc))
+  /* Check whether PC is in the dynamic linker.  This also checks
+     whether it is in the .plt section, used by non-PIC executables.  */
+  if (svr4_in_dynsym_resolve_code (pc))
     return 1;
 
     return 1;
 
-  /* Pattern match for the stub.  It would be nice if there were a more
-     efficient way to avoid this check.  */
+  /* Pattern match for the stub.  It would be nice if there were a
+     more efficient way to avoid this check.  */
   if (mips_linux_in_dynsym_stub (pc, NULL))
     return 1;
 
   if (mips_linux_in_dynsym_stub (pc, NULL))
     return 1;
 
@@ -781,8 +778,8 @@ mips_linux_in_dynsym_resolve_code (CORE_ADDR pc)
    and glibc_skip_solib_resolver in glibc-tdep.c.  The normal glibc
    implementation of this triggers at "fixup" from the same objfile as
    "_dl_runtime_resolve"; MIPS GNU/Linux can trigger at
    and glibc_skip_solib_resolver in glibc-tdep.c.  The normal glibc
    implementation of this triggers at "fixup" from the same objfile as
    "_dl_runtime_resolve"; MIPS GNU/Linux can trigger at
-   "__dl_runtime_resolve" directly.  An unresolved PLT entry will
-   point to _dl_runtime_resolve, which will first call
+   "__dl_runtime_resolve" directly.  An unresolved lazy binding
+   stub will point to _dl_runtime_resolve, which will first call
    __dl_runtime_resolve, and then pass control to the resolved
    function.  */
 
    __dl_runtime_resolve, and then pass control to the resolved
    function.  */
 
@@ -794,10 +791,10 @@ mips_linux_skip_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
   resolver = lookup_minimal_symbol ("__dl_runtime_resolve", NULL, NULL);
 
   if (resolver && SYMBOL_VALUE_ADDRESS (resolver) == pc)
   resolver = lookup_minimal_symbol ("__dl_runtime_resolve", NULL, NULL);
 
   if (resolver && SYMBOL_VALUE_ADDRESS (resolver) == pc)
-    return frame_pc_unwind (get_current_frame ()); 
+    return frame_unwind_caller_pc (get_current_frame ());
 
 
-  return 0;
-}      
+  return glibc_skip_solib_resolver (gdbarch, pc);
+}
 
 /* Signal trampoline support.  There are four supported layouts for a
    signal frame: o32 sigframe, o32 rt_sigframe, n32 rt_sigframe, and
 
 /* Signal trampoline support.  There are four supported layouts for a
    signal frame: o32 sigframe, o32 rt_sigframe, n32 rt_sigframe, and
@@ -805,12 +802,12 @@ mips_linux_skip_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
    efficient way, but simplest.  First, declare all the unwinders.  */
 
 static void mips_linux_o32_sigframe_init (const struct tramp_frame *self,
    efficient way, but simplest.  First, declare all the unwinders.  */
 
 static void mips_linux_o32_sigframe_init (const struct tramp_frame *self,
-                                         struct frame_info *next_frame,
+                                         struct frame_info *this_frame,
                                          struct trad_frame_cache *this_cache,
                                          CORE_ADDR func);
 
 static void mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
                                          struct trad_frame_cache *this_cache,
                                          CORE_ADDR func);
 
 static void mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
-                                            struct frame_info *next_frame,
+                                            struct frame_info *this_frame,
                                             struct trad_frame_cache *this_cache,
                                             CORE_ADDR func);
 
                                             struct trad_frame_cache *this_cache,
                                             CORE_ADDR func);
 
@@ -829,27 +826,46 @@ static void mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
 #define MIPS_INST_LI_V0_N32_RT_SIGRETURN 0x24020000 + MIPS_NR_N32_rt_sigreturn
 #define MIPS_INST_SYSCALL 0x0000000c
 
 #define MIPS_INST_LI_V0_N32_RT_SIGRETURN 0x24020000 + MIPS_NR_N32_rt_sigreturn
 #define MIPS_INST_SYSCALL 0x0000000c
 
-struct tramp_frame mips_linux_o32_sigframe = {
+static const struct tramp_frame mips_linux_o32_sigframe = {
+  SIGTRAMP_FRAME,
   4,
   4,
-  { MIPS_INST_LI_V0_SIGRETURN, MIPS_INST_SYSCALL, TRAMP_SENTINEL_INSN },
+  {
+    { MIPS_INST_LI_V0_SIGRETURN, -1 },
+    { MIPS_INST_SYSCALL, -1 },
+    { TRAMP_SENTINEL_INSN, -1 }
+  },
   mips_linux_o32_sigframe_init
 };
 
   mips_linux_o32_sigframe_init
 };
 
-struct tramp_frame mips_linux_o32_rt_sigframe = {
+static const struct tramp_frame mips_linux_o32_rt_sigframe = {
+  SIGTRAMP_FRAME,
   4,
   4,
-  { MIPS_INST_LI_V0_RT_SIGRETURN, MIPS_INST_SYSCALL, TRAMP_SENTINEL_INSN },
+  {
+    { MIPS_INST_LI_V0_RT_SIGRETURN, -1 },
+    { MIPS_INST_SYSCALL, -1 },
+    { TRAMP_SENTINEL_INSN, -1 } },
   mips_linux_o32_sigframe_init
 };
 
   mips_linux_o32_sigframe_init
 };
 
-struct tramp_frame mips_linux_n32_rt_sigframe = {
+static const struct tramp_frame mips_linux_n32_rt_sigframe = {
+  SIGTRAMP_FRAME,
   4,
   4,
-  { MIPS_INST_LI_V0_N32_RT_SIGRETURN, MIPS_INST_SYSCALL, TRAMP_SENTINEL_INSN },
+  {
+    { MIPS_INST_LI_V0_N32_RT_SIGRETURN, -1 },
+    { MIPS_INST_SYSCALL, -1 },
+    { TRAMP_SENTINEL_INSN, -1 }
+  },
   mips_linux_n32n64_sigframe_init
 };
 
   mips_linux_n32n64_sigframe_init
 };
 
-struct tramp_frame mips_linux_n64_rt_sigframe = {
+static const struct tramp_frame mips_linux_n64_rt_sigframe = {
+  SIGTRAMP_FRAME,
   4,
   4,
-  { MIPS_INST_LI_V0_N64_RT_SIGRETURN, MIPS_INST_SYSCALL, TRAMP_SENTINEL_INSN },
+  {
+    { MIPS_INST_LI_V0_N64_RT_SIGRETURN, -1 },
+    { MIPS_INST_SYSCALL, -1 },
+    { TRAMP_SENTINEL_INSN, -1 }
+  },
   mips_linux_n32n64_sigframe_init
 };
 
   mips_linux_n32n64_sigframe_init
 };
 
@@ -859,7 +875,7 @@ struct tramp_frame mips_linux_n64_rt_sigframe = {
 
    struct sigframe {
      u32 sf_ass[4];            [argument save space for o32]
 
    struct sigframe {
      u32 sf_ass[4];            [argument save space for o32]
-     u32 sf_code[2];           [signal trampoline]
+     u32 sf_code[2];           [signal trampoline or fill]
      struct sigcontext sf_sc;
      sigset_t sf_mask;
    };
      struct sigcontext sf_sc;
      sigset_t sf_mask;
    };
@@ -889,7 +905,7 @@ struct tramp_frame mips_linux_n64_rt_sigframe = {
 
    struct rt_sigframe {
      u32 rs_ass[4];            [argument save space for o32]
 
    struct rt_sigframe {
      u32 rs_ass[4];            [argument save space for o32]
-     u32 rs_code[2]            [signal trampoline]
+     u32 rs_code[2]            [signal trampoline or fill]
      struct siginfo rs_info;
      struct ucontext rs_uc;
    };
      struct siginfo rs_info;
      struct ucontext rs_uc;
    };
@@ -904,7 +920,6 @@ struct tramp_frame mips_linux_n64_rt_sigframe = {
    };  */
 /* *INDENT-ON* */
 
    };  */
 /* *INDENT-ON* */
 
-#define SIGFRAME_CODE_OFFSET         (4 * 4)
 #define SIGFRAME_SIGCONTEXT_OFFSET   (6 * 4)
 
 #define RTSIGFRAME_SIGINFO_SIZE      128
 #define SIGFRAME_SIGCONTEXT_OFFSET   (6 * 4)
 
 #define RTSIGFRAME_SIGINFO_SIZE      128
@@ -927,58 +942,90 @@ struct tramp_frame mips_linux_n64_rt_sigframe = {
 
 static void
 mips_linux_o32_sigframe_init (const struct tramp_frame *self,
 
 static void
 mips_linux_o32_sigframe_init (const struct tramp_frame *self,
-                             struct frame_info *next_frame,
+                             struct frame_info *this_frame,
                              struct trad_frame_cache *this_cache,
                              CORE_ADDR func)
 {
                              struct trad_frame_cache *this_cache,
                              CORE_ADDR func)
 {
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   int ireg, reg_position;
   int ireg, reg_position;
-  CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET;
-  const struct mips_regnum *regs = mips_regnum (current_gdbarch);
+  CORE_ADDR frame_sp = get_frame_sp (this_frame);
+  CORE_ADDR sigcontext_base;
+  const struct mips_regnum *regs = mips_regnum (gdbarch);
+  CORE_ADDR regs_base;
 
   if (self == &mips_linux_o32_sigframe)
 
   if (self == &mips_linux_o32_sigframe)
-    sigcontext_base += SIGFRAME_SIGCONTEXT_OFFSET;
+    sigcontext_base = frame_sp + SIGFRAME_SIGCONTEXT_OFFSET;
+  else
+    sigcontext_base = frame_sp + RTSIGFRAME_SIGCONTEXT_OFFSET;
+
+  /* I'm not proud of this hack.  Eventually we will have the
+     infrastructure to indicate the size of saved registers on a
+     per-frame basis, but right now we don't; the kernel saves eight
+     bytes but we only want four.  Use regs_base to access any
+     64-bit fields.  */
+  if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
+    regs_base = sigcontext_base + 4;
   else
   else
-    sigcontext_base += RTSIGFRAME_SIGCONTEXT_OFFSET;
-    
-  /* I'm not proud of this hack.  Eventually we will have the infrastructure
-     to indicate the size of saved registers on a per-frame basis, but
-     right now we don't; the kernel saves eight bytes but we only want
-     four.  */
-  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
-    sigcontext_base += 4;
-
-#if 0
-  trad_frame_set_reg_addr (this_cache, ORIG_ZERO_REGNUM + NUM_REGS,
-                          sigcontext_base + SIGCONTEXT_REGS);
-#endif
+    regs_base = sigcontext_base;
+
+  if (mips_linux_restart_reg_p (gdbarch))
+    trad_frame_set_reg_addr (this_cache,
+                            (MIPS_RESTART_REGNUM
+                             + gdbarch_num_regs (gdbarch)),
+                            regs_base + SIGCONTEXT_REGS);
 
   for (ireg = 1; ireg < 32; ireg++)
 
   for (ireg = 1; ireg < 32; ireg++)
-    trad_frame_set_reg_addr (this_cache, ireg + ZERO_REGNUM + NUM_REGS,
-                            sigcontext_base + SIGCONTEXT_REGS
+    trad_frame_set_reg_addr (this_cache,
+                            ireg + MIPS_ZERO_REGNUM
+                              + gdbarch_num_regs (gdbarch),
+                            regs_base + SIGCONTEXT_REGS
                             + ireg * SIGCONTEXT_REG_SIZE);
 
                             + ireg * SIGCONTEXT_REG_SIZE);
 
+  /* The way that floating point registers are saved, unfortunately,
+     depends on the architecture the kernel is built for.  For the r3000 and
+     tx39, four bytes of each register are at the beginning of each of the
+     32 eight byte slots.  For everything else, the registers are saved
+     using double precision; only the even-numbered slots are initialized,
+     and the high bits are the odd-numbered register.  Assume the latter
+     layout, since we can't tell, and it's much more common.  Which bits are
+     the "high" bits depends on endianness.  */
   for (ireg = 0; ireg < 32; ireg++)
   for (ireg = 0; ireg < 32; ireg++)
-    trad_frame_set_reg_addr (this_cache, ireg + regs->fp0 + NUM_REGS,
-                            sigcontext_base + SIGCONTEXT_FPREGS
-                            + ireg * SIGCONTEXT_REG_SIZE);
-
-  trad_frame_set_reg_addr (this_cache, regs->pc + NUM_REGS,
-                          sigcontext_base + SIGCONTEXT_PC);
-
-  trad_frame_set_reg_addr (this_cache, regs->fp_control_status + NUM_REGS,
+    if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (ireg & 1))
+      trad_frame_set_reg_addr (this_cache,
+                              ireg + regs->fp0 +
+                                gdbarch_num_regs (gdbarch),
+                              sigcontext_base + SIGCONTEXT_FPREGS + 4
+                              + (ireg & ~1) * SIGCONTEXT_REG_SIZE);
+    else
+      trad_frame_set_reg_addr (this_cache,
+                              ireg + regs->fp0
+                                + gdbarch_num_regs (gdbarch),
+                              sigcontext_base + SIGCONTEXT_FPREGS
+                              + (ireg & ~1) * SIGCONTEXT_REG_SIZE);
+
+  trad_frame_set_reg_addr (this_cache,
+                          regs->pc + gdbarch_num_regs (gdbarch),
+                          regs_base + SIGCONTEXT_PC);
+
+  trad_frame_set_reg_addr (this_cache,
+                          regs->fp_control_status
+                          + gdbarch_num_regs (gdbarch),
                           sigcontext_base + SIGCONTEXT_FPCSR);
                           sigcontext_base + SIGCONTEXT_FPCSR);
-  trad_frame_set_reg_addr (this_cache, regs->hi + NUM_REGS,
-                          sigcontext_base + SIGCONTEXT_HI);
-  trad_frame_set_reg_addr (this_cache, regs->lo + NUM_REGS,
-                          sigcontext_base + SIGCONTEXT_LO);
-  trad_frame_set_reg_addr (this_cache, regs->cause + NUM_REGS,
+  trad_frame_set_reg_addr (this_cache,
+                          regs->hi + gdbarch_num_regs (gdbarch),
+                          regs_base + SIGCONTEXT_HI);
+  trad_frame_set_reg_addr (this_cache,
+                          regs->lo + gdbarch_num_regs (gdbarch),
+                          regs_base + SIGCONTEXT_LO);
+  trad_frame_set_reg_addr (this_cache,
+                          regs->cause + gdbarch_num_regs (gdbarch),
                           sigcontext_base + SIGCONTEXT_CAUSE);
                           sigcontext_base + SIGCONTEXT_CAUSE);
-  trad_frame_set_reg_addr (this_cache, regs->badvaddr + NUM_REGS,
+  trad_frame_set_reg_addr (this_cache,
+                          regs->badvaddr + gdbarch_num_regs (gdbarch),
                           sigcontext_base + SIGCONTEXT_BADVADDR);
 
   /* Choice of the bottom of the sigframe is somewhat arbitrary.  */
                           sigcontext_base + SIGCONTEXT_BADVADDR);
 
   /* Choice of the bottom of the sigframe is somewhat arbitrary.  */
-  trad_frame_set_id (this_cache,
-                    frame_id_build (func - SIGFRAME_CODE_OFFSET, func));
+  trad_frame_set_id (this_cache, frame_id_build (frame_sp, func));
 }
 
 /* *INDENT-OFF* */
 }
 
 /* *INDENT-OFF* */
@@ -986,7 +1033,7 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
 
   struct rt_sigframe_n32 {
     u32 rs_ass[4];                  [ argument save space for o32 ]
 
   struct rt_sigframe_n32 {
     u32 rs_ass[4];                  [ argument save space for o32 ]
-    u32 rs_code[2];                 [ signal trampoline ]
+    u32 rs_code[2];                 [ signal trampoline or fill ]
     struct siginfo rs_info;
     struct ucontextn32 rs_uc;
   };
     struct siginfo rs_info;
     struct ucontextn32 rs_uc;
   };
@@ -998,8 +1045,8 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
     struct sigcontext   uc_mcontext;
     sigset_t            uc_sigmask;   [ mask last for extensibility ]
   };
     struct sigcontext   uc_mcontext;
     sigset_t            uc_sigmask;   [ mask last for extensibility ]
   };
-                                
-  struct rt_sigframe_n32 {
+
+  struct rt_sigframe {
     u32 rs_ass[4];                  [ argument save space for o32 ]
     u32 rs_code[2];                 [ signal trampoline ]
     struct siginfo rs_info;
     u32 rs_ass[4];                  [ argument save space for o32 ]
     u32 rs_code[2];                 [ signal trampoline ]
     struct siginfo rs_info;
@@ -1020,15 +1067,23 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
     unsigned long long sc_regs[32];
     unsigned long long sc_fpregs[32];
     unsigned long long sc_mdhi;
     unsigned long long sc_regs[32];
     unsigned long long sc_fpregs[32];
     unsigned long long sc_mdhi;
+    unsigned long long sc_hi1;
+    unsigned long long sc_hi2;
+    unsigned long long sc_hi3;
     unsigned long long sc_mdlo;
     unsigned long long sc_mdlo;
+    unsigned long long sc_lo1;
+    unsigned long long sc_lo2;
+    unsigned long long sc_lo3;
     unsigned long long sc_pc;
     unsigned long long sc_pc;
-    unsigned int       sc_status;
     unsigned int       sc_fpc_csr;
     unsigned int       sc_fpc_csr;
-    unsigned int       sc_fpc_eir;
     unsigned int       sc_used_math;
     unsigned int       sc_used_math;
-    unsigned int       sc_cause;
-    unsigned int       sc_badvaddr;
-  };  */
+    unsigned int       sc_dsp;
+    unsigned int       sc_reserved;
+  };
+
+  That is the post-2.6.12 definition of the 64-bit sigcontext; before
+  then, there were no hi1-hi3 or lo1-lo3.  Cause and badvaddr were
+  included too.  */
 /* *INDENT-ON* */
 
 #define N32_STACK_T_SIZE               STACK_T_SIZE
 /* *INDENT-ON* */
 
 #define N32_STACK_T_SIZE               STACK_T_SIZE
@@ -1045,71 +1100,160 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
 #define N64_SIGCONTEXT_REGS     (0 * 8)
 #define N64_SIGCONTEXT_FPREGS   (32 * 8)
 #define N64_SIGCONTEXT_HI       (64 * 8)
 #define N64_SIGCONTEXT_REGS     (0 * 8)
 #define N64_SIGCONTEXT_FPREGS   (32 * 8)
 #define N64_SIGCONTEXT_HI       (64 * 8)
-#define N64_SIGCONTEXT_LO       (65 * 8)
-#define N64_SIGCONTEXT_PC       (66 * 8)
-#define N64_SIGCONTEXT_FPCSR    (67 * 8 + 1 * 4)
-#define N64_SIGCONTEXT_FIR      (67 * 8 + 2 * 4)
-#define N64_SIGCONTEXT_CAUSE    (67 * 8 + 4 * 4)
-#define N64_SIGCONTEXT_BADVADDR (67 * 8 + 5 * 4)
+#define N64_SIGCONTEXT_LO       (68 * 8)
+#define N64_SIGCONTEXT_PC       (72 * 8)
+#define N64_SIGCONTEXT_FPCSR    (73 * 8)
 
 #define N64_SIGCONTEXT_REG_SIZE 8
 
 #define N64_SIGCONTEXT_REG_SIZE 8
-  
+
 static void
 mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
 static void
 mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
-                                struct frame_info *next_frame,
+                                struct frame_info *this_frame,
                                 struct trad_frame_cache *this_cache,
                                 CORE_ADDR func)
 {
                                 struct trad_frame_cache *this_cache,
                                 CORE_ADDR func)
 {
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   int ireg, reg_position;
   int ireg, reg_position;
-  CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET;
-  const struct mips_regnum *regs = mips_regnum (current_gdbarch);
+  CORE_ADDR frame_sp = get_frame_sp (this_frame);
+  CORE_ADDR sigcontext_base;
+  const struct mips_regnum *regs = mips_regnum (gdbarch);
 
   if (self == &mips_linux_n32_rt_sigframe)
 
   if (self == &mips_linux_n32_rt_sigframe)
-    sigcontext_base += N32_SIGFRAME_SIGCONTEXT_OFFSET;
+    sigcontext_base = frame_sp + N32_SIGFRAME_SIGCONTEXT_OFFSET;
   else
   else
-    sigcontext_base += N64_SIGFRAME_SIGCONTEXT_OFFSET;
-    
-#if 0
-  trad_frame_set_reg_addr (this_cache, ORIG_ZERO_REGNUM + NUM_REGS,
-                          sigcontext_base + N64_SIGCONTEXT_REGS);
-#endif
+    sigcontext_base = frame_sp + N64_SIGFRAME_SIGCONTEXT_OFFSET;
+
+  if (mips_linux_restart_reg_p (gdbarch))
+    trad_frame_set_reg_addr (this_cache,
+                            (MIPS_RESTART_REGNUM
+                             + gdbarch_num_regs (gdbarch)),
+                            sigcontext_base + N64_SIGCONTEXT_REGS);
 
   for (ireg = 1; ireg < 32; ireg++)
 
   for (ireg = 1; ireg < 32; ireg++)
-    trad_frame_set_reg_addr (this_cache, ireg + ZERO_REGNUM + NUM_REGS,
+    trad_frame_set_reg_addr (this_cache,
+                            ireg + MIPS_ZERO_REGNUM
+                            + gdbarch_num_regs (gdbarch),
                             sigcontext_base + N64_SIGCONTEXT_REGS
                             + ireg * N64_SIGCONTEXT_REG_SIZE);
 
   for (ireg = 0; ireg < 32; ireg++)
                             sigcontext_base + N64_SIGCONTEXT_REGS
                             + ireg * N64_SIGCONTEXT_REG_SIZE);
 
   for (ireg = 0; ireg < 32; ireg++)
-    trad_frame_set_reg_addr (this_cache, ireg + regs->fp0 + NUM_REGS,
+    trad_frame_set_reg_addr (this_cache,
+                            ireg + regs->fp0
+                            + gdbarch_num_regs (gdbarch),
                             sigcontext_base + N64_SIGCONTEXT_FPREGS
                             + ireg * N64_SIGCONTEXT_REG_SIZE);
 
                             sigcontext_base + N64_SIGCONTEXT_FPREGS
                             + ireg * N64_SIGCONTEXT_REG_SIZE);
 
-  trad_frame_set_reg_addr (this_cache, regs->pc + NUM_REGS,
+  trad_frame_set_reg_addr (this_cache,
+                          regs->pc + gdbarch_num_regs (gdbarch),
                           sigcontext_base + N64_SIGCONTEXT_PC);
 
                           sigcontext_base + N64_SIGCONTEXT_PC);
 
-  trad_frame_set_reg_addr (this_cache, regs->fp_control_status + NUM_REGS,
+  trad_frame_set_reg_addr (this_cache,
+                          regs->fp_control_status
+                          + gdbarch_num_regs (gdbarch),
                           sigcontext_base + N64_SIGCONTEXT_FPCSR);
                           sigcontext_base + N64_SIGCONTEXT_FPCSR);
-  trad_frame_set_reg_addr (this_cache, regs->hi + NUM_REGS,
+  trad_frame_set_reg_addr (this_cache,
+                          regs->hi + gdbarch_num_regs (gdbarch),
                           sigcontext_base + N64_SIGCONTEXT_HI);
                           sigcontext_base + N64_SIGCONTEXT_HI);
-  trad_frame_set_reg_addr (this_cache, regs->lo + NUM_REGS,
+  trad_frame_set_reg_addr (this_cache,
+                          regs->lo + gdbarch_num_regs (gdbarch),
                           sigcontext_base + N64_SIGCONTEXT_LO);
                           sigcontext_base + N64_SIGCONTEXT_LO);
-  trad_frame_set_reg_addr (this_cache, regs->cause + NUM_REGS,
-                          sigcontext_base + N64_SIGCONTEXT_CAUSE);
-  trad_frame_set_reg_addr (this_cache, regs->badvaddr + NUM_REGS,
-                          sigcontext_base + N64_SIGCONTEXT_BADVADDR);
 
   /* Choice of the bottom of the sigframe is somewhat arbitrary.  */
 
   /* Choice of the bottom of the sigframe is somewhat arbitrary.  */
-  trad_frame_set_id (this_cache,
-                    frame_id_build (func - SIGFRAME_CODE_OFFSET, func));
+  trad_frame_set_id (this_cache, frame_id_build (frame_sp, func));
+}
+
+static void
+mips_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
+{
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch), pc);
+
+  /* Clear the syscall restart flag.  */
+  if (mips_linux_restart_reg_p (gdbarch))
+    regcache_cooked_write_unsigned (regcache, MIPS_RESTART_REGNUM, 0);
+}
+
+/* Return 1 if MIPS_RESTART_REGNUM is usable.  */
+
+int
+mips_linux_restart_reg_p (struct gdbarch *gdbarch)
+{
+  /* If we do not have a target description with registers, then
+     MIPS_RESTART_REGNUM will not be included in the register set.  */
+  if (!tdesc_has_registers (gdbarch_target_desc (gdbarch)))
+    return 0;
+
+  /* If we do, then MIPS_RESTART_REGNUM is safe to check; it will
+     either be GPR-sized or missing.  */
+  return register_size (gdbarch, MIPS_RESTART_REGNUM) > 0;
+}
+
+/* When FRAME is at a syscall instruction, return the PC of the next
+   instruction to be executed.  */
+
+static CORE_ADDR
+mips_linux_syscall_next_pc (struct frame_info *frame)
+{
+  CORE_ADDR pc = get_frame_pc (frame);
+  ULONGEST v0 = get_frame_register_unsigned (frame, MIPS_V0_REGNUM);
+
+  /* If we are about to make a sigreturn syscall, use the unwinder to
+     decode the signal frame.  */
+  if (v0 == MIPS_NR_sigreturn
+      || v0 == MIPS_NR_rt_sigreturn
+      || v0 == MIPS_NR_N64_rt_sigreturn
+      || v0 == MIPS_NR_N32_rt_sigreturn)
+    return frame_unwind_caller_pc (get_current_frame ());
+
+  return pc + 4;
+}
+
+/* Return the current system call's number present in the
+   v0 register.  When the function fails, it returns -1.  */
+
+static LONGEST
+mips_linux_get_syscall_number (struct gdbarch *gdbarch,
+                              ptid_t ptid)
+{
+  struct regcache *regcache = get_thread_regcache (ptid);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  int regsize = register_size (gdbarch, MIPS_V0_REGNUM);
+  /* The content of a register */
+  gdb_byte buf[8];
+  /* The result */
+  LONGEST ret;
+
+  /* Make sure we're in a known ABI */
+  gdb_assert (tdep->mips_abi == MIPS_ABI_O32
+             || tdep->mips_abi == MIPS_ABI_N32
+             || tdep->mips_abi == MIPS_ABI_N64);
+
+  gdb_assert (regsize <= sizeof (buf));
+
+  /* Getting the system call number from the register.
+     syscall number is in v0 or $2.  */
+  regcache_cooked_read (regcache, MIPS_V0_REGNUM, buf);
+
+  ret = extract_signed_integer (buf, regsize, byte_order);
+
+  return ret;
 }
 
 /* Initialize one of the GNU/Linux OS ABIs.  */
 
 static void
 }
 
 /* Initialize one of the GNU/Linux OS ABIs.  */
 
 static void
-mips_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
+mips_linux_init_abi (struct gdbarch_info info,
+                    struct gdbarch *gdbarch)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   enum mips_abi abi = mips_abi (gdbarch);
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   enum mips_abi abi = mips_abi (gdbarch);
+  struct tdesc_arch_data *tdesc_data = (void *) info.tdep_info;
+
+  linux_init_abi (info, gdbarch);
+
+  /* Get the syscall number from the arch's register.  */
+  set_gdbarch_get_syscall_number (gdbarch, mips_linux_get_syscall_number);
 
   switch (abi)
     {
 
   switch (abi)
     {
@@ -1117,54 +1261,104 @@ mips_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
        set_gdbarch_get_longjmp_target (gdbarch,
                                        mips_linux_get_longjmp_target);
        set_solib_svr4_fetch_link_map_offsets
        set_gdbarch_get_longjmp_target (gdbarch,
                                        mips_linux_get_longjmp_target);
        set_solib_svr4_fetch_link_map_offsets
-         (gdbarch, mips_linux_svr4_fetch_link_map_offsets);
-       set_mips_linux_register_addr (gdbarch, mips_linux_register_addr);
+         (gdbarch, svr4_ilp32_fetch_link_map_offsets);
        tramp_frame_prepend_unwinder (gdbarch, &mips_linux_o32_sigframe);
        tramp_frame_prepend_unwinder (gdbarch, &mips_linux_o32_rt_sigframe);
        tramp_frame_prepend_unwinder (gdbarch, &mips_linux_o32_sigframe);
        tramp_frame_prepend_unwinder (gdbarch, &mips_linux_o32_rt_sigframe);
+       set_xml_syscall_file_name ("syscalls/mips-o32-linux.xml");
        break;
       case MIPS_ABI_N32:
        set_gdbarch_get_longjmp_target (gdbarch,
                                        mips_linux_get_longjmp_target);
        set_solib_svr4_fetch_link_map_offsets
        break;
       case MIPS_ABI_N32:
        set_gdbarch_get_longjmp_target (gdbarch,
                                        mips_linux_get_longjmp_target);
        set_solib_svr4_fetch_link_map_offsets
-         (gdbarch, mips_linux_svr4_fetch_link_map_offsets);
-       set_mips_linux_register_addr (gdbarch, mips64_linux_register_addr);
+         (gdbarch, svr4_ilp32_fetch_link_map_offsets);
+       set_gdbarch_long_double_bit (gdbarch, 128);
+       /* These floatformats should probably be renamed.  MIPS uses
+          the same 128-bit IEEE floating point format that IA-64 uses,
+          except that the quiet/signalling NaN bit is reversed (GDB
+          does not distinguish between quiet and signalling NaNs).  */
+       set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
        tramp_frame_prepend_unwinder (gdbarch, &mips_linux_n32_rt_sigframe);
        tramp_frame_prepend_unwinder (gdbarch, &mips_linux_n32_rt_sigframe);
+       set_xml_syscall_file_name ("syscalls/mips-n32-linux.xml");
        break;
       case MIPS_ABI_N64:
        set_gdbarch_get_longjmp_target (gdbarch,
                                        mips64_linux_get_longjmp_target);
        set_solib_svr4_fetch_link_map_offsets
        break;
       case MIPS_ABI_N64:
        set_gdbarch_get_longjmp_target (gdbarch,
                                        mips64_linux_get_longjmp_target);
        set_solib_svr4_fetch_link_map_offsets
-         (gdbarch, mips64_linux_svr4_fetch_link_map_offsets);
-       set_mips_linux_register_addr (gdbarch, mips64_linux_register_addr);
+         (gdbarch, svr4_lp64_fetch_link_map_offsets);
+       set_gdbarch_long_double_bit (gdbarch, 128);
+       /* These floatformats should probably be renamed.  MIPS uses
+          the same 128-bit IEEE floating point format that IA-64 uses,
+          except that the quiet/signalling NaN bit is reversed (GDB
+          does not distinguish between quiet and signalling NaNs).  */
+       set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
        tramp_frame_prepend_unwinder (gdbarch, &mips_linux_n64_rt_sigframe);
        tramp_frame_prepend_unwinder (gdbarch, &mips_linux_n64_rt_sigframe);
+       set_xml_syscall_file_name ("syscalls/mips-n64-linux.xml");
        break;
       default:
        break;
       default:
-       internal_error (__FILE__, __LINE__, "can't handle ABI");
        break;
     }
 
   set_gdbarch_skip_solib_resolver (gdbarch, mips_linux_skip_resolver);
 
        break;
     }
 
   set_gdbarch_skip_solib_resolver (gdbarch, mips_linux_skip_resolver);
 
-  /* This overrides the MIPS16 stub support from mips-tdep.  But no
-     one uses MIPS16 on GNU/Linux yet, so this isn't much of a loss.  */
-  set_gdbarch_in_solib_call_trampoline (gdbarch, mips_linux_in_dynsym_stub);
+  set_gdbarch_software_single_step (gdbarch, mips_software_single_step);
+
+  /* Enable TLS support.  */
+  set_gdbarch_fetch_tls_load_module_address (gdbarch,
+                                             svr4_fetch_objfile_link_map);
+
+  /* Initialize this lazily, to avoid an initialization order
+     dependency on solib-svr4.c's _initialize routine.  */
+  if (mips_svr4_so_ops.in_dynsym_resolve_code == NULL)
+    {
+      mips_svr4_so_ops = svr4_so_ops;
+      mips_svr4_so_ops.in_dynsym_resolve_code
+       = mips_linux_in_dynsym_resolve_code;
+    }
+  set_solib_ops (gdbarch, &mips_svr4_so_ops);
+
+  set_gdbarch_write_pc (gdbarch, mips_linux_write_pc);
+
+  set_gdbarch_core_read_description (gdbarch,
+                                    mips_linux_core_read_description);
+
+  set_gdbarch_regset_from_core_section (gdbarch,
+                                       mips_linux_regset_from_core_section);
+
+  tdep->syscall_next_pc = mips_linux_syscall_next_pc;
+
+  if (tdesc_data)
+    {
+      const struct tdesc_feature *feature;
+
+      /* If we have target-described registers, then we can safely
+        reserve a number for MIPS_RESTART_REGNUM (whether it is
+        described or not).  */
+      gdb_assert (gdbarch_num_regs (gdbarch) <= MIPS_RESTART_REGNUM);
+      set_gdbarch_num_regs (gdbarch, MIPS_RESTART_REGNUM + 1);
+
+      /* If it's present, then assign it to the reserved number.  */
+      feature = tdesc_find_feature (info.target_desc,
+                                   "org.gnu.gdb.mips.linux");
+      if (feature != NULL)
+       tdesc_numbered_register (feature, tdesc_data, MIPS_RESTART_REGNUM,
+                                "restart");
+    }
 }
 
 }
 
+/* Provide a prototype to silence -Wmissing-prototypes.  */
+extern initialize_file_ftype _initialize_mips_linux_tdep;
+
 void
 _initialize_mips_linux_tdep (void)
 {
   const struct bfd_arch_info *arch_info;
 
 void
 _initialize_mips_linux_tdep (void)
 {
   const struct bfd_arch_info *arch_info;
 
-  register_addr_data =
-    gdbarch_data_register_post_init (init_register_addr_data);
-
   for (arch_info = bfd_lookup_arch (bfd_arch_mips, 0);
        arch_info != NULL;
        arch_info = arch_info->next)
     {
   for (arch_info = bfd_lookup_arch (bfd_arch_mips, 0);
        arch_info != NULL;
        arch_info = arch_info->next)
     {
-      gdbarch_register_osabi (bfd_arch_mips, arch_info->mach, GDB_OSABI_LINUX,
+      gdbarch_register_osabi (bfd_arch_mips, arch_info->mach,
+                             GDB_OSABI_LINUX,
                              mips_linux_init_abi);
     }
                              mips_linux_init_abi);
     }
-
-  deprecated_add_core_fns (&regset_core_fns);
 }
 }