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
  33 #include <sys/ptrace.h>
  34 #include <asm/ptrace.h>
  35 #include <sys/types.h>
  36 #include <sys/param.h>
  37
  38 #include "spu-tdep.h"
  39
  40 /* PPU side system calls.  */
  41 #define INSTR_SC        0x44000002
  42 #define NR_spu_run      0x0116
  43
  44
  45 /* Fetch PPU register REGNO.  */
  46 static ULONGEST
  47 fetch_ppc_register (int regno)
  48 {
  49   PTRACE_TYPE_RET res;
  50
  51   int tid = TIDGET (inferior_ptid);
  52   if (tid == 0)
  53     tid = PIDGET (inferior_ptid);
  54
  55 #ifndef __powerpc64__
  56   /* If running as a 32-bit process on a 64-bit system, we attempt
  57      to get the full 64-bit register content of the target process.
  58      If the PPC special ptrace call fails, we're on a 32-bit system;
  59      just fall through to the regular ptrace call in that case.  */
  60   {
  61     gdb_byte buf[8];
  62
  63     errno = 0;
  64     ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  65             (PTRACE_TYPE_ARG3) (regno * 8), buf);
  66     if (errno == 0)
  67       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  68               (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
  69     if (errno == 0)
  70       return (ULONGEST) *(uint64_t *)buf;
  71   }
  72 #endif
  73
  74   errno = 0;
  75   res = ptrace (PT_READ_U, tid,
  76                 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
  77   if (errno != 0)
  78     {
  79       char mess[128];
  80       xsnprintf (mess, sizeof mess, "reading PPC register #%d", regno);
  81       perror_with_name (_(mess));
  82     }
  83
  84   return (ULONGEST) (unsigned long) res;
  85 }
  86
  87 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
  88 static int
  89 fetch_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET *word)
  90 {
  91   errno = 0;
  92
  93 #ifndef __powerpc64__
  94   if (memaddr >> 32)
  95     {
  96       uint64_t addr_8 = (uint64_t) memaddr;
  97       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
  98     }
  99   else
 100 #endif
 101     *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
 102
 103   return errno;
 104 }
 105
 106 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
 107 static int
 108 store_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET word)
 109 {
 110   errno = 0;
 111
 112 #ifndef __powerpc64__
 113   if (memaddr >> 32)
 114     {
 115       uint64_t addr_8 = (uint64_t) memaddr;
 116       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 117     }
 118   else
 119 #endif
 120     ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
 121
 122   return errno;
 123 }
 124
 125 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
 126 static int
 127 fetch_ppc_memory (ULONGEST memaddr, gdb_byte *myaddr, int len)
 128 {
 129   int i, ret;
 130
 131   ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 132   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 133                / sizeof (PTRACE_TYPE_RET));
 134   PTRACE_TYPE_RET *buffer;
 135
 136   int tid = TIDGET (inferior_ptid);
 137   if (tid == 0)
 138     tid = PIDGET (inferior_ptid);
 139
 140   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 141   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 142     {
 143       ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
 144       if (ret)
 145         return ret;
 146     }
 147
 148   memcpy (myaddr,
 149           (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 150           len);
 151
 152   return 0;
 153 }
 154
 155 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
 156 static int
 157 store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
 158 {
 159   int i, ret;
 160
 161   ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 162   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 163                / sizeof (PTRACE_TYPE_RET));
 164   PTRACE_TYPE_RET *buffer;
 165
 166   int tid = TIDGET (inferior_ptid);
 167   if (tid == 0)
 168     tid = PIDGET (inferior_ptid);
 169
 170   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 171
 172   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 173     {
 174       ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
 175       if (ret)
 176         return ret;
 177     }
 178
 179   if (count > 1)
 180     {
 181       ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
 182                                                * sizeof (PTRACE_TYPE_RET),
 183                                 &buffer[count - 1]);
 184       if (ret)
 185         return ret;
 186     }
 187
 188   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 189           myaddr, len);
 190
 191   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 192     {
 193       ret = store_ppc_memory_1 (tid, addr, buffer[i]);
 194       if (ret)
 195         return ret;
 196     }
 197
 198   return 0;
 199 }
 200
 201
 202 /* If the PPU thread is currently stopped on a spu_run system call,
 203    return to FD and ADDR the file handle and NPC parameter address
 204    used with the system call.  Return non-zero if successful.  */
 205 static int
 206 parse_spufs_run (int *fd, ULONGEST *addr)
 207 {
 208   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
 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, byte_order) != 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 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
 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   asection *spu_name;
 314
 315   ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
 316   *open_closure = addr;
 317
 318   nbfd = gdb_bfd_openr_iovec ("<in-memory>", "elf32-spu",
 319                               spu_bfd_iovec_open, open_closure,
 320                               spu_bfd_iovec_pread, spu_bfd_iovec_close,
 321                               spu_bfd_iovec_stat);
 322   if (!nbfd)
 323     return NULL;
 324
 325   if (!bfd_check_format (nbfd, bfd_object))
 326     {
 327       gdb_bfd_unref (nbfd);
 328       return NULL;
 329     }
 330
 331   /* Retrieve SPU name note and update BFD name.  */
 332   spu_name = bfd_get_section_by_name (nbfd, ".note.spu_name");
 333   if (spu_name)
 334     {
 335       int sect_size = bfd_section_size (nbfd, spu_name);
 336       if (sect_size > 20)
 337         {
 338           char *buf = alloca (sect_size - 20 + 1);
 339           bfd_get_section_contents (nbfd, spu_name, buf, 20, sect_size - 20);
 340           buf[sect_size - 20] = '\0';
 341
 342           xfree ((char *)nbfd->filename);
 343           nbfd->filename = xstrdup (buf);
 344         }
 345     }
 346
 347   return nbfd;
 348 }
 349
 350 /* INFERIOR_FD is a file handle passed by the inferior to the
 351    spu_run system call.  Assuming the SPE context was allocated
 352    by the libspe library, try to retrieve the main SPE executable
 353    file from its copy within the target process.  */
 354 static void
 355 spu_symbol_file_add_from_memory (int inferior_fd)
 356 {
 357   ULONGEST addr;
 358   struct bfd *nbfd;
 359
 360   char id[128];
 361   char annex[32];
 362   int len;
 363
 364   /* Read object ID.  */
 365   xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
 366   len = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id);
 367   if (len <= 0 || len >= sizeof id)
 368     return;
 369   id[len] = 0;
 370   addr = strtoulst (id, NULL, 16);
 371   if (!addr)
 372     return;
 373
 374   /* Open BFD representing SPE executable and read its symbols.  */
 375   nbfd = spu_bfd_open (addr);
 376   if (nbfd)
 377     {
 378       struct cleanup *cleanup = make_cleanup_bfd_unref (nbfd);
 379
 380       symbol_file_add_from_bfd (nbfd, SYMFILE_VERBOSE | SYMFILE_MAINLINE,
 381                                 NULL, 0, NULL);
 382       do_cleanups (cleanup);
 383     }
 384 }
 385
 386
 387 /* Override the post_startup_inferior routine to continue running
 388    the inferior until the first spu_run system call.  */
 389 static void
 390 spu_child_post_startup_inferior (ptid_t ptid)
 391 {
 392   int fd;
 393   ULONGEST addr;
 394
 395   int tid = TIDGET (ptid);
 396   if (tid == 0)
 397     tid = PIDGET (ptid);
 398
 399   while (!parse_spufs_run (&fd, &addr))
 400     {
 401       ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
 402       waitpid (tid, NULL, __WALL | __WNOTHREAD);
 403     }
 404 }
 405
 406 /* Override the post_attach routine to try load the SPE executable
 407    file image from its copy inside the target process.  */
 408 static void
 409 spu_child_post_attach (int pid)
 410 {
 411   int fd;
 412   ULONGEST addr;
 413
 414   /* Like child_post_startup_inferior, if we happened to attach to
 415      the inferior while it wasn't currently in spu_run, continue
 416      running it until we get back there.  */
 417   while (!parse_spufs_run (&fd, &addr))
 418     {
 419       ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
 420       waitpid (pid, NULL, __WALL | __WNOTHREAD);
 421     }
 422
 423   /* If the user has not provided an executable file, try to extract
 424      the image from inside the target process.  */
 425   if (!get_exec_file (0))
 426     spu_symbol_file_add_from_memory (fd);
 427 }
 428
 429 /* Wait for child PTID to do something.  Return id of the child,
 430    minus_one_ptid in case of error; store status into *OURSTATUS.  */
 431 static ptid_t
 432 spu_child_wait (struct target_ops *ops,
 433                 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 434 {
 435   int save_errno;
 436   int status;
 437   pid_t pid;
 438
 439   do
 440     {
 441       set_sigint_trap ();       /* Causes SIGINT to be passed on to the
 442                                    attached process.  */
 443
 444       pid = waitpid (PIDGET (ptid), &status, 0);
 445       if (pid == -1 && errno == ECHILD)
 446         /* Try again with __WCLONE to check cloned processes.  */
 447         pid = waitpid (PIDGET (ptid), &status, __WCLONE);
 448
 449       save_errno = errno;
 450
 451       /* Make sure we don't report an event for the exit of the
 452          original program, if we've detached from it.  */
 453       if (pid != -1 && !WIFSTOPPED (status) && pid != PIDGET (inferior_ptid))
 454         {
 455           pid = -1;
 456           save_errno = EINTR;
 457         }
 458
 459       clear_sigint_trap ();
 460     }
 461   while (pid == -1 && save_errno == EINTR);
 462
 463   if (pid == -1)
 464     {
 465       warning (_("Child process unexpectedly missing: %s"),
 466                safe_strerror (save_errno));
 467
 468       /* Claim it exited with unknown signal.  */
 469       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 470       ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
 471       return inferior_ptid;
 472     }
 473
 474   store_waitstatus (ourstatus, status);
 475   return pid_to_ptid (pid);
 476 }
 477
 478 /* Override the fetch_inferior_register routine.  */
 479 static void
 480 spu_fetch_inferior_registers (struct target_ops *ops,
 481                               struct regcache *regcache, int regno)
 482 {
 483   int fd;
 484   ULONGEST addr;
 485
 486   /* We must be stopped on a spu_run system call.  */
 487   if (!parse_spufs_run (&fd, &addr))
 488     return;
 489
 490   /* The ID register holds the spufs file handle.  */
 491   if (regno == -1 || regno == SPU_ID_REGNUM)
 492     {
 493       struct gdbarch *gdbarch = get_regcache_arch (regcache);
 494       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 495       char buf[4];
 496       store_unsigned_integer (buf, 4, byte_order, fd);
 497       regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
 498     }
 499
 500   /* The NPC register is found at ADDR.  */
 501   if (regno == -1 || regno == SPU_PC_REGNUM)
 502     {
 503       gdb_byte buf[4];
 504       if (fetch_ppc_memory (addr, buf, 4) == 0)
 505         regcache_raw_supply (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_GPRS))
 510     {
 511       gdb_byte buf[16 * SPU_NUM_GPRS];
 512       char annex[32];
 513       int i;
 514
 515       xsnprintf (annex, sizeof 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_GPRS; i++)
 518           regcache_raw_supply (regcache, i, buf + i*16);
 519     }
 520 }
 521
 522 /* Override the store_inferior_register routine.  */
 523 static void
 524 spu_store_inferior_registers (struct target_ops *ops,
 525                               struct regcache *regcache, int regno)
 526 {
 527   int fd;
 528   ULONGEST addr;
 529
 530   /* We must be stopped on a spu_run system call.  */
 531   if (!parse_spufs_run (&fd, &addr))
 532     return;
 533
 534   /* The NPC register is found at ADDR.  */
 535   if (regno == -1 || regno == SPU_PC_REGNUM)
 536     {
 537       gdb_byte buf[4];
 538       regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
 539       store_ppc_memory (addr, buf, 4);
 540     }
 541
 542   /* The GPRs are found in the "regs" spufs file.  */
 543   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
 544     {
 545       gdb_byte buf[16 * SPU_NUM_GPRS];
 546       char annex[32];
 547       int i;
 548
 549       for (i = 0; i < SPU_NUM_GPRS; i++)
 550         regcache_raw_collect (regcache, i, buf + i*16);
 551
 552       xsnprintf (annex, sizeof annex, "%d/regs", fd);
 553       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
 554     }
 555 }
 556
 557 /* Override the to_xfer_partial routine.  */
 558 static LONGEST
 559 spu_xfer_partial (struct target_ops *ops,
 560                   enum target_object object, const char *annex,
 561                   gdb_byte *readbuf, const gdb_byte *writebuf,
 562                   ULONGEST offset, LONGEST len)
 563 {
 564   if (object == TARGET_OBJECT_SPU)
 565     return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len);
 566
 567   if (object == TARGET_OBJECT_MEMORY)
 568     {
 569       int fd;
 570       ULONGEST addr;
 571       char mem_annex[32], lslr_annex[32];
 572       gdb_byte buf[32];
 573       ULONGEST lslr;
 574       LONGEST ret;
 575
 576       /* We must be stopped on a spu_run system call.  */
 577       if (!parse_spufs_run (&fd, &addr))
 578         return 0;
 579
 580       /* Use the "mem" spufs file to access SPU local store.  */
 581       xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
 582       ret = spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
 583       if (ret > 0)
 584         return ret;
 585
 586       /* SPU local store access wraps the address around at the
 587          local store limit.  We emulate this here.  To avoid needing
 588          an extra access to retrieve the LSLR, we only do that after
 589          trying the original address first, and getting end-of-file.  */
 590       xsnprintf (lslr_annex, sizeof lslr_annex, "%d/lslr", fd);
 591       memset (buf, 0, sizeof buf);
 592       if (spu_proc_xfer_spu (lslr_annex, buf, NULL, 0, sizeof buf) <= 0)
 593         return ret;
 594
 595       lslr = strtoulst (buf, NULL, 16);
 596       return spu_proc_xfer_spu (mem_annex, readbuf, writebuf,
 597                                 offset & lslr, len);
 598     }
 599
 600   return -1;
 601 }
 602
 603 /* Override the to_can_use_hw_breakpoint routine.  */
 604 static int
 605 spu_can_use_hw_breakpoint (int type, int cnt, int othertype)
 606 {
 607   return 0;
 608 }
 609
 610
 611 /* Initialize SPU native target.  */
 612 void
 613 _initialize_spu_nat (void)
 614 {
 615   /* Generic ptrace methods.  */
 616   struct target_ops *t;
 617   t = inf_ptrace_target ();
 618
 619   /* Add SPU methods.  */
 620   t->to_post_attach = spu_child_post_attach;
 621   t->to_post_startup_inferior = spu_child_post_startup_inferior;
 622   t->to_wait = spu_child_wait;
 623   t->to_fetch_registers = spu_fetch_inferior_registers;
 624   t->to_store_registers = spu_store_inferior_registers;
 625   t->to_xfer_partial = spu_xfer_partial;
 626   t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
 627
 628   /* Register SPU target.  */
 629   add_target (t);
 630 }