gdb/spu-linux-nat.c

   1 /* SPU native-dependent code for GDB, the GNU debugger.
   2    Copyright (C) 2006-2014 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 <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
  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 = ptid_get_lwp (inferior_ptid);
  52   if (tid == 0)
  53     tid = ptid_get_pid (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 = ptid_get_lwp (inferior_ptid);
 137   if (tid == 0)
 138     tid = ptid_get_pid (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 = ptid_get_lwp (inferior_ptid);
 167   if (tid == 0)
 168     tid = ptid_get_pid (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, ULONGEST len)
 235 {
 236   char buf[128];
 237   int fd = 0;
 238   int ret = -1;
 239   int pid = ptid_get_pid (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
 280   /* Zero means success.  */
 281   return 0;
 282 }
 283
 284 static file_ptr
 285 spu_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
 286                      file_ptr nbytes, file_ptr offset)
 287 {
 288   ULONGEST addr = *(ULONGEST *)stream;
 289
 290   if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
 291     {
 292       bfd_set_error (bfd_error_invalid_operation);
 293       return -1;
 294     }
 295
 296   return nbytes;
 297 }
 298
 299 static int
 300 spu_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 301 {
 302   /* We don't have an easy way of finding the size of embedded spu
 303      images.  We could parse the in-memory ELF header and section
 304      table to find the extent of the last section but that seems
 305      pointless when the size is needed only for checks of other
 306      parsed values in dbxread.c.  */
 307   sb->st_size = INT_MAX;
 308   return 0;
 309 }
 310
 311 static bfd *
 312 spu_bfd_open (ULONGEST addr)
 313 {
 314   struct bfd *nbfd;
 315   asection *spu_name;
 316
 317   ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
 318   *open_closure = addr;
 319
 320   nbfd = gdb_bfd_openr_iovec ("<in-memory>", "elf32-spu",
 321                               spu_bfd_iovec_open, open_closure,
 322                               spu_bfd_iovec_pread, spu_bfd_iovec_close,
 323                               spu_bfd_iovec_stat);
 324   if (!nbfd)
 325     return NULL;
 326
 327   if (!bfd_check_format (nbfd, bfd_object))
 328     {
 329       gdb_bfd_unref (nbfd);
 330       return NULL;
 331     }
 332
 333   /* Retrieve SPU name note and update BFD name.  */
 334   spu_name = bfd_get_section_by_name (nbfd, ".note.spu_name");
 335   if (spu_name)
 336     {
 337       int sect_size = bfd_section_size (nbfd, spu_name);
 338       if (sect_size > 20)
 339         {
 340           char *buf = alloca (sect_size - 20 + 1);
 341           bfd_get_section_contents (nbfd, spu_name, buf, 20, sect_size - 20);
 342           buf[sect_size - 20] = '\0';
 343
 344           xfree ((char *)nbfd->filename);
 345           nbfd->filename = xstrdup (buf);
 346         }
 347     }
 348
 349   return nbfd;
 350 }
 351
 352 /* INFERIOR_FD is a file handle passed by the inferior to the
 353    spu_run system call.  Assuming the SPE context was allocated
 354    by the libspe library, try to retrieve the main SPE executable
 355    file from its copy within the target process.  */
 356 static void
 357 spu_symbol_file_add_from_memory (int inferior_fd)
 358 {
 359   ULONGEST addr;
 360   struct bfd *nbfd;
 361
 362   gdb_byte id[128];
 363   char annex[32];
 364   int len;
 365
 366   /* Read object ID.  */
 367   xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
 368   len = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id);
 369   if (len <= 0 || len >= sizeof id)
 370     return;
 371   id[len] = 0;
 372   addr = strtoulst ((const char *) id, NULL, 16);
 373   if (!addr)
 374     return;
 375
 376   /* Open BFD representing SPE executable and read its symbols.  */
 377   nbfd = spu_bfd_open (addr);
 378   if (nbfd)
 379     {
 380       struct cleanup *cleanup = make_cleanup_bfd_unref (nbfd);
 381
 382       symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd),
 383                                 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 = ptid_get_lwp (ptid);
 399   if (tid == 0)
 400     tid = ptid_get_pid (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 (ptid_get_pid (ptid), &status, 0);
 448       if (pid == -1 && errno == ECHILD)
 449         /* Try again with __WCLONE to check cloned processes.  */
 450         pid = waitpid (ptid_get_pid (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)
 457           && pid != ptid_get_pid (inferior_ptid))
 458         {
 459           pid = -1;
 460           save_errno = EINTR;
 461         }
 462
 463       clear_sigint_trap ();
 464     }
 465   while (pid == -1 && save_errno == EINTR);
 466
 467   if (pid == -1)
 468     {
 469       warning (_("Child process unexpectedly missing: %s"),
 470                safe_strerror (save_errno));
 471
 472       /* Claim it exited with unknown signal.  */
 473       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 474       ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
 475       return inferior_ptid;
 476     }
 477
 478   store_waitstatus (ourstatus, status);
 479   return pid_to_ptid (pid);
 480 }
 481
 482 /* Override the fetch_inferior_register routine.  */
 483 static void
 484 spu_fetch_inferior_registers (struct target_ops *ops,
 485                               struct regcache *regcache, int regno)
 486 {
 487   int fd;
 488   ULONGEST addr;
 489
 490   /* We must be stopped on a spu_run system call.  */
 491   if (!parse_spufs_run (&fd, &addr))
 492     return;
 493
 494   /* The ID register holds the spufs file handle.  */
 495   if (regno == -1 || regno == SPU_ID_REGNUM)
 496     {
 497       struct gdbarch *gdbarch = get_regcache_arch (regcache);
 498       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 499       gdb_byte buf[4];
 500       store_unsigned_integer (buf, 4, byte_order, fd);
 501       regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
 502     }
 503
 504   /* The NPC register is found at ADDR.  */
 505   if (regno == -1 || regno == SPU_PC_REGNUM)
 506     {
 507       gdb_byte buf[4];
 508       if (fetch_ppc_memory (addr, buf, 4) == 0)
 509         regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
 510     }
 511
 512   /* The GPRs are found in the "regs" spufs file.  */
 513   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
 514     {
 515       gdb_byte buf[16 * SPU_NUM_GPRS];
 516       char annex[32];
 517       int i;
 518
 519       xsnprintf (annex, sizeof annex, "%d/regs", fd);
 520       if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
 521         for (i = 0; i < SPU_NUM_GPRS; i++)
 522           regcache_raw_supply (regcache, i, buf + i*16);
 523     }
 524 }
 525
 526 /* Override the store_inferior_register routine.  */
 527 static void
 528 spu_store_inferior_registers (struct target_ops *ops,
 529                               struct regcache *regcache, int regno)
 530 {
 531   int fd;
 532   ULONGEST addr;
 533
 534   /* We must be stopped on a spu_run system call.  */
 535   if (!parse_spufs_run (&fd, &addr))
 536     return;
 537
 538   /* The NPC register is found at ADDR.  */
 539   if (regno == -1 || regno == SPU_PC_REGNUM)
 540     {
 541       gdb_byte buf[4];
 542       regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
 543       store_ppc_memory (addr, buf, 4);
 544     }
 545
 546   /* The GPRs are found in the "regs" spufs file.  */
 547   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
 548     {
 549       gdb_byte buf[16 * SPU_NUM_GPRS];
 550       char annex[32];
 551       int i;
 552
 553       for (i = 0; i < SPU_NUM_GPRS; i++)
 554         regcache_raw_collect (regcache, i, buf + i*16);
 555
 556       xsnprintf (annex, sizeof annex, "%d/regs", fd);
 557       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
 558     }
 559 }
 560
 561 /* Override the to_xfer_partial routine.  */
 562 static LONGEST
 563 spu_xfer_partial (struct target_ops *ops,
 564                   enum target_object object, const char *annex,
 565                   gdb_byte *readbuf, const gdb_byte *writebuf,
 566                   ULONGEST offset, ULONGEST len)
 567 {
 568   if (object == TARGET_OBJECT_SPU)
 569     return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len);
 570
 571   if (object == TARGET_OBJECT_MEMORY)
 572     {
 573       int fd;
 574       ULONGEST addr;
 575       char mem_annex[32], lslr_annex[32];
 576       gdb_byte buf[32];
 577       ULONGEST lslr;
 578       LONGEST ret;
 579
 580       /* We must be stopped on a spu_run system call.  */
 581       if (!parse_spufs_run (&fd, &addr))
 582         return 0;
 583
 584       /* Use the "mem" spufs file to access SPU local store.  */
 585       xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
 586       ret = spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
 587       if (ret > 0)
 588         return ret;
 589
 590       /* SPU local store access wraps the address around at the
 591          local store limit.  We emulate this here.  To avoid needing
 592          an extra access to retrieve the LSLR, we only do that after
 593          trying the original address first, and getting end-of-file.  */
 594       xsnprintf (lslr_annex, sizeof lslr_annex, "%d/lslr", fd);
 595       memset (buf, 0, sizeof buf);
 596       if (spu_proc_xfer_spu (lslr_annex, buf, NULL, 0, sizeof buf) <= 0)
 597         return ret;
 598
 599       lslr = strtoulst ((const char *) buf, NULL, 16);
 600       return spu_proc_xfer_spu (mem_annex, readbuf, writebuf,
 601                                 offset & lslr, len);
 602     }
 603
 604   return -1;
 605 }
 606
 607 /* Override the to_can_use_hw_breakpoint routine.  */
 608 static int
 609 spu_can_use_hw_breakpoint (int type, int cnt, int othertype)
 610 {
 611   return 0;
 612 }
 613
 614 /* -Wmissing-prototypes */
 615 extern initialize_file_ftype _initialize_spu_nat;
 616
 617 /* Initialize SPU native target.  */
 618 void
 619 _initialize_spu_nat (void)
 620 {
 621   /* Generic ptrace methods.  */
 622   struct target_ops *t;
 623   t = inf_ptrace_target ();
 624
 625   /* Add SPU methods.  */
 626   t->to_post_attach = spu_child_post_attach;
 627   t->to_post_startup_inferior = spu_child_post_startup_inferior;
 628   t->to_wait = spu_child_wait;
 629   t->to_fetch_registers = spu_fetch_inferior_registers;
 630   t->to_store_registers = spu_store_inferior_registers;
 631   t->to_xfer_partial = spu_xfer_partial;
 632   t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
 633
 634   /* Register SPU target.  */
 635   add_target (t);
 636 }