Merge GDB 7.5.1

gdb/mips-linux-tdep.c

 /* Target-dependent code for GNU/Linux on MIPS processors.
 
    Copyright (C) 2001-2002, 2004-2012 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
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 22 matching lines @@
 #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"
+#include "gdb_signals.h"
 
 static struct target_so_ops mips_svr4_so_ops;
 
 /* 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.  */
 
 #define MIPS_LINUX_JB_ELEMENT_SIZE 4
@@ skipping 59 matching lines @@
   supply_32bit_reg (regcache, mips_regnum (gdbarch)->hi, regp + EF_HI);
 
   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 the inaccessible zero register with zero.  */
   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);
@@ skipping 105 matching lines @@
 }
 
 /* Likewise, pack one or all floating point registers into an
    elf_fpregset_t.  */
 
 void
 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 *to;
 
   if ((regno >= gdbarch_fp0_regnum (gdbarch))
       && (regno < gdbarch_fp0_regnum (gdbarch) + 32))
     {
       to = (char *) (*fpregsetp + regno - gdbarch_fp0_regnum (gdbarch));
       regcache_raw_collect (regcache, regno, to);
     }
   else if (regno == mips_regnum (gdbarch)->fp_control_status)
     {
       to = (char *) (*fpregsetp + 32);
@@ skipping 102 matching lines @@
 
   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 the inaccessible zero register with zero.  */
   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
 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);
@@ skipping 190 matching lines @@
 static void
 mips64_fill_fpregset_wrapper (const struct regset *regset,
                               const struct regcache *regcache,
                               int regnum, void *gregs, size_t len)
 {
   gdb_assert (len == sizeof (mips64_elf_fpregset_t));
 
   mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *)gregs, regnum);
 }
 
