X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbserver%2Fspu-low.c;h=97f985ae8f832c975fd31cdd22b7996f5aa575b3;hb=a7e559cc087b10b9ea337b58e52cc13964aae3fb;hp=8307c4edba0ac6a08cfc9278ffc043bb3bf60935;hpb=5472f405e240ab93b49942eb5181a5b4987a5417;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbserver/spu-low.c b/gdb/gdbserver/spu-low.c index 8307c4edba..97f985ae8f 100644 --- a/gdb/gdbserver/spu-low.c +++ b/gdb/gdbserver/spu-low.c @@ -1,5 +1,5 @@ /* Low level interface to SPUs, for the remote server for GDB. - Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc. + Copyright (C) 2006-2019 Free Software Foundation, Inc. Contributed by Ulrich Weigand . @@ -20,15 +20,14 @@ #include "server.h" -#include -#include +#include "common/gdb_wait.h" #include #include -#include -#include #include -#include #include +#include "common/filestuff.h" +#include "hostio.h" +#include "nat/fork-inferior.h" /* Some older glibc versions do not define this. */ #ifndef __WNOTHREAD @@ -51,15 +50,15 @@ #define INSTR_SC 0x44000002 #define NR_spu_run 0x0116 -/* Get current thread ID (Linux task ID). */ -#define current_ptid ((struct inferior_list_entry *)current_inferior)->id - /* These are used in remote-utils.c. */ int using_threads = 0; /* Defined in auto-generated file reg-spu.c. */ void init_registers_spu (void); +extern const struct target_desc *tdesc_spu; +/* Software breakpoint instruction. */ +static const gdb_byte breakpoint[] = { 0x00, 0x00, 0x3f, 0xff }; /* Fetch PPU register REGNO. */ static CORE_ADDR @@ -67,7 +66,7 @@ fetch_ppc_register (int regno) { PTRACE_TYPE_RET res; - int tid = ptid_get_lwp (current_ptid); + int tid = current_ptid.lwp (); #ifndef __powerpc64__ /* If running as a 32-bit process on a 64-bit system, we attempt @@ -78,10 +77,10 @@ fetch_ppc_register (int regno) char buf[8]; errno = 0; - ptrace (PPC_PTRACE_PEEKUSR_3264, tid, + ptrace ((PTRACE_TYPE_ARG1) PPC_PTRACE_PEEKUSR_3264, tid, (PTRACE_TYPE_ARG3) (regno * 8), buf); if (errno == 0) - ptrace (PPC_PTRACE_PEEKUSR_3264, tid, + ptrace ((PTRACE_TYPE_ARG1) PPC_PTRACE_PEEKUSR_3264, tid, (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4); if (errno == 0) return (CORE_ADDR) *(unsigned long long *)buf; @@ -111,7 +110,8 @@ fetch_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word) if (memaddr >> 32) { unsigned long long addr_8 = (unsigned long long) memaddr; - ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word); + ptrace ((PTRACE_TYPE_ARG1) PPC_PTRACE_PEEKTEXT_3264, tid, + (PTRACE_TYPE_ARG3) &addr_8, word); } else #endif @@ -130,7 +130,8 @@ store_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word) if (memaddr >> 32) { unsigned long long addr_8 = (unsigned long long) memaddr; - ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word); + ptrace ((PTRACE_TYPE_ARG1) PPC_PTRACE_POKEDATA_3264, tid, + (PTRACE_TYPE_ARG3) &addr_8, word); } else #endif @@ -150,9 +151,9 @@ fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len) / sizeof (PTRACE_TYPE_RET)); PTRACE_TYPE_RET *buffer; - int tid = ptid_get_lwp (current_ptid); + int tid = current_ptid.lwp (); - buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET)); + buffer = XALLOCAVEC (PTRACE_TYPE_RET, count); for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET)) if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0) return ret; @@ -175,9 +176,9 @@ store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len) / sizeof (PTRACE_TYPE_RET)); PTRACE_TYPE_RET *buffer; - int tid = ptid_get_lwp (current_ptid); + int tid = current_ptid.lwp (); - buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET)); + buffer = XALLOCAVEC (PTRACE_TYPE_RET, count); if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET)) if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0) @@ -206,14 +207,14 @@ store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len) static int parse_spufs_run (int *fd, CORE_ADDR *addr) { - char buf[4]; + unsigned int insn; CORE_ADDR pc = fetch_ppc_register (32); /* nip */ /* Fetch instruction preceding current NIP. */ - if (fetch_ppc_memory (pc-4, buf, 4) != 0) + if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0) return 0; /* It should be a "sc" instruction. */ - if (*(unsigned int *)buf != INSTR_SC) + if (insn != INSTR_SC) return 0; /* System call number should be NR_spu_run. */ if (fetch_ppc_register (0) != NR_spu_run) @@ -240,7 +241,7 @@ spu_proc_xfer_spu (const char *annex, unsigned char *readbuf, if (!annex) return 0; - sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex); + sprintf (buf, "/proc/%ld/fd/%s", current_ptid.lwp (), annex); fd = open (buf, writebuf? O_WRONLY : O_RDONLY); if (fd <= 0) return -1; @@ -261,38 +262,42 @@ spu_proc_xfer_spu (const char *annex, unsigned char *readbuf, return ret; } +/* Callback to be used when calling fork_inferior, responsible for + actually initiating the tracing of the inferior. */ + +static void +spu_ptrace_fun () +{ + if (ptrace (PTRACE_TRACEME, 0, 0, 0) < 0) + trace_start_error_with_name ("ptrace"); + if (setpgid (0, 0) < 0) + trace_start_error_with_name ("setpgid"); +} /* Start an inferior process and returns its pid. - ALLARGS is a vector of program-name and args. */ + PROGRAM is the name of the program to be started, and PROGRAM_ARGS + are its arguments. */ + static int -spu_create_inferior (char *program, char **allargs) +spu_create_inferior (const char *program, + const std::vector &program_args) { int pid; ptid_t ptid; + struct process_info *proc; + std::string str_program_args = stringify_argv (program_args); - pid = fork (); - if (pid < 0) - perror_with_name ("fork"); + pid = fork_inferior (program, + str_program_args.c_str (), + get_environ ()->envp (), spu_ptrace_fun, + NULL, NULL, NULL, NULL); - if (pid == 0) - { - ptrace (PTRACE_TRACEME, 0, 0, 0); - - setpgid (0, 0); + post_fork_inferior (pid, program); - execv (program, allargs); - if (errno == ENOENT) - execvp (program, allargs); + proc = add_process (pid, 0); + proc->tdesc = tdesc_spu; - fprintf (stderr, "Cannot exec %s: %s.\n", program, - strerror (errno)); - fflush (stderr); - _exit (0177); - } - - add_process (pid, 0); - - ptid = ptid_build (pid, pid, 0); + ptid = ptid_t (pid, pid, 0); add_thread (ptid, NULL); return pid; } @@ -302,6 +307,7 @@ int spu_attach (unsigned long pid) { ptid_t ptid; + struct process_info *proc; if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0) { @@ -311,47 +317,54 @@ spu_attach (unsigned long pid) _exit (0177); } - add_process (pid, 1); - ptid = ptid_build (pid, pid, 0); + proc = add_process (pid, 1); + proc->tdesc = tdesc_spu; + ptid = ptid_t (pid, pid, 0); add_thread (ptid, NULL); return 0; } /* Kill the inferior process. */ static int -spu_kill (int pid) +spu_kill (process_info *process) { - struct process_info *process = find_process_pid (pid); - if (process == NULL) - return -1; + int status, ret; + int pid = process->pid; ptrace (PTRACE_KILL, pid, 0, 0); + + do { + ret = waitpid (pid, &status, 0); + if (WIFEXITED (status) || WIFSIGNALED (status)) + break; + } while (ret != -1 || errno != ECHILD); + + clear_inferiors (); remove_process (process); return 0; } /* Detach from inferior process. */ static int -spu_detach (int pid) +spu_detach (process_info *process) { - struct process_info *process = find_process_pid (pid); - if (process == NULL) - return -1; + ptrace (PTRACE_DETACH, process->pid, 0, 0); - ptrace (PTRACE_DETACH, pid, 0, 0); + clear_inferiors (); remove_process (process); return 0; } +static void +spu_mourn (struct process_info *process) +{ + remove_process (process); +} + static void spu_join (int pid) { int status, ret; - struct process_info *process; - - process = find_process_pid (pid); - if (process == NULL) - return; do { ret = waitpid (pid, &status, 0); @@ -364,18 +377,19 @@ spu_join (int pid) static int spu_thread_alive (ptid_t ptid) { - return ptid_equal (ptid, current_ptid); + return ptid == current_ptid; } /* Resume process. */ static void spu_resume (struct thread_resume *resume_info, size_t n) { + struct thread_info *thr = get_first_thread (); size_t i; for (i = 0; i < n; i++) - if (ptid_equal (resume_info[i].thread, minus_one_ptid) - || ptid_equal (resume_info[i].thread, current_ptid)) + if (resume_info[i].thread == minus_one_ptid + || resume_info[i].thread == ptid_of (thr)) break; if (i == n) @@ -389,7 +403,7 @@ spu_resume (struct thread_resume *resume_info, size_t n) regcache_invalidate (); errno = 0; - ptrace (PTRACE_CONT, ptid_get_lwp (current_ptid), 0, resume_info[i].sig); + ptrace (PTRACE_CONT, ptid_of (thr).lwp (), 0, resume_info[i].sig); if (errno) perror_with_name ("ptrace"); } @@ -398,7 +412,7 @@ spu_resume (struct thread_resume *resume_info, size_t n) static ptid_t spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options) { - int pid = ptid_get_pid (ptid); + int pid = ptid.pid (); int w; int ret; @@ -437,17 +451,15 @@ spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options) ourstatus->kind = TARGET_WAITKIND_EXITED; ourstatus->value.integer = WEXITSTATUS (w); clear_inferiors (); - remove_process (find_process_pid (ret)); - return pid_to_ptid (ret); + return ptid_t (ret); } else if (!WIFSTOPPED (w)) { fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w)); ourstatus->kind = TARGET_WAITKIND_SIGNALLED; - ourstatus->value.sig = target_signal_from_host (WTERMSIG (w)); + ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w)); clear_inferiors (); - remove_process (find_process_pid (ret)); - return pid_to_ptid (ret); + return ptid_t (ret); } /* After attach, we may have received a SIGSTOP. Do not return this @@ -455,40 +467,36 @@ spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options) if (!server_waiting) { ourstatus->kind = TARGET_WAITKIND_STOPPED; - ourstatus->value.sig = TARGET_SIGNAL_0; - return ptid_build (ret, ret, 0); + ourstatus->value.sig = GDB_SIGNAL_0; + return ptid_t (ret, ret, 0); } ourstatus->kind = TARGET_WAITKIND_STOPPED; - ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w)); - return ptid_build (ret, ret, 0); + ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w)); + return ptid_t (ret, ret, 0); } /* Fetch inferior registers. */ static void -spu_fetch_registers (int regno) +spu_fetch_registers (struct regcache *regcache, int regno) { int fd; CORE_ADDR addr; - /* ??? Some callers use 0 to mean all registers. */ - if (regno == 0) - regno = -1; - /* We must be stopped on a spu_run system call. */ if (!parse_spufs_run (&fd, &addr)) return; /* The ID register holds the spufs file handle. */ if (regno == -1 || regno == SPU_ID_REGNUM) - supply_register (SPU_ID_REGNUM, (char *)&fd); + supply_register (regcache, SPU_ID_REGNUM, (char *)&fd); /* The NPC register is found at ADDR. */ if (regno == -1 || regno == SPU_PC_REGNUM) { char buf[4]; if (fetch_ppc_memory (addr, buf, 4) == 0) - supply_register (SPU_PC_REGNUM, buf); + supply_register (regcache, SPU_PC_REGNUM, buf); } /* The GPRs are found in the "regs" spufs file. */ @@ -501,13 +509,13 @@ spu_fetch_registers (int regno) sprintf (annex, "%d/regs", fd); if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf) for (i = 0; i < SPU_NUM_CORE_REGS; i++) - supply_register (i, buf + i*16); + supply_register (regcache, i, buf + i*16); } } /* Store inferior registers. */ static void -spu_store_registers (int regno) +spu_store_registers (struct regcache *regcache, int regno) { int fd; CORE_ADDR addr; @@ -524,7 +532,7 @@ spu_store_registers (int regno) if (regno == -1 || regno == SPU_PC_REGNUM) { char buf[4]; - collect_register (SPU_PC_REGNUM, buf); + collect_register (regcache, SPU_PC_REGNUM, buf); store_ppc_memory (addr, buf, 4); } @@ -536,7 +544,7 @@ spu_store_registers (int regno) int i; for (i = 0; i < SPU_NUM_CORE_REGS; i++) - collect_register (i, buf + i*16); + collect_register (regcache, i, buf + i*16); sprintf (annex, "%d/regs", fd); spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf); @@ -550,7 +558,8 @@ spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) { int fd, ret; CORE_ADDR addr; - char annex[32]; + char annex[32], lslr_annex[32], buf[32]; + CORE_ADDR lslr; /* We must be stopped on a spu_run system call. */ if (!parse_spufs_run (&fd, &addr)) @@ -559,6 +568,22 @@ spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) /* Use the "mem" spufs file to access SPU local store. */ sprintf (annex, "%d/mem", fd); ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len); + if (ret > 0) + return ret == len ? 0 : EIO; + + /* SPU local store access wraps the address around at the + local store limit. We emulate this here. To avoid needing + an extra access to retrieve the LSLR, we only do that after + trying the original address first, and getting end-of-file. */ + sprintf (lslr_annex, "%d/lslr", fd); + memset (buf, 0, sizeof buf); + if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL, + 0, sizeof buf) <= 0) + return ret; + + lslr = strtoul (buf, NULL, 16); + ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len); + return ret == len ? 0 : EIO; } @@ -571,7 +596,8 @@ spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len) { int fd, ret; CORE_ADDR addr; - char annex[32]; + char annex[32], lslr_annex[32], buf[32]; + CORE_ADDR lslr; /* We must be stopped on a spu_run system call. */ if (!parse_spufs_run (&fd, &addr)) @@ -580,6 +606,22 @@ spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len) /* Use the "mem" spufs file to access SPU local store. */ sprintf (annex, "%d/mem", fd); ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len); + if (ret > 0) + return ret == len ? 0 : EIO; + + /* SPU local store access wraps the address around at the + local store limit. We emulate this here. To avoid needing + an extra access to retrieve the LSLR, we only do that after + trying the original address first, and getting end-of-file. */ + sprintf (lslr_annex, "%d/lslr", fd); + memset (buf, 0, sizeof buf); + if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL, + 0, sizeof buf) <= 0) + return ret; + + lslr = strtoul (buf, NULL, 16); + ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len); + return ret == len ? 0 : EIO; } @@ -593,41 +635,98 @@ spu_look_up_symbols (void) static void spu_request_interrupt (void) { - syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT); + struct thread_info *thr = get_first_thread (); + + syscall (SYS_tkill, lwpid_of (thr), SIGINT); +} + +/* Implementation of the target_ops method "sw_breakpoint_from_kind". */ + +static const gdb_byte * +spu_sw_breakpoint_from_kind (int kind, int *size) +{ + *size = sizeof breakpoint; + return breakpoint; } static struct target_ops spu_target_ops = { spu_create_inferior, + NULL, /* post_create_inferior */ spu_attach, spu_kill, spu_detach, + spu_mourn, spu_join, spu_thread_alive, spu_resume, spu_wait, spu_fetch_registers, spu_store_registers, + NULL, /* prepare_to_access_memory */ + NULL, /* done_accessing_memory */ spu_read_memory, spu_write_memory, spu_look_up_symbols, spu_request_interrupt, NULL, + NULL, /* supports_z_point_type */ NULL, NULL, + NULL, /* stopped_by_sw_breakpoint */ + NULL, /* supports_stopped_by_sw_breakpoint */ + NULL, /* stopped_by_hw_breakpoint */ + NULL, /* supports_stopped_by_hw_breakpoint */ + NULL, /* supports_hardware_single_step */ NULL, NULL, NULL, NULL, spu_proc_xfer_spu, hostio_last_error_from_errno, + NULL, /* qxfer_osdata */ + NULL, /* qxfer_siginfo */ + NULL, /* supports_non_stop */ + NULL, /* async */ + NULL, /* start_non_stop */ + NULL, /* supports_multi_process */ + NULL, /* supports_fork_events */ + NULL, /* supports_vfork_events */ + NULL, /* supports_exec_events */ + NULL, /* handle_new_gdb_connection */ + NULL, /* handle_monitor_command */ + NULL, /* core_of_thread */ + NULL, /* read_loadmap */ + NULL, /* process_qsupported */ + NULL, /* supports_tracepoints */ + NULL, /* read_pc */ + NULL, /* write_pc */ + NULL, /* thread_stopped */ + NULL, /* get_tib_address */ + NULL, /* pause_all */ + NULL, /* unpause_all */ + NULL, /* stabilize_threads */ + NULL, /* install_fast_tracepoint_jump_pad */ + NULL, /* emit_ops */ + NULL, /* supports_disable_randomization */ + NULL, /* get_min_fast_tracepoint_insn_len */ + NULL, /* qxfer_libraries_svr4 */ + NULL, /* support_agent */ + NULL, /* enable_btrace */ + NULL, /* disable_btrace */ + NULL, /* read_btrace */ + NULL, /* read_btrace_conf */ + NULL, /* supports_range_stepping */ + NULL, /* pid_to_exec_file */ + NULL, /* multifs_open */ + NULL, /* multifs_unlink */ + NULL, /* multifs_readlink */ + NULL, /* breakpoint_kind_from_pc */ + spu_sw_breakpoint_from_kind, }; void initialize_low (void) { - static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff }; - set_target_ops (&spu_target_ops); - set_breakpoint_data (breakpoint, sizeof breakpoint); init_registers_spu (); }