GDBserver

spu-low.c
Go to the documentation of this file.
1 /* Low level interface to SPUs, for the remote server for GDB.
2 Copyright (C) 2006-2018 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 #include "nat/fork-inferior.h"
31
32 /* Some older glibc versions do not define this. */
33 #ifndef __WNOTHREAD
34 #define __WNOTHREAD 0x20000000 /* Don't wait on children of other
35 threads in this group */
36 #endif
37
38 #define PTRACE_TYPE_RET long
39 #define PTRACE_TYPE_ARG3 long
40
41 /* Number of registers. */
42 #define SPU_NUM_REGS 130
43 #define SPU_NUM_CORE_REGS 128
44
45 /* Special registers. */
46 #define SPU_ID_REGNUM 128
47 #define SPU_PC_REGNUM 129
48
49 /* PPU side system calls. */
50 #define INSTR_SC 0x44000002
51 #define NR_spu_run 0x0116
52
53 /* These are used in remote-utils.c. */
54 int using_threads = 0;
55
56 /* Defined in auto-generated file reg-spu.c. */
57 void init_registers_spu (void);
58 extern const struct target_desc *tdesc_spu;
59
60 /* Software breakpoint instruction. */
61 static const gdb_byte breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
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 ((PTRACE_TYPE_ARG1) PPC_PTRACE_PEEKUSR_3264, tid,
81 (PTRACE_TYPE_ARG3) (regno * 8), buf);
82 if (errno == 0)
83 ptrace ((PTRACE_TYPE_ARG1) 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 ((PTRACE_TYPE_ARG1) PPC_PTRACE_PEEKTEXT_3264, tid,
114 (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 ((PTRACE_TYPE_ARG1) PPC_PTRACE_POKEDATA_3264, tid,
134 (PTRACE_TYPE_ARG3) &addr_8, word);
135 }
136 else
137 #endif
138 ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
139
140 return errno;
141 }
142
143 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
144 static int
145 fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
146 {
147 int i, ret;
148
149 CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
150 int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
151 / sizeof (PTRACE_TYPE_RET));
152 PTRACE_TYPE_RET *buffer;
153
154 int tid = ptid_get_lwp (current_ptid);
155
156 buffer = XALLOCAVEC (PTRACE_TYPE_RET, count);
157 for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
158 if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
159 return ret;
160
161 memcpy (myaddr,
162 (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
163 len);
164
165 return 0;
166 }
167
168 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
169 static int
170 store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
171 {
172 int i, ret;
173
174 CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
175 int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
176 / sizeof (PTRACE_TYPE_RET));
177 PTRACE_TYPE_RET *buffer;
178
179 int tid = ptid_get_lwp (current_ptid);
180
181 buffer = XALLOCAVEC (PTRACE_TYPE_RET, count);
182
183 if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
184 if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
185 return ret;
186
187 if (count > 1)
188 if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
189 * sizeof (PTRACE_TYPE_RET),
190 &buffer[count - 1])) != 0)
191 return ret;
192
193 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
194 myaddr, len);
195
196 for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
197 if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
198 return ret;
199
200 return 0;
201 }
202
203
204 /* If the PPU thread is currently stopped on a spu_run system call,
205 return to FD and ADDR the file handle and NPC parameter address
206 used with the system call. Return non-zero if successful. */
207 static int
208 parse_spufs_run (int *fd, CORE_ADDR *addr)
209 {
210 unsigned int insn;
211 CORE_ADDR pc = fetch_ppc_register (32); /* nip */
212
213 /* Fetch instruction preceding current NIP. */
214 if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
215 return 0;
216 /* It should be a "sc" instruction. */
217 if (insn != INSTR_SC)
218 return 0;
219 /* System call number should be NR_spu_run. */
220 if (fetch_ppc_register (0) != NR_spu_run)
221 return 0;
222
223 /* Register 3 contains fd, register 4 the NPC param pointer. */
224 *fd = fetch_ppc_register (34); /* orig_gpr3 */
225 *addr = fetch_ppc_register (4);
226 return 1;
227 }
228
229
230 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
231 using the /proc file system. */
232 static int
233 spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
234 const unsigned char *writebuf,
235 CORE_ADDR offset, int len)
236 {
237 char buf[128];
238 int fd = 0;
239 int ret = -1;
240
241 if (!annex)
242 return 0;
243
244 sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
245 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
246 if (fd <= 0)
247 return -1;
248
249 if (offset != 0
250 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
251 {
252 close (fd);
253 return 0;
254 }
255
256 if (writebuf)
257 ret = write (fd, writebuf, (size_t) len);
258 else if (readbuf)
259 ret = read (fd, readbuf, (size_t) len);
260
261 close (fd);
262 return ret;
263 }
264
265 /* Callback to be used when calling fork_inferior, responsible for
266 actually initiating the tracing of the inferior. */
267
268 static void
269 spu_ptrace_fun ()
270 {
271 if (ptrace (PTRACE_TRACEME, 0, 0, 0) < 0)
272 trace_start_error_with_name ("ptrace");
273 if (setpgid (0, 0) < 0)
274 trace_start_error_with_name ("setpgid");
275 }
276
277 /* Start an inferior process and returns its pid.
278 PROGRAM is the name of the program to be started, and PROGRAM_ARGS
279 are its arguments. */
280
281 static int
282 spu_create_inferior (const char *program,
283 const std::vector<char *> &program_args)
284 {
285 int pid;
286 ptid_t ptid;
287 struct process_info *proc;
288 std::string str_program_args = stringify_argv (program_args);
289
290 pid = fork_inferior (program,
291 str_program_args.c_str (),
292 get_environ ()->envp (), spu_ptrace_fun,
293 NULL, NULL, NULL, NULL);
294
295 post_fork_inferior (pid, program);
296
297 proc = add_process (pid, 0);
298 proc->tdesc = tdesc_spu;
299
300 ptid = ptid_build (pid, pid, 0);
301 add_thread (ptid, NULL);
302 return pid;
303 }
304
305 /* Attach to an inferior process. */
306 int
307 spu_attach (unsigned long pid)
308 {
309 ptid_t ptid;
310 struct process_info *proc;
311
312 if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
313 {
314 fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
315 strerror (errno), errno);
316 fflush (stderr);
317 _exit (0177);
318 }
319
320 proc = add_process (pid, 1);
321 proc->tdesc = tdesc_spu;
322 ptid = ptid_build (pid, pid, 0);
323 add_thread (ptid, NULL);
324 return 0;
325 }
326
327 /* Kill the inferior process. */
328 static int
329 spu_kill (int pid)
330 {
331 int status, ret;
332 struct process_info *process = find_process_pid (pid);
333 if (process == NULL)
334 return -1;
335
336 ptrace (PTRACE_KILL, pid, 0, 0);
337
338 do {
339 ret = waitpid (pid, &status, 0);
340 if (WIFEXITED (status) || WIFSIGNALED (status))
341 break;
342 } while (ret != -1 || errno != ECHILD);
343
344 clear_inferiors ();
345 remove_process (process);
346 return 0;
347 }
348
349 /* Detach from inferior process. */
350 static int
351 spu_detach (int pid)
352 {
353 struct process_info *process = find_process_pid (pid);
354 if (process == NULL)
355 return -1;
356
357 ptrace (PTRACE_DETACH, pid, 0, 0);
358
359 clear_inferiors ();
360 remove_process (process);
361 return 0;
362 }
363
364 static void
365 spu_mourn (struct process_info *process)
366 {
367 remove_process (process);
368 }
369
370 static void
371 spu_join (int pid)
372 {
373 int status, ret;
374
375 do {
376 ret = waitpid (pid, &status, 0);
377 if (WIFEXITED (status) || WIFSIGNALED (status))
378 break;
379 } while (ret != -1 || errno != ECHILD);
380 }
381
382 /* Return nonzero if the given thread is still alive. */
383 static int
384 spu_thread_alive (ptid_t ptid)
385 {
386 return ptid_equal (ptid, current_ptid);
387 }
388
389 /* Resume process. */
390 static void
391 spu_resume (struct thread_resume *resume_info, size_t n)
392 {
393 struct thread_info *thr = get_first_thread ();
394 size_t i;
395
396 for (i = 0; i < n; i++)
397 if (ptid_equal (resume_info[i].thread, minus_one_ptid)
398 || ptid_equal (resume_info[i].thread, ptid_of (thr)))
399 break;
400
401 if (i == n)
402 return;
403
404 /* We don't support hardware single-stepping right now, assume
405 GDB knows to use software single-stepping. */
406 if (resume_info[i].kind == resume_step)
407 fprintf (stderr, "Hardware single-step not supported.\n");
408
409 regcache_invalidate ();
410
411 errno = 0;
412 ptrace (PTRACE_CONT, ptid_get_lwp (ptid_of (thr)), 0, resume_info[i].sig);
413 if (errno)
414 perror_with_name ("ptrace");
415 }
416
417 /* Wait for process, returns status. */
418 static ptid_t
419 spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
420 {
421 int pid = ptid_get_pid (ptid);
422 int w;
423 int ret;
424
425 while (1)
426 {
427 ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);
428
429 if (ret == -1)
430 {
431 if (errno != ECHILD)
432 perror_with_name ("waitpid");
433 }
434 else if (ret > 0)
435 break;
436
437 usleep (1000);
438 }
439
440 /* On the first wait, continue running the inferior until we are
441 blocked inside an spu_run system call. */
442 if (!server_waiting)
443 {
444 int fd;
445 CORE_ADDR addr;
446
447 while (!parse_spufs_run (&fd, &addr))
448 {
449 ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
450 waitpid (pid, NULL, __WALL | __WNOTHREAD);
451 }
452 }
453
454 if (WIFEXITED (w))
455 {
456 fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
457 ourstatus->kind = TARGET_WAITKIND_EXITED;
458 ourstatus->value.integer = WEXITSTATUS (w);
459 clear_inferiors ();
460 return pid_to_ptid (ret);
461 }
462 else if (!WIFSTOPPED (w))
463 {
464 fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
465 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
466 ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
467 clear_inferiors ();
468 return pid_to_ptid (ret);
469 }
470
471 /* After attach, we may have received a SIGSTOP. Do not return this
472 as signal to GDB, or else it will try to continue with SIGSTOP ... */
473 if (!server_waiting)
474 {
475 ourstatus->kind = TARGET_WAITKIND_STOPPED;
476 ourstatus->value.sig = GDB_SIGNAL_0;
477 return ptid_build (ret, ret, 0);
478 }
479
480 ourstatus->kind = TARGET_WAITKIND_STOPPED;
481 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
482 return ptid_build (ret, ret, 0);
483 }
484
485 /* Fetch inferior registers. */
486 static void
487 spu_fetch_registers (struct regcache *regcache, int regno)
488 {
489 int fd;
490 CORE_ADDR addr;
491
492 /* We must be stopped on a spu_run system call. */
493 if (!parse_spufs_run (&fd, &addr))
494 return;
495
496 /* The ID register holds the spufs file handle. */
497 if (regno == -1 || regno == SPU_ID_REGNUM)
498 supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);
499
500 /* The NPC register is found at ADDR. */
501 if (regno == -1 || regno == SPU_PC_REGNUM)
502 {
503 char buf[4];
504 if (fetch_ppc_memory (addr, buf, 4) == 0)
505 supply_register (regcache, SPU_PC_REGNUM, buf);
506 }
507
508 /* The GPRs are found in the "regs" spufs file. */
509 if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
510 {
511 unsigned char buf[16*SPU_NUM_CORE_REGS];
512 char annex[32];
513 int i;
514
515 sprintf (annex, "%d/regs", fd);
516 if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
517 for (i = 0; i < SPU_NUM_CORE_REGS; i++)
518 supply_register (regcache, i, buf + i*16);
519 }
520 }
521
522 /* Store inferior registers. */
523 static void
524 spu_store_registers (struct regcache *regcache, int regno)
525 {
526 int fd;
527 CORE_ADDR addr;
528
529 /* ??? Some callers use 0 to mean all registers. */
530 if (regno == 0)
531 regno = -1;
532
533 /* We must be stopped on a spu_run system call. */
534 if (!parse_spufs_run (&fd, &addr))
535 return;
536
537 /* The NPC register is found at ADDR. */
538 if (regno == -1 || regno == SPU_PC_REGNUM)
539 {
540 char buf[4];
541 collect_register (regcache, SPU_PC_REGNUM, buf);
542 store_ppc_memory (addr, buf, 4);
543 }
544
545 /* The GPRs are found in the "regs" spufs file. */
546 if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
547 {
548 unsigned char buf[16*SPU_NUM_CORE_REGS];
549 char annex[32];
550 int i;
551
552 for (i = 0; i < SPU_NUM_CORE_REGS; i++)
553 collect_register (regcache, i, buf + i*16);
554
555 sprintf (annex, "%d/regs", fd);
556 spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
557 }
558 }
559
560 /* Copy LEN bytes from inferior's memory starting at MEMADDR
561 to debugger memory starting at MYADDR. */
562 static int
563 spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
564 {
565 int fd, ret;
566 CORE_ADDR addr;
567 char annex[32], lslr_annex[32], buf[32];
568 CORE_ADDR lslr;
569
570 /* We must be stopped on a spu_run system call. */
571 if (!parse_spufs_run (&fd, &addr))
572 return 0;
573
574 /* Use the "mem" spufs file to access SPU local store. */
575 sprintf (annex, "%d/mem", fd);
576 ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
577 if (ret > 0)
578 return ret == len ? 0 : EIO;
579
580 /* SPU local store access wraps the address around at the
581 local store limit. We emulate this here. To avoid needing
582 an extra access to retrieve the LSLR, we only do that after
583 trying the original address first, and getting end-of-file. */
584 sprintf (lslr_annex, "%d/lslr", fd);
585 memset (buf, 0, sizeof buf);
586 if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
587 0, sizeof buf) <= 0)
588 return ret;
589
590 lslr = strtoul (buf, NULL, 16);
591 ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
592
593 return ret == len ? 0 : EIO;
594 }
595
596 /* Copy LEN bytes of data from debugger memory at MYADDR
597 to inferior's memory at MEMADDR.
598 On failure (cannot write the inferior)
599 returns the value of errno. */
600 static int
601 spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
602 {
603 int fd, ret;
604 CORE_ADDR addr;
605 char annex[32], lslr_annex[32], buf[32];
606 CORE_ADDR lslr;
607
608 /* We must be stopped on a spu_run system call. */
609 if (!parse_spufs_run (&fd, &addr))
610 return 0;
611
612 /* Use the "mem" spufs file to access SPU local store. */
613 sprintf (annex, "%d/mem", fd);
614 ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
615 if (ret > 0)
616 return ret == len ? 0 : EIO;
617
618 /* SPU local store access wraps the address around at the
619 local store limit. We emulate this here. To avoid needing
620 an extra access to retrieve the LSLR, we only do that after
621 trying the original address first, and getting end-of-file. */
622 sprintf (lslr_annex, "%d/lslr", fd);
623 memset (buf, 0, sizeof buf);
624 if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
625 0, sizeof buf) <= 0)
626 return ret;
627
628 lslr = strtoul (buf, NULL, 16);
629 ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
630
631 return ret == len ? 0 : EIO;
632 }
633
634 /* Look up special symbols -- unneded here. */
635 static void
636 spu_look_up_symbols (void)
637 {
638 }
639
640 /* Send signal to inferior. */
641 static void
642 spu_request_interrupt (void)
643 {
644 struct thread_info *thr = get_first_thread ();
645
646 syscall (SYS_tkill, lwpid_of (thr), SIGINT);
647 }
648
649 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
650
651 static const gdb_byte *
652 spu_sw_breakpoint_from_kind (int kind, int *size)
653 {
654 *size = sizeof breakpoint;
655 return breakpoint;
656 }
657
658 static struct target_ops spu_target_ops = {
659 spu_create_inferior,
660 NULL, /* post_create_inferior */
661 spu_attach,
662 spu_kill,
663 spu_detach,
664 spu_mourn,
665 spu_join,
666 spu_thread_alive,
667 spu_resume,
668 spu_wait,
669 spu_fetch_registers,
670 spu_store_registers,
671 NULL, /* prepare_to_access_memory */
672 NULL, /* done_accessing_memory */
673 spu_read_memory,
674 spu_write_memory,
675 spu_look_up_symbols,
676 spu_request_interrupt,
677 NULL,
678 NULL, /* supports_z_point_type */
679 NULL,
680 NULL,
681 NULL, /* stopped_by_sw_breakpoint */
682 NULL, /* supports_stopped_by_sw_breakpoint */
683 NULL, /* stopped_by_hw_breakpoint */
684 NULL, /* supports_stopped_by_hw_breakpoint */
685 NULL, /* supports_hardware_single_step */
686 NULL,
687 NULL,
688 NULL,
689 NULL,
690 spu_proc_xfer_spu,
691 hostio_last_error_from_errno,
692 NULL, /* qxfer_osdata */
693 NULL, /* qxfer_siginfo */
694 NULL, /* supports_non_stop */
695 NULL, /* async */
696 NULL, /* start_non_stop */
697 NULL, /* supports_multi_process */
698 NULL, /* supports_fork_events */
699 NULL, /* supports_vfork_events */
700 NULL, /* supports_exec_events */
701 NULL, /* handle_new_gdb_connection */
702 NULL, /* handle_monitor_command */
703 NULL, /* core_of_thread */
704 NULL, /* read_loadmap */
705 NULL, /* process_qsupported */
706 NULL, /* supports_tracepoints */
707 NULL, /* read_pc */
708 NULL, /* write_pc */
709 NULL, /* thread_stopped */
710 NULL, /* get_tib_address */
711 NULL, /* pause_all */
712 NULL, /* unpause_all */
713 NULL, /* stabilize_threads */
714 NULL, /* install_fast_tracepoint_jump_pad */
715 NULL, /* emit_ops */
716 NULL, /* supports_disable_randomization */
717 NULL, /* get_min_fast_tracepoint_insn_len */
718 NULL, /* qxfer_libraries_svr4 */
719 NULL, /* support_agent */
720 NULL, /* support_btrace */
721 NULL, /* enable_btrace */
722 NULL, /* disable_btrace */
723 NULL, /* read_btrace */
724 NULL, /* read_btrace_conf */
725 NULL, /* supports_range_stepping */
726 NULL, /* pid_to_exec_file */
727 NULL, /* multifs_open */
728 NULL, /* multifs_unlink */
729 NULL, /* multifs_readlink */
730 NULL, /* breakpoint_kind_from_pc */
731 spu_sw_breakpoint_from_kind,
732 };
733
734 void
735 initialize_low (void)
736 {
737 set_target_ops (&spu_target_ops);
738 init_registers_spu ();
739 }
string
const char * string
Definition: signals.c:50
spu_request_interrupt
static void spu_request_interrupt(void)
Definition: spu-low.c:642
collect_register
void collect_register(struct regcache *regcache, int n, void *buf)
Definition: regcache.c:402
using_threads
int using_threads
Definition: spu-low.c:54
spu_sw_breakpoint_from_kind
static const gdb_byte * spu_sw_breakpoint_from_kind(int kind, int *size)
Definition: spu-low.c:652
spu_store_registers
static void spu_store_registers(struct regcache *regcache, int regno)
Definition: spu-low.c:524
add_process
struct process_info * add_process(int pid, int attached)
Definition: inferiors.c:140
WNOHANG
#define WNOHANG
Definition: gdb_wait.h:102
spu_resume
static void spu_resume(struct thread_resume *resume_info, size_t n)
Definition: spu-low.c:391
spu_look_up_symbols
static void spu_look_up_symbols(void)
Definition: spu-low.c:636
store_ppc_memory
static int store_ppc_memory(CORE_ADDR memaddr, char *myaddr, int len)
Definition: spu-low.c:170
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
SPU_PC_REGNUM
#define SPU_PC_REGNUM
Definition: spu-low.c:47
ptid_get_pid
int ptid_get_pid(const ptid_t &ptid)
Definition: ptid.c:47
stringify_argv
std::string stringify_argv(const std::vector< char *> &args)
Definition: common-utils.c:392
lwpid_of
static long lwpid_of(const thread_info *thread)
Definition: gdbthread.h:222
spu_kill
static int spu_kill(int pid)
Definition: spu-low.c:329
ptid_of
static ptid_t ptid_of(const thread_info *thread)
Definition: gdbthread.h:206
server_waiting
int server_waiting
Definition: server.c:80
process_info
Definition: inferiors.h:34
memset
void * memset(T *s, int c, size_t n)=delete
fetch_ppc_memory
static int fetch_ppc_memory(CORE_ADDR memaddr, char *myaddr, int len)
Definition: spu-low.c:145
fcntl.h
spu_proc_xfer_spu
static int spu_proc_xfer_spu(const char *annex, unsigned char *readbuf, const unsigned char *writebuf, CORE_ADDR offset, int len)
Definition: spu-low.c:233
process_info::tdesc
const struct target_desc * tdesc
Definition: inferiors.h:67
regcache
Definition: regcache.h:31
NR_spu_run
#define NR_spu_run
Definition: spu-low.c:51
PT_WRITE_D
#define PT_WRITE_D
Definition: gdb_ptrace.h:63
ptrace
PTRACE_TYPE_RET ptrace()
ptid_build
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
PT_SYSCALL
#define PT_SYSCALL
Definition: gdb_ptrace.h:120
thread_info
Definition: gdbthread.h:30
spu_create_inferior
static int spu_create_inferior(const char *program, const std::vector< char *> &program_args)
Definition: spu-low.c:282
WSTOPSIG
#define WSTOPSIG
Definition: gdb_wait.h:75
store_ppc_memory_1
static int store_ppc_memory_1(int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
Definition: spu-low.c:125
PT_READ_I
#define PT_READ_I
Definition: gdb_ptrace.h:47
tdesc_spu
const struct target_desc * tdesc_spu
WTERMSIG
#define WTERMSIG(w)
Definition: gdb_wait.h:71
regcache_invalidate
void regcache_invalidate(void)
Definition: regcache.c:108
get_environ
gdb_environ * get_environ()
Definition: server.c:277
target_ops
Definition: target.h:66
find_process_pid
process_info * find_process_pid(int pid)
Definition: inferiors.c:164
WIFEXITED
#define WIFEXITED(w)
Definition: gdb_wait.h:44
ptid_t
Definition: ptid.h:35
offset
int offset
Definition: tracepoint.c:181
unistd.h
pid_to_ptid
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:39
breakpoint
Definition: mem-break.c:169
current_ptid
#define current_ptid
Definition: gdbthread.h:201
gdb_signal_from_host
enum gdb_signal gdb_signal_from_host(int)
Definition: signals.c:116
server.h
spu_thread_alive
static int spu_thread_alive(ptid_t ptid)
Definition: spu-low.c:384
fetch_ppc_register
static CORE_ADDR fetch_ppc_register(int regno)
Definition: spu-low.c:65
thread_resume
Definition: target.h:42
PTRACE_TYPE_ARG3
#define PTRACE_TYPE_ARG3
Definition: spu-low.c:39
remove_process
void remove_process(struct process_info *process)
Definition: inferiors.c:154
set_target_ops
void set_target_ops(struct target_ops *target)
Definition: target.c:299
spu_detach
static int spu_detach(int pid)
Definition: spu-low.c:351
WEXITSTATUS
#define WEXITSTATUS(w)
Definition: gdb_wait.h:67
INSTR_SC
#define INSTR_SC
Definition: spu-low.c:50
ptid_get_lwp
long ptid_get_lwp(const ptid_t &ptid)
Definition: ptid.c:55
__WNOTHREAD
#define __WNOTHREAD
Definition: spu-low.c:34
__WALL
#define __WALL
Definition: linux-ptrace.h:96
post_fork_inferior
void post_fork_inferior(int pid, const char *program)
Definition: fork-child.c:97
errno
#define errno
Definition: wincecompat.h:24
spu_target_ops
static struct target_ops spu_target_ops
Definition: spu-low.c:658
get_first_thread
struct thread_info * get_first_thread(void)
Definition: inferiors.c:55
PT_READ_U
#define PT_READ_U
Definition: gdb_ptrace.h:55
WIFSTOPPED
#define WIFSTOPPED(w)
Definition: gdb_wait.h:62
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
breakpoint
static const gdb_byte breakpoint[]
Definition: spu-low.c:61
fork-inferior.h
process_info::pid
int pid
Definition: inferiors.h:41
SPU_ID_REGNUM
#define SPU_ID_REGNUM
Definition: spu-low.c:46
trace_start_error_with_name
void trace_start_error_with_name(const char *string)
Definition: fork-inferior.c:613
spu_write_memory
static int spu_write_memory(CORE_ADDR memaddr, const unsigned char *myaddr, int len)
Definition: spu-low.c:601
fork_inferior
pid_t fork_inferior(const char *exec_file_arg, const std::string &allargs, char **env, void(*traceme_fun)(), void(*init_trace_fun)(int), void(*pre_trace_fun)(), const char *shell_file_arg, void(*exec_fun)(const char *file, char *const *argv, char *const *env))
Definition: fork-inferior.c:287
spu_wait
static ptid_t spu_wait(ptid_t ptid, struct target_waitstatus *ourstatus, int options)
Definition: spu-low.c:419
target_desc
Definition: tdesc.h:33
hostio.h
buffer
Definition: buffer.h:23
hostio_last_error_from_errno
void hostio_last_error_from_errno(char *buf)
Definition: hostio-errno.c:28
fetch_ppc_memory_1
static int fetch_ppc_memory_1(int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
Definition: spu-low.c:105
gdb_environ::envp
char ** envp() const
Definition: environ.c:166
perror_with_name
void perror_with_name(const char *string)
Definition: utils.c:57
spu_fetch_registers
static void spu_fetch_registers(struct regcache *regcache, int regno)
Definition: spu-low.c:487
spu_ptrace_fun
static void spu_ptrace_fun()
Definition: spu-low.c:269
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
spu_attach
int spu_attach(unsigned long pid)
Definition: spu-low.c:307
gdb_wait.h
WIFSIGNALED
#define WIFSIGNALED(w)
Definition: gdb_wait.h:48
init_registers_spu
void init_registers_spu(void)
spu_join
static void spu_join(int pid)
Definition: spu-low.c:371
initialize_low
void initialize_low(void)
Definition: spu-low.c:735
spu_mourn
static void spu_mourn(struct process_info *process)
Definition: spu-low.c:365
filestuff.h
parse_spufs_run
static int parse_spufs_run(int *fd, CORE_ADDR *addr)
Definition: spu-low.c:208
SPU_NUM_CORE_REGS
#define SPU_NUM_CORE_REGS
Definition: spu-low.c:43
program_args
static std::vector< char * > program_args
Definition: server.c:112
supply_register
void supply_register(struct regcache *regcache, int n, const void *buf)
Definition: regcache.c:318
add_thread
struct thread_info * add_thread(ptid_t ptid, void *target_data)
Definition: inferiors.c:34
spu_read_memory
static int spu_read_memory(CORE_ADDR memaddr, unsigned char *myaddr, int len)
Definition: spu-low.c:563
clear_inferiors
void clear_inferiors(void)
Definition: inferiors.c:129
minus_one_ptid
ptid_t minus_one_ptid
Definition: ptid.c:26
PTRACE_TYPE_RET
#define PTRACE_TYPE_RET
Definition: spu-low.c:38
strerror
char * strerror(int)
PTRACE_TYPE_ARG1
#define PTRACE_TYPE_ARG1
Definition: config.h:336