-const struct regset *
+static const struct regset *
 mips_linux_regset_from_core_section (struct gdbarch *gdbarch,
                                      const char *sect_name, size_t sect_size)
 {
   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;
 
   if (strcmp (sect_name, ".reg") == 0)
@@ skipping 267 matching lines @@
 /* The unwinder for o32 signal frames.  The legacy structures look
    like this:
 
    struct sigframe {
      u32 sf_ass[4];            [argument save space for o32]
      u32 sf_code[2];           [signal trampoline or fill]
      struct sigcontext sf_sc;
      sigset_t sf_mask;
    };
 
+   Pre-2.6.12 sigcontext:
+
    struct sigcontext {
         unsigned int       sc_regmask;          [Unused]
         unsigned int       sc_status;
         unsigned long long sc_pc;
         unsigned long long sc_regs[32];
         unsigned long long sc_fpregs[32];
         unsigned int       sc_ownedfp;
         unsigned int       sc_fpc_csr;
         unsigned int       sc_fpc_eir;          [Unused]
         unsigned int       sc_used_math;
         unsigned int       sc_ssflags;          [Unused]
         [Alignment hole of four bytes]
         unsigned long long sc_mdhi;
         unsigned long long sc_mdlo;
 
         unsigned int       sc_cause;            [Unused]
         unsigned int       sc_badvaddr;         [Unused]
 
         unsigned long      sc_sigset[4];        [kernel's sigset_t]
    };
 
+   Post-2.6.12 sigcontext (SmartMIPS/DSP support added):
+
+   struct sigcontext {
+        unsigned int       sc_regmask;          [Unused]
+        unsigned int       sc_status;           [Unused]
+        unsigned long long sc_pc;
+        unsigned long long sc_regs[32];
+        unsigned long long sc_fpregs[32];
+        unsigned int       sc_acx;
+        unsigned int       sc_fpc_csr;
+        unsigned int       sc_fpc_eir;          [Unused]
+        unsigned int       sc_used_math;
+        unsigned int       sc_dsp;
+        [Alignment hole of four bytes]
+        unsigned long long sc_mdhi;
+        unsigned long long sc_mdlo;
+        unsigned long      sc_hi1;
+        unsigned long      sc_lo1;
+        unsigned long      sc_hi2;
+        unsigned long      sc_lo2;
+        unsigned long      sc_hi3;
+        unsigned long      sc_lo3;
+   };
+
    The RT signal frames look like this:
 
    struct rt_sigframe {
      u32 rs_ass[4];            [argument save space for o32]
      u32 rs_code[2]            [signal trampoline or fill]
      struct siginfo rs_info;
      struct ucontext rs_uc;
    };
 
    struct ucontext {
@@ skipping 12 matching lines @@
 #define STACK_T_SIZE                 (3 * 4)
 #define UCONTEXT_SIGCONTEXT_OFFSET   (2 * 4 + STACK_T_SIZE + 4)
 #define RTSIGFRAME_SIGCONTEXT_OFFSET (SIGFRAME_SIGCONTEXT_OFFSET \
                                       + RTSIGFRAME_SIGINFO_SIZE \
                                       + UCONTEXT_SIGCONTEXT_OFFSET)
 
 #define SIGCONTEXT_PC       (1 * 8)
 #define SIGCONTEXT_REGS     (2 * 8)
 #define SIGCONTEXT_FPREGS   (34 * 8)
 #define SIGCONTEXT_FPCSR    (66 * 8 + 4)
+#define SIGCONTEXT_DSPCTL   (68 * 8 + 0)
 #define SIGCONTEXT_HI       (69 * 8)
 #define SIGCONTEXT_LO       (70 * 8)
 #define SIGCONTEXT_CAUSE    (71 * 8 + 0)
 #define SIGCONTEXT_BADVADDR (71 * 8 + 4)
+#define SIGCONTEXT_HI1      (71 * 8 + 0)
+#define SIGCONTEXT_LO1      (71 * 8 + 4)
+#define SIGCONTEXT_HI2      (72 * 8 + 0)
+#define SIGCONTEXT_LO2      (72 * 8 + 4)
+#define SIGCONTEXT_HI3      (73 * 8 + 0)
+#define SIGCONTEXT_LO3      (73 * 8 + 4)
 
 #define SIGCONTEXT_REG_SIZE 8
 
 static void
 mips_linux_o32_sigframe_init (const struct tramp_frame *self,
                               struct frame_info *this_frame,
                               struct trad_frame_cache *this_cache,
                               CORE_ADDR func)
 {
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
-  int ireg, reg_position;
+  int ireg;
   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)
     sigcontext_base = frame_sp + SIGFRAME_SIGCONTEXT_OFFSET;
   else
     sigcontext_base = frame_sp + RTSIGFRAME_SIGCONTEXT_OFFSET;
 
@@ skipping 43 matching lines @@
                                + (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);
+
+  if (regs->dspctl != -1)
+    trad_frame_set_reg_addr (this_cache,
+                             regs->dspctl + gdbarch_num_regs (gdbarch),
+                             sigcontext_base + SIGCONTEXT_DSPCTL);
+
   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);
-  trad_frame_set_reg_addr (this_cache,
-                           regs->badvaddr + gdbarch_num_regs (gdbarch),
-                           sigcontext_base + SIGCONTEXT_BADVADDR);
+
+  if (regs->dspacc != -1)
+    {
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 0 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + SIGCONTEXT_HI1);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 1 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + SIGCONTEXT_LO1);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 2 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + SIGCONTEXT_HI2);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 3 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + SIGCONTEXT_LO2);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 4 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + SIGCONTEXT_HI3);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 5 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + SIGCONTEXT_LO3);
+    }
+  else
+    {
+      trad_frame_set_reg_addr (this_cache,
+                               regs->cause + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + SIGCONTEXT_CAUSE);
+      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.  */
   trad_frame_set_id (this_cache, frame_id_build (frame_sp, func));
 }
 
 /* *INDENT-OFF* */
 /* For N32/N64 things look different.  There is no non-rt signal frame.
 
   struct rt_sigframe_n32 {
     u32 rs_ass[4];                  [ argument save space for o32 ]
@@ skipping 57 matching lines @@
 #define N32_SIGFRAME_SIGCONTEXT_OFFSET  (SIGFRAME_SIGCONTEXT_OFFSET \
                                          + RTSIGFRAME_SIGINFO_SIZE \
                                          + N32_UCONTEXT_SIGCONTEXT_OFFSET)
 #define N64_SIGFRAME_SIGCONTEXT_OFFSET  (SIGFRAME_SIGCONTEXT_OFFSET \
                                          + RTSIGFRAME_SIGINFO_SIZE \
                                          + N64_UCONTEXT_SIGCONTEXT_OFFSET)
 
 #define N64_SIGCONTEXT_REGS     (0 * 8)
 #define N64_SIGCONTEXT_FPREGS   (32 * 8)
 #define N64_SIGCONTEXT_HI       (64 * 8)
+#define N64_SIGCONTEXT_HI1      (65 * 8)
+#define N64_SIGCONTEXT_HI2      (66 * 8)
+#define N64_SIGCONTEXT_HI3      (67 * 8)
 #define N64_SIGCONTEXT_LO       (68 * 8)
+#define N64_SIGCONTEXT_LO1      (69 * 8)
+#define N64_SIGCONTEXT_LO2      (70 * 8)
+#define N64_SIGCONTEXT_LO3      (71 * 8)
 #define N64_SIGCONTEXT_PC       (72 * 8)
-#define N64_SIGCONTEXT_FPCSR    (73 * 8)
+#define N64_SIGCONTEXT_FPCSR    (73 * 8 + 0)
+#define N64_SIGCONTEXT_DSPCTL   (74 * 8 + 0)
 
 #define N64_SIGCONTEXT_REG_SIZE 8
 
 static void
 mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
                                  struct frame_info *this_frame,
                                  struct trad_frame_cache *this_cache,
                                  CORE_ADDR func)
 {
   struct gdbarch *gdbarch = get_frame_arch (this_frame);
-  int ireg, reg_position;
+  int ireg;
   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)
     sigcontext_base = frame_sp + N32_SIGFRAME_SIGCONTEXT_OFFSET;
   else
     sigcontext_base = frame_sp + N64_SIGFRAME_SIGCONTEXT_OFFSET;
 
   if (mips_linux_restart_reg_p (gdbarch))
@@ skipping 17 matching lines @@
                              + ireg * N64_SIGCONTEXT_REG_SIZE);
 
   trad_frame_set_reg_addr (this_cache,
                            regs->pc + gdbarch_num_regs (gdbarch),
                            sigcontext_base + N64_SIGCONTEXT_PC);
 
   trad_frame_set_reg_addr (this_cache,
                            regs->fp_control_status
                            + gdbarch_num_regs (gdbarch),
                            sigcontext_base + N64_SIGCONTEXT_FPCSR);
+
   trad_frame_set_reg_addr (this_cache,
                            regs->hi + gdbarch_num_regs (gdbarch),
                            sigcontext_base + N64_SIGCONTEXT_HI);
   trad_frame_set_reg_addr (this_cache,
                            regs->lo + gdbarch_num_regs (gdbarch),
                            sigcontext_base + N64_SIGCONTEXT_LO);
 
+  if (regs->dspacc != -1)
+    {
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 0 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + N64_SIGCONTEXT_HI1);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 1 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + N64_SIGCONTEXT_LO1);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 2 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + N64_SIGCONTEXT_HI2);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 3 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + N64_SIGCONTEXT_LO2);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 4 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + N64_SIGCONTEXT_HI3);
+      trad_frame_set_reg_addr (this_cache,
+                               regs->dspacc + 5 + gdbarch_num_regs (gdbarch),
+                               sigcontext_base + N64_SIGCONTEXT_LO3);
+    }
+  if (regs->dspctl != -1)
+    trad_frame_set_reg_addr (this_cache,
+                             regs->dspctl + gdbarch_num_regs (gdbarch),
+                             sigcontext_base + N64_SIGCONTEXT_DSPCTL);
+
   /* Choice of the bottom of the sigframe is somewhat arbitrary.  */
   trad_frame_set_id (this_cache, frame_id_build (frame_sp, func));
 }
 
