gdb/gdbserver/spu-low.c

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