gdb/spu-linux-nat.c

   1 /* SPU native-dependent code for GDB, the GNU debugger.
   2    Copyright (C) 2006, 2007 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 2 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, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "defs.h"
  24 #include "gdbcore.h"
  25 #include "gdb_string.h"
  26 #include "target.h"
  27 #include "inferior.h"
  28 #include "inf-ptrace.h"
  29 #include "regcache.h"
  30 #include "symfile.h"
  31 #include "gdb_wait.h"
  32 #include "gdb_stdint.h"
  33
  34 #include <sys/ptrace.h>
  35 #include <asm/ptrace.h>
  36 #include <sys/types.h>
  37 #include <sys/param.h>
  38
  39 #include "spu-tdep.h"
  40
  41 /* PPU side system calls.  */
  42 #define INSTR_SC        0x44000002
  43 #define NR_spu_run      0x0116
  44
  45
  46 /* Fetch PPU register REGNO.  */
  47 static ULONGEST
  48 fetch_ppc_register (int regno)
  49 {
  50   PTRACE_TYPE_RET res;
  51
  52   int tid = TIDGET (inferior_ptid);
  53   if (tid == 0)
  54     tid = PIDGET (inferior_ptid);
  55
  56 #ifndef __powerpc64__
  57   /* If running as a 32-bit process on a 64-bit system, we attempt
  58      to get the full 64-bit register content of the target process.
  59      If the PPC special ptrace call fails, we're on a 32-bit system;
  60      just fall through to the regular ptrace call in that case.  */
  61   {
  62     gdb_byte buf[8];
  63
  64     errno = 0;
  65     ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  66             (PTRACE_TYPE_ARG3) (regno * 8), buf);
  67     if (errno == 0)
  68       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  69               (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
  70     if (errno == 0)
  71       return (ULONGEST) *(uint64_t *)buf;
  72   }
  73 #endif
  74
  75   errno = 0;
  76   res = ptrace (PT_READ_U, tid,
  77                 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
  78   if (errno != 0)
  79     {
  80       char mess[128];
  81       xsnprintf (mess, sizeof mess, "reading PPC register #%d", regno);
  82       perror_with_name (_(mess));
  83     }
  84
  85   return (ULONGEST) (unsigned long) res;
  86 }
  87
  88 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
  89 static int
  90 fetch_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET *word)
  91 {
  92   errno = 0;
  93
  94 #ifndef __powerpc64__
  95   if (memaddr >> 32)
  96     {
  97       uint64_t addr_8 = (uint64_t) memaddr;
  98       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
  99     }
 100   else
 101 #endif
 102     *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
 103
 104   return errno;
 105 }
 106
 107 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
 108 static int
 109 store_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET word)
 110 {
 111   errno = 0;
 112
 113 #ifndef __powerpc64__
 114   if (memaddr >> 32)
 115     {
 116       uint64_t addr_8 = (uint64_t) memaddr;
 117       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 118     }
 119   else
 120 #endif
 121     ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
 122
 123   return errno;
 124 }
 125
 126 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
 127 static int
 128 fetch_ppc_memory (ULONGEST memaddr, gdb_byte *myaddr, int len)
 129 {
 130   int i, ret;
 131
 132   ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 133   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 134                / sizeof (PTRACE_TYPE_RET));
 135   PTRACE_TYPE_RET *buffer;
 136
 137   int tid = TIDGET (inferior_ptid);
 138   if (tid == 0)
 139     tid = PIDGET (inferior_ptid);
 140
 141   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 142   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 143     {
 144       ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
 145       if (ret)
 146         return ret;
 147     }
 148
 149   memcpy (myaddr,
 150           (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 151           len);
 152
 153   return 0;
 154 }
 155
 156 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
 157 static int
 158 store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
 159 {
 160   int i, ret;
 161
 162   ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 163   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 164                / sizeof (PTRACE_TYPE_RET));
 165   PTRACE_TYPE_RET *buffer;
 166
 167   int tid = TIDGET (inferior_ptid);
 168   if (tid == 0)
 169     tid = PIDGET (inferior_ptid);
 170
 171   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 172
 173   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 174     {
 175       ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
 176       if (ret)
 177         return ret;
 178     }
 179
 180   if (count > 1)
 181     {
 182       ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
 183                                                * sizeof (PTRACE_TYPE_RET),
 184                                 &buffer[count - 1]);
 185       if (ret)
 186         return ret;
 187     }
 188
 189   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 190           myaddr, len);
 191
 192   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 193     {
 194       ret = store_ppc_memory_1 (tid, addr, buffer[i]);
 195       if (ret)
 196         return ret;
 197     }
 198
 199   return 0;
 200 }
 201
 202
 203 /* If the PPU thread is currently stopped on a spu_run system call,
 204    return to FD and ADDR the file handle and NPC parameter address
 205    used with the system call.  Return non-zero if successful.  */
 206 static int
 207 parse_spufs_run (int *fd, ULONGEST *addr)
 208 {
 209   gdb_byte buf[4];
 210   ULONGEST pc = fetch_ppc_register (32);  /* nip */
 211
 212   /* Fetch instruction preceding current NIP.  */
 213   if (fetch_ppc_memory (pc-4, buf, 4) != 0)
 214     return 0;
 215   /* It should be a "sc" instruction.  */
 216   if (extract_unsigned_integer (buf, 4) != INSTR_SC)
 217     return 0;
 218   /* System call number should be NR_spu_run.  */
 219   if (fetch_ppc_register (0) != NR_spu_run)
 220     return 0;
 221
 222   /* Register 3 contains fd, register 4 the NPC param pointer.  */
 223   *fd = fetch_ppc_register (34);  /* orig_gpr3 */
 224   *addr = fetch_ppc_register (4);
 225   return 1;
 226 }
 227
 228
 229 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
 230    using the /proc file system.  */
 231 static LONGEST
 232 spu_proc_xfer_spu (const char *annex, gdb_byte *readbuf,
 233                    const gdb_byte *writebuf,
 234                    ULONGEST offset, LONGEST len)
 235 {
 236   char buf[128];
 237   int fd = 0;
 238   int ret = -1;
 239   int pid = PIDGET (inferior_ptid);
 240
 241   if (!annex)
 242     return 0;
 243
 244   xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, 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 -1;
 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
 266 /* Inferior memory should contain an SPE executable image at location ADDR.
 267    Allocate a BFD representing that executable.  Return NULL on error.  */
 268
 269 static void *
 270 spu_bfd_iovec_open (struct bfd *nbfd, void *open_closure)
 271 {
 272   return open_closure;
 273 }
 274
 275 static int
 276 spu_bfd_iovec_close (struct bfd *nbfd, void *stream)
 277 {
 278   xfree (stream);
 279   return 1;
 280 }
 281
 282 static file_ptr
 283 spu_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
 284                      file_ptr nbytes, file_ptr offset)
 285 {
 286   ULONGEST addr = *(ULONGEST *)stream;
 287
 288   if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
 289     {
 290       bfd_set_error (bfd_error_invalid_operation);
 291       return -1;
 292     }
 293
 294   return nbytes;
 295 }
 296
 297 static int
 298 spu_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 299 {
 300   /* We don't have an easy way of finding the size of embedded spu
 301      images.  We could parse the in-memory ELF header and section
 302      table to find the extent of the last section but that seems
 303      pointless when the size is needed only for checks of other
 304      parsed values in dbxread.c.  */
 305   sb->st_size = INT_MAX;
 306   return 0;
 307 }
 308
 309 static bfd *
 310 spu_bfd_open (ULONGEST addr)
 311 {
 312   struct bfd *nbfd;
 313
 314   ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
 315   *open_closure = addr;
 316
 317   nbfd = bfd_openr_iovec (xstrdup ("<in-memory>"), "elf32-spu",
 318                           spu_bfd_iovec_open, open_closure,
 319                           spu_bfd_iovec_pread, spu_bfd_iovec_close,
 320                           spu_bfd_iovec_stat);
 321   if (!nbfd)
 322     return NULL;
 323
 324   if (!bfd_check_format (nbfd, bfd_object))
 325     {
 326       bfd_close (nbfd);
 327       return NULL;
 328     }
 329
 330   return nbfd;
 331 }
 332
 333 /* INFERIOR_FD is a file handle passed by the inferior to the
 334    spu_run system call.  Assuming the SPE context was allocated
 335    by the libspe library, try to retrieve the main SPE executable
 336    file from its copy within the target process.  */
 337 static void
 338 spu_symbol_file_add_from_memory (int inferior_fd)
 339 {
 340   ULONGEST addr;
 341   struct bfd *nbfd;
 342
 343   char id[128];
 344   char annex[32];
 345   int len;
 346
 347   /* Read object ID.  */
 348   xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
 349   len = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id);
 350   if (len <= 0 || len >= sizeof id)
 351     return;
 352   id[len] = 0;
 353   addr = strtoulst (id, NULL, 16);
 354   if (!addr)
 355     return;
 356
 357   /* Open BFD representing SPE executable and read its symbols.  */
 358   nbfd = spu_bfd_open (addr);
 359   if (nbfd)
 360     symbol_file_add_from_bfd (nbfd, 0, NULL, 1, 0);
 361 }
 362
 363
 364 /* Override the post_startup_inferior routine to continue running
 365    the inferior until the first spu_run system call.  */
 366 static void
 367 spu_child_post_startup_inferior (ptid_t ptid)
 368 {
 369   int fd;
 370   ULONGEST addr;
 371
 372   int tid = TIDGET (ptid);
 373   if (tid == 0)
 374     tid = PIDGET (ptid);
 375
 376   while (!parse_spufs_run (&fd, &addr))
 377     {
 378       ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
 379       waitpid (tid, NULL, __WALL | __WNOTHREAD);
 380     }
 381 }
 382
 383 /* Override the post_attach routine to try load the SPE executable
 384    file image from its copy inside the target process.  */
 385 static void
 386 spu_child_post_attach (int pid)
 387 {
 388   int fd;
 389   ULONGEST addr;
 390
 391   /* Like child_post_startup_inferior, if we happened to attach to
 392      the inferior while it wasn't currently in spu_run, continue
 393      running it until we get back there.  */
 394   while (!parse_spufs_run (&fd, &addr))
 395     {
 396       ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
 397       waitpid (pid, NULL, __WALL | __WNOTHREAD);
 398     }
 399
 400   /* If the user has not provided an executable file, try to extract
 401      the image from inside the target process.  */
 402   if (!get_exec_file (0))
 403     spu_symbol_file_add_from_memory (fd);
 404 }
 405
 406 /* Wait for child PTID to do something.  Return id of the child,
 407    minus_one_ptid in case of error; store status into *OURSTATUS.  */
 408 static ptid_t
 409 spu_child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 410 {
 411   int save_errno;
 412   int status;
 413   pid_t pid;
 414
 415   do
 416     {
 417       set_sigint_trap ();       /* Causes SIGINT to be passed on to the
 418                                    attached process.  */
 419       set_sigio_trap ();
 420
 421       pid = waitpid (PIDGET (ptid), &status, 0);
 422       if (pid == -1 && errno == ECHILD)
 423         /* Try again with __WCLONE to check cloned processes.  */
 424         pid = waitpid (PIDGET (ptid), &status, __WCLONE);
 425
 426       save_errno = errno;
 427
 428       /* Make sure we don't report an event for the exit of the
 429          original program, if we've detached from it.  */
 430       if (pid != -1 && !WIFSTOPPED (status) && pid != PIDGET (inferior_ptid))
 431         {
 432           pid = -1;
 433           save_errno = EINTR;
 434         }
 435
 436       clear_sigio_trap ();
 437       clear_sigint_trap ();
 438     }
 439   while (pid == -1 && save_errno == EINTR);
 440
 441   if (pid == -1)
 442     {
 443       warning (_("Child process unexpectedly missing: %s"),
 444                safe_strerror (save_errno));
 445
 446       /* Claim it exited with unknown signal.  */
 447       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 448       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 449       return minus_one_ptid;
 450     }
 451
 452   store_waitstatus (ourstatus, status);
 453   return pid_to_ptid (pid);
 454 }
 455
 456 /* Override the fetch_inferior_register routine.  */
 457 static void
 458 spu_fetch_inferior_registers (struct regcache *regcache, int regno)
 459 {
 460   int fd;
 461   ULONGEST addr;
 462
 463   /* We must be stopped on a spu_run system call.  */
 464   if (!parse_spufs_run (&fd, &addr))
 465     return;
 466
 467   /* The ID register holds the spufs file handle.  */
 468   if (regno == -1 || regno == SPU_ID_REGNUM)
 469     {
 470       char buf[4];
 471       store_unsigned_integer (buf, 4, fd);
 472       regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
 473     }
 474
 475   /* The NPC register is found at ADDR.  */
 476   if (regno == -1 || regno == SPU_PC_REGNUM)
 477     {
 478       gdb_byte buf[4];
 479       if (fetch_ppc_memory (addr, buf, 4) == 0)
 480         regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
 481     }
 482
 483   /* The GPRs are found in the "regs" spufs file.  */
 484   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
 485     {
 486       gdb_byte buf[16 * SPU_NUM_GPRS];
 487       char annex[32];
 488       int i;
 489
 490       xsnprintf (annex, sizeof annex, "%d/regs", fd);
 491       if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
 492         for (i = 0; i < SPU_NUM_GPRS; i++)
 493           regcache_raw_supply (regcache, i, buf + i*16);
 494     }
 495 }
 496
 497 /* Override the store_inferior_register routine.  */
 498 static void
 499 spu_store_inferior_registers (struct regcache *regcache, int regno)
 500 {
 501   int fd;
 502   ULONGEST addr;
 503
 504   /* We must be stopped on a spu_run system call.  */
 505   if (!parse_spufs_run (&fd, &addr))
 506     return;
 507
 508   /* The NPC register is found at ADDR.  */
 509   if (regno == -1 || regno == SPU_PC_REGNUM)
 510     {
 511       gdb_byte buf[4];
 512       regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
 513       store_ppc_memory (addr, buf, 4);
 514     }
 515
 516   /* The GPRs are found in the "regs" spufs file.  */
 517   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
 518     {
 519       gdb_byte buf[16 * SPU_NUM_GPRS];
 520       char annex[32];
 521       int i;
 522
 523       for (i = 0; i < SPU_NUM_GPRS; i++)
 524         regcache_raw_collect (regcache, i, buf + i*16);
 525
 526       xsnprintf (annex, sizeof annex, "%d/regs", fd);
 527       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
 528     }
 529 }
 530
 531 /* Override the to_xfer_partial routine.  */
 532 static LONGEST
 533 spu_xfer_partial (struct target_ops *ops,
 534                   enum target_object object, const char *annex,
 535                   gdb_byte *readbuf, const gdb_byte *writebuf,
 536                   ULONGEST offset, LONGEST len)
 537 {
 538   if (object == TARGET_OBJECT_MEMORY)
 539     {
 540       int fd;
 541       ULONGEST addr;
 542       char mem_annex[32];
 543
 544       /* We must be stopped on a spu_run system call.  */
 545       if (!parse_spufs_run (&fd, &addr))
 546         return 0;
 547
 548       /* Use the "mem" spufs file to access SPU local store.  */
 549       xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
 550       return spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
 551     }
 552
 553   return -1;
 554 }
 555
 556 /* Override the to_can_use_hw_breakpoint routine.  */
 557 static int
 558 spu_can_use_hw_breakpoint (int type, int cnt, int othertype)
 559 {
 560   return 0;
 561 }
 562
 563
 564 /* Initialize SPU native target.  */
 565 void
 566 _initialize_spu_nat (void)
 567 {
 568   /* Generic ptrace methods.  */
 569   struct target_ops *t;
 570   t = inf_ptrace_target ();
 571
 572   /* Add SPU methods.  */
 573   t->to_post_attach = spu_child_post_attach;
 574   t->to_post_startup_inferior = spu_child_post_startup_inferior;
 575   t->to_wait = spu_child_wait;
 576   t->to_fetch_registers = spu_fetch_inferior_registers;
 577   t->to_store_registers = spu_store_inferior_registers;
 578   t->to_xfer_partial = spu_xfer_partial;
 579   t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
 580
 581   /* Register SPU target.  */
 582   add_target (t);
 583 }
 584