gdb/gdbserver/spu-low.c

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