Fix nto,spu and win32 builds of GDBServer.
[deliverable/binutils-gdb.git] / gdb / gdbserver / spu-low.c
1 /* Low level interface to SPUs, for the remote server for GDB.
2 Copyright (C) 2006-2015 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 <unistd.h>
27 #include <sys/syscall.h>
28 #include "filestuff.h"
29 #include "hostio.h"
30
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
36
37 #define PTRACE_TYPE_RET long
38 #define PTRACE_TYPE_ARG3 long
39
40 /* Number of registers. */
41 #define SPU_NUM_REGS 130
42 #define SPU_NUM_CORE_REGS 128
43
44 /* Special registers. */
45 #define SPU_ID_REGNUM 128
46 #define SPU_PC_REGNUM 129
47
48 /* PPU side system calls. */
49 #define INSTR_SC 0x44000002
50 #define NR_spu_run 0x0116
51
52 /* These are used in remote-utils.c. */
53 int using_threads = 0;
54
55 /* Defined in auto-generated file reg-spu.c. */
56 void init_registers_spu (void);
57 extern const struct target_desc *tdesc_spu;
58
59 /* Software breakpoint instruction. */
60 static const gdb_byte breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
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 = XALLOCAVEC (PTRACE_TYPE_RET, count);
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 = XALLOCAVEC (PTRACE_TYPE_RET, count);
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 struct thread_info *thr = get_first_thread ();
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, ptid_of (thr)))
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 (ptid_of (thr)), 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 struct thread_info *thr = get_first_thread ();
641
642 syscall (SYS_tkill, lwpid_of (thr), SIGINT);
643 }
644
645 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
646
647 static const gdb_byte *
648 spu_sw_breakpoint_from_kind (int kind, int *size)
649 {
650 *size = sizeof breakpoint;
651 return breakpoint;
652 }
653
654 static struct target_ops spu_target_ops = {
655 spu_create_inferior,
656 NULL, /* arch_setup */
657 spu_attach,
658 spu_kill,
659 spu_detach,
660 spu_mourn,
661 spu_join,
662 spu_thread_alive,
663 spu_resume,
664 spu_wait,
665 spu_fetch_registers,
666 spu_store_registers,
667 NULL, /* prepare_to_access_memory */
668 NULL, /* done_accessing_memory */
669 spu_read_memory,
670 spu_write_memory,
671 spu_look_up_symbols,
672 spu_request_interrupt,
673 NULL,
674 NULL, /* supports_z_point_type */
675 NULL,
676 NULL,
677 NULL, /* stopped_by_sw_breakpoint */
678 NULL, /* supports_stopped_by_sw_breakpoint */
679 NULL, /* stopped_by_hw_breakpoint */
680 NULL, /* supports_stopped_by_hw_breakpoint */
681 NULL, /* supports_hardware_single_step */
682 NULL,
683 NULL,
684 NULL,
685 NULL,
686 spu_proc_xfer_spu,
687 hostio_last_error_from_errno,
688 NULL, /* qxfer_osdata */
689 NULL, /* qxfer_siginfo */
690 NULL, /* supports_non_stop */
691 NULL, /* async */
692 NULL, /* start_non_stop */
693 NULL, /* supports_multi_process */
694 NULL, /* supports_fork_events */
695 NULL, /* supports_vfork_events */
696 NULL, /* supports_exec_events */
697 NULL, /* handle_new_gdb_connection */
698 NULL, /* handle_monitor_command */
699 NULL, /* core_of_thread */
700 NULL, /* read_loadmap */
701 NULL, /* process_qsupported */
702 NULL, /* supports_tracepoints */
703 NULL, /* read_pc */
704 NULL, /* write_pc */
705 NULL, /* thread_stopped */
706 NULL, /* get_tib_address */
707 NULL, /* pause_all */
708 NULL, /* unpause_all */
709 NULL, /* stabilize_threads */
710 NULL, /* install_fast_tracepoint_jump_pad */
711 NULL, /* emit_ops */
712 NULL, /* supports_disable_randomization */
713 NULL, /* get_min_fast_tracepoint_insn_len */
714 NULL, /* qxfer_libraries_svr4 */
715 NULL, /* support_agent */
716 NULL, /* support_btrace */
717 NULL, /* enable_btrace */
718 NULL, /* disable_btrace */
719 NULL, /* read_btrace */
720 NULL, /* read_btrace_conf */
721 NULL, /* supports_range_stepping */
722 NULL, /* pid_to_exec_file */
723 NULL, /* multifs_open */
724 NULL, /* multifs_unlink */
725 NULL, /* multifs_readlink */
726 NULL, /* breakpoint_kind_from_pc */
727 spu_sw_breakpoint_from_kind,
728 };
729
730 void
731 initialize_low (void)
732 {
733 set_target_ops (&spu_target_ops);
734 init_registers_spu ();
735 }
This page took 0.045943 seconds and 4 git commands to generate.