gdb/spu-linux-nat.c

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