+/* Implement the "write_pc" gdbarch method.  */
+
 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);
+
+  mips_write_pc (regcache, 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)
@@ skipping 53 matching lines @@
 
   /* 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;
 }
 
+/* Translate signals based on MIPS signal values.  
+   Adapted from gdb/common/signals.c.  */
+
+static enum gdb_signal
+mips_gdb_signal_from_target (struct gdbarch *gdbarch, int signo)
+{
+  switch (signo) 
+    {
+    case 0:
+      return GDB_SIGNAL_0;
+    case MIPS_SIGHUP:
+      return GDB_SIGNAL_HUP;
+    case MIPS_SIGINT:
+      return GDB_SIGNAL_INT;
+    case MIPS_SIGQUIT:
+      return GDB_SIGNAL_QUIT;
+    case MIPS_SIGILL:
+      return GDB_SIGNAL_ILL;
+    case MIPS_SIGTRAP:
+      return GDB_SIGNAL_TRAP;
+    case MIPS_SIGABRT:
+      return GDB_SIGNAL_ABRT;
+    case MIPS_SIGEMT:
+      return GDB_SIGNAL_EMT;
+    case MIPS_SIGFPE:
+      return GDB_SIGNAL_FPE;
+    case MIPS_SIGKILL:
+      return GDB_SIGNAL_KILL;
+    case MIPS_SIGBUS:
+      return GDB_SIGNAL_BUS;
+    case MIPS_SIGSEGV:
+      return GDB_SIGNAL_SEGV;
+    case MIPS_SIGSYS:
+      return GDB_SIGNAL_SYS;
+    case MIPS_SIGPIPE:
+      return GDB_SIGNAL_PIPE;
+    case MIPS_SIGALRM:
+      return GDB_SIGNAL_ALRM;
+    case MIPS_SIGTERM:
+      return GDB_SIGNAL_TERM;
+    case MIPS_SIGUSR1:
+      return GDB_SIGNAL_USR1;
+    case MIPS_SIGUSR2:
+      return GDB_SIGNAL_USR2;
+    case MIPS_SIGCHLD:
+      return GDB_SIGNAL_CHLD;
+    case MIPS_SIGPWR:
+      return GDB_SIGNAL_PWR;
+    case MIPS_SIGWINCH:
+      return GDB_SIGNAL_WINCH;
+    case MIPS_SIGURG:
+      return GDB_SIGNAL_URG;
+    case MIPS_SIGPOLL:
+      return GDB_SIGNAL_POLL;
+    case MIPS_SIGSTOP:
+      return GDB_SIGNAL_STOP;
+    case MIPS_SIGTSTP:
+      return GDB_SIGNAL_TSTP;
+    case MIPS_SIGCONT:
+      return GDB_SIGNAL_CONT;
+    case MIPS_SIGTTIN:
+      return GDB_SIGNAL_TTIN;
+    case MIPS_SIGTTOU:
+      return GDB_SIGNAL_TTOU;
+    case MIPS_SIGVTALRM:
+      return GDB_SIGNAL_VTALRM;
+    case MIPS_SIGPROF:
+      return GDB_SIGNAL_PROF;
+    case MIPS_SIGXCPU:
+      return GDB_SIGNAL_XCPU;
+    case MIPS_SIGXFSZ:
+      return GDB_SIGNAL_XFSZ;
+  }
+
+  if (signo >= MIPS_SIGRTMIN && signo <= MIPS_SIGRTMAX)
+    {
+      /* GDB_SIGNAL_REALTIME values are not contiguous, map parts of
+         the MIPS block to the respective GDB_SIGNAL_REALTIME blocks.  */
+      signo -= MIPS_SIGRTMIN;
+      if (signo == 0)
+        return GDB_SIGNAL_REALTIME_32;
+      else if (signo < 32)
+        return ((enum gdb_signal) (signo - 1 + (int) GDB_SIGNAL_REALTIME_33));
+      else
+        return ((enum gdb_signal) (signo - 32 + (int) GDB_SIGNAL_REALTIME_64));
+    }
+
+  return GDB_SIGNAL_UNKNOWN;
+}
+
 /* Initialize one of the GNU/Linux OS ABIs.  */
 
 static void
 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 tdesc_arch_data *tdesc_data = (void *) info.tdep_info;
 
@@ skipping 64 matching lines @@
   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);
 
+  set_gdbarch_gdb_signal_from_target (gdbarch,
+                                      mips_gdb_signal_from_target);
+
   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);
+      set_gdbarch_num_pseudo_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;
 
   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,
                               mips_linux_init_abi);
     }
 }