gdb/spu-linux-nat.c

   1 /* SPU native-dependent code for GDB, the GNU debugger.
   2    Copyright (C) 2006-2012 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 "defs.h"
  22 #include "gdbcore.h"
  23 #include "gdb_string.h"
  24 #include "target.h"
  25 #include "inferior.h"
  26 #include "inf-child.h"
  27 #include "inf-ptrace.h"
  28 #include "regcache.h"
  29 #include "symfile.h"
  30 #include "gdb_wait.h"
  31 #include "gdbthread.h"
  32 #include "gdb_bfd.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   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 210   gdb_byte buf[4];
 211   ULONGEST pc = fetch_ppc_register (32);  /* nip */
 212
 213   /* Fetch instruction preceding current NIP.  */
 214   if (fetch_ppc_memory (pc-4, buf, 4) != 0)
 215     return 0;
 216   /* It should be a "sc" instruction.  */
 217   if (extract_unsigned_integer (buf, 4, byte_order) != 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 LONGEST
 233 spu_proc_xfer_spu (const char *annex, gdb_byte *readbuf,
 234                    const gdb_byte *writebuf,
 235                    ULONGEST offset, LONGEST len)
 236 {
 237   char buf[128];
 238   int fd = 0;
 239   int ret = -1;
 240   int pid = PIDGET (inferior_ptid);
 241
 242   if (!annex)
 243     return 0;
 244
 245   xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
 246   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
 247   if (fd <= 0)
 248     return -1;
 249
 250   if (offset != 0
 251       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
 252     {
 253       close (fd);
 254       return 0;
 255     }
 256
 257   if (writebuf)
 258     ret = write (fd, writebuf, (size_t) len);
 259   else if (readbuf)
 260     ret = read (fd, readbuf, (size_t) len);
 261
 262   close (fd);
 263   return ret;
 264 }
 265
 266
 267 /* Inferior memory should contain an SPE executable image at location ADDR.
 268    Allocate a BFD representing that executable.  Return NULL on error.  */
 269
 270 static void *
 271 spu_bfd_iovec_open (struct bfd *nbfd, void *open_closure)
 272 {
 273   return open_closure;
 274 }
 275
 276 static int
 277 spu_bfd_iovec_close (struct bfd *nbfd, void *stream)
 278 {
 279   xfree (stream);
 280   return 1;
 281 }
 282
 283 static file_ptr
 284 spu_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
 285                      file_ptr nbytes, file_ptr offset)
 286 {
 287   ULONGEST addr = *(ULONGEST *)stream;
 288
 289   if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
 290     {
 291       bfd_set_error (bfd_error_invalid_operation);
 292       return -1;
 293     }
 294
 295   return nbytes;
 296 }
 297
 298 static int
 299 spu_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 300 {
 301   /* We don't have an easy way of finding the size of embedded spu
 302      images.  We could parse the in-memory ELF header and section
 303      table to find the extent of the last section but that seems
 304      pointless when the size is needed only for checks of other
 305      parsed values in dbxread.c.  */
 306   sb->st_size = INT_MAX;
 307   return 0;
 308 }
 309
 310 static bfd *
 311 spu_bfd_open (ULONGEST addr)
 312 {
 313   struct bfd *nbfd;
 314   asection *spu_name;
 315
 316   ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
 317   *open_closure = addr;
 318
 319   nbfd = gdb_bfd_openr_iovec ("<in-memory>", "elf32-spu",
 320                               spu_bfd_iovec_open, open_closure,
 321                               spu_bfd_iovec_pread, spu_bfd_iovec_close,
 322                               spu_bfd_iovec_stat);
 323   if (!nbfd)
 324     return NULL;
 325
 326   if (!bfd_check_format (nbfd, bfd_object))
 327     {
 328       gdb_bfd_unref (nbfd);
 329       return NULL;
 330     }
 331
 332   /* Retrieve SPU name note and update BFD name.  */
 333   spu_name = bfd_get_section_by_name (nbfd, ".note.spu_name");
 334   if (spu_name)
 335     {
 336       int sect_size = bfd_section_size (nbfd, spu_name);
 337       if (sect_size > 20)
 338         {
 339           char *buf = alloca (sect_size - 20 + 1);
 340           bfd_get_section_contents (nbfd, spu_name, buf, 20, sect_size - 20);
 341           buf[sect_size - 20] = '\0';
 342
 343           xfree ((char *)nbfd->filename);
 344           nbfd->filename = xstrdup (buf);
 345         }
 346     }
 347
 348   return nbfd;
 349 }
 350
 351 /* INFERIOR_FD is a file handle passed by the inferior to the
 352    spu_run system call.  Assuming the SPE context was allocated
 353    by the libspe library, try to retrieve the main SPE executable
 354    file from its copy within the target process.  */
 355 static void
 356 spu_symbol_file_add_from_memory (int inferior_fd)
 357 {
 358   ULONGEST addr;
 359   struct bfd *nbfd;
 360
 361   char id[128];
 362   char annex[32];
 363   int len;
 364
 365   /* Read object ID.  */
 366   xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
 367   len = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id);
 368   if (len <= 0 || len >= sizeof id)
 369     return;
 370   id[len] = 0;
 371   addr = strtoulst (id, NULL, 16);
 372   if (!addr)
 373     return;
 374
 375   /* Open BFD representing SPE executable and read its symbols.  */
 376   nbfd = spu_bfd_open (addr);
 377   if (nbfd)
 378     {
 379       struct cleanup *cleanup = make_cleanup_bfd_unref (nbfd);
 380
 381       symbol_file_add_from_bfd (nbfd, SYMFILE_VERBOSE | SYMFILE_MAINLINE,
 382                                 NULL, 0, NULL);
 383       do_cleanups (cleanup);
 384     }
 385 }
 386
 387
 388 /* Override the post_startup_inferior routine to continue running
 389    the inferior until the first spu_run system call.  */
 390 static void
 391 spu_child_post_startup_inferior (ptid_t ptid)
 392 {
 393   int fd;
 394   ULONGEST addr;
 395
 396   int tid = TIDGET (ptid);
 397   if (tid == 0)
 398     tid = PIDGET (ptid);
 399
 400   while (!parse_spufs_run (&fd, &addr))
 401     {
 402       ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
 403       waitpid (tid, NULL, __WALL | __WNOTHREAD);
 404     }
 405 }
 406
 407 /* Override the post_attach routine to try load the SPE executable
 408    file image from its copy inside the target process.  */
 409 static void
 410 spu_child_post_attach (int pid)
 411 {
 412   int fd;
 413   ULONGEST addr;
 414
 415   /* Like child_post_startup_inferior, if we happened to attach to
 416      the inferior while it wasn't currently in spu_run, continue
 417      running it until we get back there.  */
 418   while (!parse_spufs_run (&fd, &addr))
 419     {
 420       ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
 421       waitpid (pid, NULL, __WALL | __WNOTHREAD);
 422     }
 423
 424   /* If the user has not provided an executable file, try to extract
 425      the image from inside the target process.  */
 426   if (!get_exec_file (0))
 427     spu_symbol_file_add_from_memory (fd);
 428 }
 429
 430 /* Wait for child PTID to do something.  Return id of the child,
 431    minus_one_ptid in case of error; store status into *OURSTATUS.  */
 432 static ptid_t
 433 spu_child_wait (struct target_ops *ops,
 434                 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 435 {
 436   int save_errno;
 437   int status;
 438   pid_t pid;
 439
 440   do
 441     {
 442       set_sigint_trap ();       /* Causes SIGINT to be passed on to the
 443                                    attached process.  */
 444
 445       pid = waitpid (PIDGET (ptid), &status, 0);
 446       if (pid == -1 && errno == ECHILD)
 447         /* Try again with __WCLONE to check cloned processes.  */
 448         pid = waitpid (PIDGET (ptid), &status, __WCLONE);
 449
 450       save_errno = errno;
 451
 452       /* Make sure we don't report an event for the exit of the
 453          original program, if we've detached from it.  */
 454       if (pid != -1 && !WIFSTOPPED (status) && pid != PIDGET (inferior_ptid))
 455         {
 456           pid = -1;
 457           save_errno = EINTR;
 458         }
 459
 460       clear_sigint_trap ();
 461     }
 462   while (pid == -1 && save_errno == EINTR);
 463
 464   if (pid == -1)
 465     {
 466       warning (_("Child process unexpectedly missing: %s"),
 467                safe_strerror (save_errno));
 468
 469       /* Claim it exited with unknown signal.  */
 470       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 471       ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
 472       return inferior_ptid;
 473     }
 474
 475   store_waitstatus (ourstatus, status);
 476   return pid_to_ptid (pid);
 477 }
 478
 479 /* Override the fetch_inferior_register routine.  */
 480 static void
 481 spu_fetch_inferior_registers (struct target_ops *ops,
 482                               struct regcache *regcache, int regno)
 483 {
 484   int fd;
 485   ULONGEST addr;
 486
 487   /* We must be stopped on a spu_run system call.  */
 488   if (!parse_spufs_run (&fd, &addr))
 489     return;
 490
 491   /* The ID register holds the spufs file handle.  */
 492   if (regno == -1 || regno == SPU_ID_REGNUM)
 493     {
 494       struct gdbarch *gdbarch = get_regcache_arch (regcache);
 495       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 496       char buf[4];
 497       store_unsigned_integer (buf, 4, byte_order, fd);
 498       regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
 499     }
 500
 501   /* The NPC register is found at ADDR.  */
 502   if (regno == -1 || regno == SPU_PC_REGNUM)
 503     {
 504       gdb_byte buf[4];
 505       if (fetch_ppc_memory (addr, buf, 4) == 0)
 506         regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
 507     }
 508
 509   /* The GPRs are found in the "regs" spufs file.  */
 510   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
 511     {
 512       gdb_byte buf[16 * SPU_NUM_GPRS];
 513       char annex[32];
 514       int i;
 515
 516       xsnprintf (annex, sizeof annex, "%d/regs", fd);
 517       if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
 518         for (i = 0; i < SPU_NUM_GPRS; i++)
 519           regcache_raw_supply (regcache, i, buf + i*16);
 520     }
 521 }
 522
 523 /* Override the store_inferior_register routine.  */
 524 static void
 525 spu_store_inferior_registers (struct target_ops *ops,
 526                               struct regcache *regcache, int regno)
 527 {
 528   int fd;
 529   ULONGEST addr;
 530
 531   /* We must be stopped on a spu_run system call.  */
 532   if (!parse_spufs_run (&fd, &addr))
 533     return;
 534
 535   /* The NPC register is found at ADDR.  */
 536   if (regno == -1 || regno == SPU_PC_REGNUM)
 537     {
 538       gdb_byte buf[4];
 539       regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
 540       store_ppc_memory (addr, buf, 4);
 541     }
 542
 543   /* The GPRs are found in the "regs" spufs file.  */
 544   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
 545     {
 546       gdb_byte buf[16 * SPU_NUM_GPRS];
 547       char annex[32];
 548       int i;
 549
 550       for (i = 0; i < SPU_NUM_GPRS; i++)
 551         regcache_raw_collect (regcache, i, buf + i*16);
 552
 553       xsnprintf (annex, sizeof annex, "%d/regs", fd);
 554       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
 555     }
 556 }
 557
 558 /* Override the to_xfer_partial routine.  */
 559 static LONGEST
 560 spu_xfer_partial (struct target_ops *ops,
 561                   enum target_object object, const char *annex,
 562                   gdb_byte *readbuf, const gdb_byte *writebuf,
 563                   ULONGEST offset, LONGEST len)
 564 {
 565   if (object == TARGET_OBJECT_SPU)
 566     return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len);
 567
 568   if (object == TARGET_OBJECT_MEMORY)
 569     {
 570       int fd;
 571       ULONGEST addr;
 572       char mem_annex[32], lslr_annex[32];
 573       gdb_byte buf[32];
 574       ULONGEST lslr;
 575       LONGEST ret;
 576
 577       /* We must be stopped on a spu_run system call.  */
 578       if (!parse_spufs_run (&fd, &addr))
 579         return 0;
 580
 581       /* Use the "mem" spufs file to access SPU local store.  */
 582       xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
 583       ret = spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
 584       if (ret > 0)
 585         return ret;
 586
 587       /* SPU local store access wraps the address around at the
 588          local store limit.  We emulate this here.  To avoid needing
 589          an extra access to retrieve the LSLR, we only do that after
 590          trying the original address first, and getting end-of-file.  */
 591       xsnprintf (lslr_annex, sizeof lslr_annex, "%d/lslr", fd);
 592       memset (buf, 0, sizeof buf);
 593       if (spu_proc_xfer_spu (lslr_annex, buf, NULL, 0, sizeof buf) <= 0)
 594         return ret;
 595
 596       lslr = strtoulst (buf, NULL, 16);
 597       return spu_proc_xfer_spu (mem_annex, readbuf, writebuf,
 598                                 offset & lslr, len);
 599     }
 600
 601   return -1;
 602 }
 603
 604 /* Override the to_can_use_hw_breakpoint routine.  */
 605 static int
 606 spu_can_use_hw_breakpoint (int type, int cnt, int othertype)
 607 {
 608   return 0;
 609 }
 610
 611
 612 /* Initialize SPU native target.  */
 613 void
 614 _initialize_spu_nat (void)
 615 {
 616   /* Generic ptrace methods.  */
 617   struct target_ops *t;
 618   t = inf_ptrace_target ();
 619
 620   /* Add SPU methods.  */
 621   t->to_post_attach = spu_child_post_attach;
 622   t->to_post_startup_inferior = spu_child_post_startup_inferior;
 623   t->to_wait = spu_child_wait;
 624   t->to_fetch_registers = spu_fetch_inferior_registers;
 625   t->to_store_registers = spu_store_inferior_registers;
 626   t->to_xfer_partial = spu_xfer_partial;
 627   t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
 628
 629   /* Register SPU target.  */
 630   add_target (t);
 631 }