gdb/spu-linux-nat.c

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