gdb/spu-linux-nat.c

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