gdb/gdbserver/spu-low.c

   1 /* Low level interface to SPUs, for the remote server for GDB.
   2    Copyright (C) 2006-2012 Free Software Foundation, Inc.
   3
   4    Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "server.h"
  22
  23 #include <sys/wait.h>
  24 #include <stdio.h>
  25 #include <sys/ptrace.h>
  26 #include <fcntl.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31 #include <sys/syscall.h>
  32
  33 /* Some older glibc versions do not define this.  */
  34 #ifndef __WNOTHREAD
  35 #define __WNOTHREAD     0x20000000      /* Don't wait on children of other
  36                                            threads in this group */
  37 #endif
  38
  39 #define PTRACE_TYPE_RET long
  40 #define PTRACE_TYPE_ARG3 long
  41
  42 /* Number of registers.  */
  43 #define SPU_NUM_REGS         130
  44 #define SPU_NUM_CORE_REGS    128
  45
  46 /* Special registers.  */
  47 #define SPU_ID_REGNUM        128
  48 #define SPU_PC_REGNUM        129
  49
  50 /* PPU side system calls.  */
  51 #define INSTR_SC        0x44000002
  52 #define NR_spu_run      0x0116
  53
  54 /* Get current thread ID (Linux task ID).  */
  55 #define current_ptid ((struct inferior_list_entry *)current_inferior)->id
  56
  57 /* These are used in remote-utils.c.  */
  58 int using_threads = 0;
  59
  60 /* Defined in auto-generated file reg-spu.c.  */
  61 void init_registers_spu (void);
  62
  63
  64 /* Fetch PPU register REGNO.  */
  65 static CORE_ADDR
  66 fetch_ppc_register (int regno)
  67 {
  68   PTRACE_TYPE_RET res;
  69
  70   int tid = ptid_get_lwp (current_ptid);
  71
  72 #ifndef __powerpc64__
  73   /* If running as a 32-bit process on a 64-bit system, we attempt
  74      to get the full 64-bit register content of the target process.
  75      If the PPC special ptrace call fails, we're on a 32-bit system;
  76      just fall through to the regular ptrace call in that case.  */
  77   {
  78     char buf[8];
  79
  80     errno = 0;
  81     ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  82             (PTRACE_TYPE_ARG3) (regno * 8), buf);
  83     if (errno == 0)
  84       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  85               (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
  86     if (errno == 0)
  87       return (CORE_ADDR) *(unsigned long long *)buf;
  88   }
  89 #endif
  90
  91   errno = 0;
  92   res = ptrace (PT_READ_U, tid,
  93                 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
  94   if (errno != 0)
  95     {
  96       char mess[128];
  97       sprintf (mess, "reading PPC register #%d", regno);
  98       perror_with_name (mess);
  99     }
 100
 101   return (CORE_ADDR) (unsigned long) res;
 102 }
 103
 104 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
 105 static int
 106 fetch_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
 107 {
 108   errno = 0;
 109
 110 #ifndef __powerpc64__
 111   if (memaddr >> 32)
 112     {
 113       unsigned long long addr_8 = (unsigned long long) memaddr;
 114       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 115     }
 116   else
 117 #endif
 118     *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
 119
 120   return errno;
 121 }
 122
 123 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
 124 static int
 125 store_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
 126 {
 127   errno = 0;
 128
 129 #ifndef __powerpc64__
 130   if (memaddr >> 32)
 131     {
 132       unsigned long long addr_8 = (unsigned long long) memaddr;
 133       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 134     }
 135   else
 136 #endif
 137     ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
 138
 139   return errno;
 140 }
 141
 142 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
 143 static int
 144 fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
 145 {
 146   int i, ret;
 147
 148   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 149   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 150                / sizeof (PTRACE_TYPE_RET));
 151   PTRACE_TYPE_RET *buffer;
 152
 153   int tid = ptid_get_lwp (current_ptid);
 154
 155   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 156   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 157     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
 158       return ret;
 159
 160   memcpy (myaddr,
 161           (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 162           len);
 163
 164   return 0;
 165 }
 166
 167 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
 168 static int
 169 store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
 170 {
 171   int i, ret;
 172
 173   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 174   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 175                / sizeof (PTRACE_TYPE_RET));
 176   PTRACE_TYPE_RET *buffer;
 177
 178   int tid = ptid_get_lwp (current_ptid);
 179
 180   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 181
 182   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 183     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
 184       return ret;
 185
 186   if (count > 1)
 187     if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
 188                                                * sizeof (PTRACE_TYPE_RET),
 189                                    &buffer[count - 1])) != 0)
 190       return ret;
 191
 192   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 193           myaddr, len);
 194
 195   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 196     if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
 197       return ret;
 198
 199   return 0;
 200 }
 201
 202
 203 /* If the PPU thread is currently stopped on a spu_run system call,
 204    return to FD and ADDR the file handle and NPC parameter address
 205    used with the system call.  Return non-zero if successful.  */
 206 static int
 207 parse_spufs_run (int *fd, CORE_ADDR *addr)
 208 {
 209   unsigned int insn;
 210   CORE_ADDR pc = fetch_ppc_register (32);  /* nip */
 211
 212   /* Fetch instruction preceding current NIP.  */
 213   if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
 214     return 0;
 215   /* It should be a "sc" instruction.  */
 216   if (insn != INSTR_SC)
 217     return 0;
 218   /* System call number should be NR_spu_run.  */
 219   if (fetch_ppc_register (0) != NR_spu_run)
 220     return 0;
 221
 222   /* Register 3 contains fd, register 4 the NPC param pointer.  */
 223   *fd = fetch_ppc_register (34);  /* orig_gpr3 */
 224   *addr = fetch_ppc_register (4);
 225   return 1;
 226 }
 227
 228
 229 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
 230    using the /proc file system.  */
 231 static int
 232 spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
 233                    const unsigned char *writebuf,
 234                    CORE_ADDR offset, int len)
 235 {
 236   char buf[128];
 237   int fd = 0;
 238   int ret = -1;
 239
 240   if (!annex)
 241     return 0;
 242
 243   sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
 244   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
 245   if (fd <= 0)
 246     return -1;
 247
 248   if (offset != 0
 249       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
 250     {
 251       close (fd);
 252       return 0;
 253     }
 254
 255   if (writebuf)
 256     ret = write (fd, writebuf, (size_t) len);
 257   else if (readbuf)
 258     ret = read (fd, readbuf, (size_t) len);
 259
 260   close (fd);
 261   return ret;
 262 }
 263
 264
 265 /* Start an inferior process and returns its pid.
 266    ALLARGS is a vector of program-name and args. */
 267 static int
 268 spu_create_inferior (char *program, char **allargs)
 269 {
 270   int pid;
 271   ptid_t ptid;
 272
 273   pid = fork ();
 274   if (pid < 0)
 275     perror_with_name ("fork");
 276
 277   if (pid == 0)
 278     {
 279       ptrace (PTRACE_TRACEME, 0, 0, 0);
 280
 281       setpgid (0, 0);
 282
 283       execv (program, allargs);
 284       if (errno == ENOENT)
 285         execvp (program, allargs);
 286
 287       fprintf (stderr, "Cannot exec %s: %s.\n", program,
 288                strerror (errno));
 289       fflush (stderr);
 290       _exit (0177);
 291     }
 292
 293   add_process (pid, 0);
 294
 295   ptid = ptid_build (pid, pid, 0);
 296   add_thread (ptid, NULL);
 297   return pid;
 298 }
 299
 300 /* Attach to an inferior process.  */
 301 int
 302 spu_attach (unsigned long  pid)
 303 {
 304   ptid_t ptid;
 305
 306   if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
 307     {
 308       fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
 309                strerror (errno), errno);
 310       fflush (stderr);
 311       _exit (0177);
 312     }
 313
 314   add_process (pid, 1);
 315   ptid = ptid_build (pid, pid, 0);
 316   add_thread (ptid, NULL);
 317   return 0;
 318 }
 319
 320 /* Kill the inferior process.  */
 321 static int
 322 spu_kill (int pid)
 323 {
 324   int status, ret;
 325   struct process_info *process = find_process_pid (pid);
 326   if (process == NULL)
 327     return -1;
 328
 329   ptrace (PTRACE_KILL, pid, 0, 0);
 330
 331   do {
 332     ret = waitpid (pid, &status, 0);
 333     if (WIFEXITED (status) || WIFSIGNALED (status))
 334       break;
 335   } while (ret != -1 || errno != ECHILD);
 336
 337   clear_inferiors ();
 338   remove_process (process);
 339   return 0;
 340 }
 341
 342 /* Detach from inferior process.  */
 343 static int
 344 spu_detach (int pid)
 345 {
 346   struct process_info *process = find_process_pid (pid);
 347   if (process == NULL)
 348     return -1;
 349
 350   ptrace (PTRACE_DETACH, pid, 0, 0);
 351
 352   clear_inferiors ();
 353   remove_process (process);
 354   return 0;
 355 }
 356
 357 static void
 358 spu_mourn (struct process_info *process)
 359 {
 360   remove_process (process);
 361 }
 362
 363 static void
 364 spu_join (int pid)
 365 {
 366   int status, ret;
 367
 368   do {
 369     ret = waitpid (pid, &status, 0);
 370     if (WIFEXITED (status) || WIFSIGNALED (status))
 371       break;
 372   } while (ret != -1 || errno != ECHILD);
 373 }
 374
 375 /* Return nonzero if the given thread is still alive.  */
 376 static int
 377 spu_thread_alive (ptid_t ptid)
 378 {
 379   return ptid_equal (ptid, current_ptid);
 380 }
 381
 382 /* Resume process.  */
 383 static void
 384 spu_resume (struct thread_resume *resume_info, size_t n)
 385 {
 386   size_t i;
 387
 388   for (i = 0; i < n; i++)
 389     if (ptid_equal (resume_info[i].thread, minus_one_ptid)
 390         || ptid_equal (resume_info[i].thread, current_ptid))
 391       break;
 392
 393   if (i == n)
 394     return;
 395
 396   /* We don't support hardware single-stepping right now, assume
 397      GDB knows to use software single-stepping.  */
 398   if (resume_info[i].kind == resume_step)
 399     fprintf (stderr, "Hardware single-step not supported.\n");
 400
 401   regcache_invalidate ();
 402
 403   errno = 0;
 404   ptrace (PTRACE_CONT, ptid_get_lwp (current_ptid), 0, resume_info[i].sig);
 405   if (errno)
 406     perror_with_name ("ptrace");
 407 }
 408
 409 /* Wait for process, returns status.  */
 410 static ptid_t
 411 spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 412 {
 413   int pid = ptid_get_pid (ptid);
 414   int w;
 415   int ret;
 416
 417   while (1)
 418     {
 419       ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);
 420
 421       if (ret == -1)
 422         {
 423           if (errno != ECHILD)
 424             perror_with_name ("waitpid");
 425         }
 426       else if (ret > 0)
 427         break;
 428
 429       usleep (1000);
 430     }
 431
 432   /* On the first wait, continue running the inferior until we are
 433      blocked inside an spu_run system call.  */
 434   if (!server_waiting)
 435     {
 436       int fd;
 437       CORE_ADDR addr;
 438
 439       while (!parse_spufs_run (&fd, &addr))
 440         {
 441           ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
 442           waitpid (pid, NULL, __WALL | __WNOTHREAD);
 443         }
 444     }
 445
 446   if (WIFEXITED (w))
 447     {
 448       fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
 449       ourstatus->kind =  TARGET_WAITKIND_EXITED;
 450       ourstatus->value.integer = WEXITSTATUS (w);
 451       clear_inferiors ();
 452       return pid_to_ptid (ret);
 453     }
 454   else if (!WIFSTOPPED (w))
 455     {
 456       fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
 457       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 458       ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
 459       clear_inferiors ();
 460       return pid_to_ptid (ret);
 461     }
 462
 463   /* After attach, we may have received a SIGSTOP.  Do not return this
 464      as signal to GDB, or else it will try to continue with SIGSTOP ...  */
 465   if (!server_waiting)
 466     {
 467       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 468       ourstatus->value.sig = GDB_SIGNAL_0;
 469       return ptid_build (ret, ret, 0);
 470     }
 471
 472   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 473   ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
 474   return ptid_build (ret, ret, 0);
 475 }
 476
 477 /* Fetch inferior registers.  */
 478 static void
 479 spu_fetch_registers (struct regcache *regcache, int regno)
 480 {
 481   int fd;
 482   CORE_ADDR addr;
 483
 484   /* We must be stopped on a spu_run system call.  */
 485   if (!parse_spufs_run (&fd, &addr))
 486     return;
 487
 488   /* The ID register holds the spufs file handle.  */
 489   if (regno == -1 || regno == SPU_ID_REGNUM)
 490     supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);
 491
 492   /* The NPC register is found at ADDR.  */
 493   if (regno == -1 || regno == SPU_PC_REGNUM)
 494     {
 495       char buf[4];
 496       if (fetch_ppc_memory (addr, buf, 4) == 0)
 497         supply_register (regcache, SPU_PC_REGNUM, buf);
 498     }
 499
 500   /* The GPRs are found in the "regs" spufs file.  */
 501   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
 502     {
 503       unsigned char buf[16*SPU_NUM_CORE_REGS];
 504       char annex[32];
 505       int i;
 506
 507       sprintf (annex, "%d/regs", fd);
 508       if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
 509         for (i = 0; i < SPU_NUM_CORE_REGS; i++)
 510           supply_register (regcache, i, buf + i*16);
 511     }
 512 }
 513
 514 /* Store inferior registers.  */
 515 static void
 516 spu_store_registers (struct regcache *regcache, int regno)
 517 {
 518   int fd;
 519   CORE_ADDR addr;
 520
 521   /* ??? Some callers use 0 to mean all registers.  */
 522   if (regno == 0)
 523     regno = -1;
 524
 525   /* We must be stopped on a spu_run system call.  */
 526   if (!parse_spufs_run (&fd, &addr))
 527     return;
 528
 529   /* The NPC register is found at ADDR.  */
 530   if (regno == -1 || regno == SPU_PC_REGNUM)
 531     {
 532       char buf[4];
 533       collect_register (regcache, SPU_PC_REGNUM, buf);
 534       store_ppc_memory (addr, buf, 4);
 535     }
 536
 537   /* The GPRs are found in the "regs" spufs file.  */
 538   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
 539     {
 540       unsigned char buf[16*SPU_NUM_CORE_REGS];
 541       char annex[32];
 542       int i;
 543
 544       for (i = 0; i < SPU_NUM_CORE_REGS; i++)
 545         collect_register (regcache, i, buf + i*16);
 546
 547       sprintf (annex, "%d/regs", fd);
 548       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
 549     }
 550 }
 551
 552 /* Copy LEN bytes from inferior's memory starting at MEMADDR
 553    to debugger memory starting at MYADDR.  */
 554 static int
 555 spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 556 {
 557   int fd, ret;
 558   CORE_ADDR addr;
 559   char annex[32], lslr_annex[32], buf[32];
 560   CORE_ADDR lslr;
 561
 562   /* We must be stopped on a spu_run system call.  */
 563   if (!parse_spufs_run (&fd, &addr))
 564     return 0;
 565
 566   /* Use the "mem" spufs file to access SPU local store.  */
 567   sprintf (annex, "%d/mem", fd);
 568   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
 569   if (ret > 0)
 570     return ret == len ? 0 : EIO;
 571
 572   /* SPU local store access wraps the address around at the
 573      local store limit.  We emulate this here.  To avoid needing
 574      an extra access to retrieve the LSLR, we only do that after
 575      trying the original address first, and getting end-of-file.  */
 576   sprintf (lslr_annex, "%d/lslr", fd);
 577   memset (buf, 0, sizeof buf);
 578   if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
 579                          0, sizeof buf) <= 0)
 580     return ret;
 581
 582   lslr = strtoul (buf, NULL, 16);
 583   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
 584
 585   return ret == len ? 0 : EIO;
 586 }
 587
 588 /* Copy LEN bytes of data from debugger memory at MYADDR
 589    to inferior's memory at MEMADDR.
 590    On failure (cannot write the inferior)
 591    returns the value of errno.  */
 592 static int
 593 spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
 594 {
 595   int fd, ret;
 596   CORE_ADDR addr;
 597   char annex[32], lslr_annex[32], buf[32];
 598   CORE_ADDR lslr;
 599
 600   /* We must be stopped on a spu_run system call.  */
 601   if (!parse_spufs_run (&fd, &addr))
 602     return 0;
 603
 604   /* Use the "mem" spufs file to access SPU local store.  */
 605   sprintf (annex, "%d/mem", fd);
 606   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
 607   if (ret > 0)
 608     return ret == len ? 0 : EIO;
 609
 610   /* SPU local store access wraps the address around at the
 611      local store limit.  We emulate this here.  To avoid needing
 612      an extra access to retrieve the LSLR, we only do that after
 613      trying the original address first, and getting end-of-file.  */
 614   sprintf (lslr_annex, "%d/lslr", fd);
 615   memset (buf, 0, sizeof buf);
 616   if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
 617                          0, sizeof buf) <= 0)
 618     return ret;
 619
 620   lslr = strtoul (buf, NULL, 16);
 621   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
 622
 623   return ret == len ? 0 : EIO;
 624 }
 625
 626 /* Look up special symbols -- unneded here.  */
 627 static void
 628 spu_look_up_symbols (void)
 629 {
 630 }
 631
 632 /* Send signal to inferior.  */
 633 static void
 634 spu_request_interrupt (void)
 635 {
 636   syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT);
 637 }
 638
 639 static struct target_ops spu_target_ops = {
 640   spu_create_inferior,
 641   spu_attach,
 642   spu_kill,
 643   spu_detach,
 644   spu_mourn,
 645   spu_join,
 646   spu_thread_alive,
 647   spu_resume,
 648   spu_wait,
 649   spu_fetch_registers,
 650   spu_store_registers,
 651   NULL, /* prepare_to_access_memory */
 652   NULL, /* done_accessing_memory */
 653   spu_read_memory,
 654   spu_write_memory,
 655   spu_look_up_symbols,
 656   spu_request_interrupt,
 657   NULL,
 658   NULL,
 659   NULL,
 660   NULL,
 661   NULL,
 662   NULL,
 663   NULL,
 664   spu_proc_xfer_spu,
 665   hostio_last_error_from_errno,
 666 };
 667
 668 void
 669 initialize_low (void)
 670 {
 671   static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
 672
 673   set_target_ops (&spu_target_ops);
 674   set_breakpoint_data (breakpoint, sizeof breakpoint);
 675   init_registers_spu ();
 676 }