gdb/gdbserver/spu-low.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* Low level interface to SPUs, for the remote server for GDB.
  2.    Copyright (C) 2006-2015 Free Software Foundation, Inc.

  4.    Contributed by Ulrich Weigand <uweigand@de.ibm.com>.

  6.    This file is part of GDB.

  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.

  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.

  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/>.  */

  21. #include "server.h"

  23. #include "gdb_wait.h"
  24. #include <sys/ptrace.h>
  25. #include <fcntl.h>
  26. #include <unistd.h>
  27. #include <sys/syscall.h>
  28. #include "filestuff.h"
  29. #include "hostio.h"

  31. /* Some older glibc versions do not define this.  */
  32. #ifndef __WNOTHREAD
  33. ‌#define __WNOTHREAD     0x20000000      /* Don't wait on children of other
  34.                                            threads in this group */
  35. #endif

  37. ‌#define PTRACE_TYPE_RET long
  38. ‌#define PTRACE_TYPE_ARG3 long

  40. /* Number of registers.  */
  41. ‌#define SPU_NUM_REGS         130
  42. ‌#define SPU_NUM_CORE_REGS    128

  44. /* Special registers.  */
  45. ‌#define SPU_ID_REGNUM        128
  46. ‌#define SPU_PC_REGNUM        129

  48. /* PPU side system calls.  */
  49. ‌#define INSTR_SC        0x44000002
  50. ‌#define NR_spu_run        0x0116

  52. /* These are used in remote-utils.c.  */
  53. ‌int using_threads = 0;

  55. /* Defined in auto-generated file reg-spu.c.  */
  56. void init_registers_spu (void);
  57. extern const struct target_desc *tdesc_spu;

  59. /* Fetch PPU register REGNO.  */
  60. static CORE_ADDR
  61. ‌fetch_ppc_register (int regno)
  62. {
  63.   PTRACE_TYPE_RET res;

  65.   int tid = ptid_get_lwp (current_ptid);

  67. #ifndef __powerpc64__
  68.   /* If running as a 32-bit process on a 64-bit system, we attempt
  69.      to get the full 64-bit register content of the target process.
  70.      If the PPC special ptrace call fails, we're on a 32-bit system;
  71.      just fall through to the regular ptrace call in that case.  */
  72.   {
  73.     char buf[8];

  75.     errno = 0;
  76.     ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  77.             (PTRACE_TYPE_ARG3) (regno * 8), buf);
  78.     if (errno == 0)
  79.       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  80.               (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
  81.     if (errno == 0)
  82.       return (CORE_ADDR) *(unsigned long long *)buf;
  83.   }
  84. #endif

  86.   errno = 0;
  87.   res = ptrace (PT_READ_U, tid,
  88.                 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
  89.   if (errno != 0)
  90.     {
  91.       char mess[128];
  92.       sprintf (mess, "reading PPC register #%d", regno);
  93.       perror_with_name (mess);
  94.     }

  96.   return (CORE_ADDR) (unsigned long) res;
  97. }

  99. /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
  100. static int
  101. ‌fetch_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
  102. {
  103.   errno = 0;

  105. #ifndef __powerpc64__
  106.   if (memaddr >> 32)
  107.     {
  108.       unsigned long long addr_8 = (unsigned long long) memaddr;
  109.       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
  110.     }
  111.   else
  112. #endif
  113.     *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);

  115.   return errno;
  116. }

  118. /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
  119. static int
  120. ‌store_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
  121. {
  122.   errno = 0;

  124. #ifndef __powerpc64__
  125.   if (memaddr >> 32)
  126.     {
  127.       unsigned long long addr_8 = (unsigned long long) memaddr;
  128.       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
  129.     }
  130.   else
  131. #endif
  132.     ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);

  134.   return errno;
  135. }

  137. /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
  138. static int
  139. ‌fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
  140. {
  141.   int i, ret;

  143.   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
  144.   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
  145.                / sizeof (PTRACE_TYPE_RET));
  146.   PTRACE_TYPE_RET *buffer;

  148.   int tid = ptid_get_lwp (current_ptid);

  150.   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
  151.   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
  152.     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
  153.       return ret;

  155.   memcpy (myaddr,
  156.           (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
  157.           len);

  159.   return 0;
  160. }

  162. /* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
  163. static int
  164. ‌store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
  165. {
  166.   int i, ret;

  168.   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
  169.   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
  170.                / sizeof (PTRACE_TYPE_RET));
  171.   PTRACE_TYPE_RET *buffer;

  173.   int tid = ptid_get_lwp (current_ptid);

  175.   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));

  177.   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
  178.     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
  179.       return ret;

  181.   if (count > 1)
  182.     if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
  183.                                                * sizeof (PTRACE_TYPE_RET),
  184.                                    &buffer[count - 1])) != 0)
  185.       return ret;

  187.   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
  188.           myaddr, len);

  190.   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
  191.     if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
  192.       return ret;

  194.   return 0;
  195. }


  198. /* If the PPU thread is currently stopped on a spu_run system call,
  199.    return to FD and ADDR the file handle and NPC parameter address
  200.    used with the system call.  Return non-zero if successful.  */
  201. static int
  202. ‌parse_spufs_run (int *fd, CORE_ADDR *addr)
  203. {
  204.   unsigned int insn;
  205.   CORE_ADDR pc = fetch_ppc_register (32);  /* nip */

  207.   /* Fetch instruction preceding current NIP.  */
  208.   if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
  209.     return 0;
  210.   /* It should be a "sc" instruction.  */
  211.   if (insn != INSTR_SC)
  212.     return 0;
  213.   /* System call number should be NR_spu_run.  */
  214.   if (fetch_ppc_register (0) != NR_spu_run)
  215.     return 0;

  217.   /* Register 3 contains fd, register 4 the NPC param pointer.  */
  218.   *fd = fetch_ppc_register (34);  /* orig_gpr3 */
  219.   *addr = fetch_ppc_register (4);
  220.   return 1;
  221. }


  224. /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
  225.    using the /proc file system.  */
  226. static int
  227. ‌spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
  228.                    const unsigned char *writebuf,
  229.                    CORE_ADDR offset, int len)
  230. {
  231.   char buf[128];
  232.   int fd = 0;
  233.   int ret = -1;

  235.   if (!annex)
  236.     return 0;

  238.   sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
  239.   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
  240.   if (fd <= 0)
  241.     return -1;

  243.   if (offset != 0
  244.       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
  245.     {
  246.       close (fd);
  247.       return 0;
  248.     }

  250.   if (writebuf)
  251.     ret = write (fd, writebuf, (size_t) len);
  252.   else if (readbuf)
  253.     ret = read (fd, readbuf, (size_t) len);

  255.   close (fd);
  256.   return ret;
  257. }


  260. /* Start an inferior process and returns its pid.
  261.    ALLARGS is a vector of program-name and args. */
  262. static int
  263. ‌spu_create_inferior (char *program, char **allargs)
  264. {
  265.   int pid;
  266.   ptid_t ptid;
  267.   struct process_info *proc;

  269.   pid = fork ();
  270.   if (pid < 0)
  271.     perror_with_name ("fork");

  273.   if (pid == 0)
  274.     {
  275.       close_most_fds ();
  276.       ptrace (PTRACE_TRACEME, 0, 0, 0);

  278.       setpgid (0, 0);

  280.       execv (program, allargs);
  281.       if (errno == ENOENT)
  282.         execvp (program, allargs);

  284.       fprintf (stderr, "Cannot exec %s: %s.\n", program,
  285.                strerror (errno));
  286.       fflush (stderr);
  287.       _exit (0177);
  288.     }

  290.   proc = add_process (pid, 0);
  291.   proc->tdesc = tdesc_spu;

  293.   ptid = ptid_build (pid, pid, 0);
  294.   add_thread (ptid, NULL);
  295.   return pid;
  296. }

  298. /* Attach to an inferior process.  */
  299. int
  300. ‌spu_attach (unsigned long  pid)
  301. {
  302.   ptid_t ptid;
  303.   struct process_info *proc;

  305.   if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
  306.     {
  307.       fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
  308.                strerror (errno), errno);
  309.       fflush (stderr);
  310.       _exit (0177);
  311.     }

  313.   proc = add_process (pid, 1);
  314.   proc->tdesc = tdesc_spu;
  315.   ptid = ptid_build (pid, pid, 0);
  316.   add_thread (ptid, NULL);
  317.   return 0;
  318. }

  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;

  329.   ptrace (PTRACE_KILL, pid, 0, 0);

  331.   do {
  332.     ret = waitpid (pid, &status, 0);
  333.     if (WIFEXITED (status) || WIFSIGNALED (status))
  334.       break;
  335.   } while (ret != -1 || errno != ECHILD);

  337.   clear_inferiors ();
  338.   remove_process (process);
  339.   return 0;
  340. }

  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;

  350.   ptrace (PTRACE_DETACH, pid, 0, 0);

  352.   clear_inferiors ();
  353.   remove_process (process);
  354.   return 0;
  355. }

  357. static void
  358. ‌spu_mourn (struct process_info *process)
  359. {
  360.   remove_process (process);
  361. }

  363. static void
  364. ‌spu_join (int pid)
  365. {
  366.   int status, ret;

  368.   do {
  369.     ret = waitpid (pid, &status, 0);
  370.     if (WIFEXITED (status) || WIFSIGNALED (status))
  371.       break;
  372.   } while (ret != -1 || errno != ECHILD);
  373. }

  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. }

  382. /* Resume process.  */
  383. static void
  384. ‌spu_resume (struct thread_resume *resume_info, size_t n)
  385. {
  386.   size_t i;

  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;

  393.   if (i == n)
  394.     return;

  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");

  401.   regcache_invalidate ();

  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. }

  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;

  417.   while (1)
  418.     {
  419.       ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);

  421.       if (ret == -1)
  422.         {
  423.           if (errno != ECHILD)
  424.             perror_with_name ("waitpid");
  425.         }
  426.       else if (ret > 0)
  427.         break;

  429.       usleep (1000);
  430.     }

  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;

  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.     }

  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.     }

  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.     }

  472.   ourstatus->kind = TARGET_WAITKIND_STOPPED;
  473.   ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
  474.   return ptid_build (ret, ret, 0);
  475. }

  477. /* Fetch inferior registers.  */
  478. static void
  479. ‌spu_fetch_registers (struct regcache *regcache, int regno)
  480. {
  481.   int fd;
  482.   CORE_ADDR addr;

  484.   /* We must be stopped on a spu_run system call.  */
  485.   if (!parse_spufs_run (&fd, &addr))
  486.     return;

  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);

  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.     }

  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;

  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. }

  514. /* Store inferior registers.  */
  515. static void
  516. ‌spu_store_registers (struct regcache *regcache, int regno)
  517. {
  518.   int fd;
  519.   CORE_ADDR addr;

  521.   /* ??? Some callers use 0 to mean all registers.  */
  522.   if (regno == 0)
  523.     regno = -1;

  525.   /* We must be stopped on a spu_run system call.  */
  526.   if (!parse_spufs_run (&fd, &addr))
  527.     return;

  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.     }

  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;

  544.       for (i = 0; i < SPU_NUM_CORE_REGS; i++)
  545.         collect_register (regcache, i, buf + i*16);

  547.       sprintf (annex, "%d/regs", fd);
  548.       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
  549.     }
  550. }

  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;

  562.   /* We must be stopped on a spu_run system call.  */
  563.   if (!parse_spufs_run (&fd, &addr))
  564.     return 0;

  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;

  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;

  582.   lslr = strtoul (buf, NULL, 16);
  583.   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);

  585.   return ret == len ? 0 : EIO;
  586. }

  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;

  600.   /* We must be stopped on a spu_run system call.  */
  601.   if (!parse_spufs_run (&fd, &addr))
  602.     return 0;

  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;

  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;

  620.   lslr = strtoul (buf, NULL, 16);
  621.   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);

  623.   return ret == len ? 0 : EIO;
  624. }

  626. /* Look up special symbols -- unneded here.  */
  627. static void
  628. ‌spu_look_up_symbols (void)
  629. {
  630. }

  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. }

  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,  /* supports_z_point_type */
  659.   NULL,
  660.   NULL,
  661.   NULL,
  662.   NULL,
  663.   NULL,
  664.   NULL,
  665.   spu_proc_xfer_spu,
  666.   hostio_last_error_from_errno,
  667. };

  669. void
  670. ‌initialize_low (void)
  671. {
  672.   static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };

  674.   set_target_ops (&spu_target_ops);
  675.   set_breakpoint_data (breakpoint, sizeof breakpoint);
  676.   init_registers_spu ();
  677. }