gdb/solib-spu.c

   1 /* Cell SPU GNU/Linux support -- shared library handling.
   2    Copyright (C) 2009-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 "solib-spu.h"
  23 #include "gdbcore.h"
  24 #include <string.h>
  25 #include <sys/stat.h>
  26 #include "arch-utils.h"
  27 #include "bfd.h"
  28 #include "symtab.h"
  29 #include "solib.h"
  30 #include "solib-svr4.h"
  31 #include "solist.h"
  32 #include "inferior.h"
  33 #include "objfiles.h"
  34 #include "observer.h"
  35 #include "breakpoint.h"
  36 #include "gdbthread.h"
  37 #include "exceptions.h"
  38 #include "gdb_bfd.h"
  39
  40 #include "spu-tdep.h"
  41
  42 /* Highest SPE id (file handle) the inferior may have.  */
  43 #define MAX_SPE_FD 1024
  44
  45 /* Stand-alone SPE executable?  */
  46 #define spu_standalone_p() \
  47   (symfile_objfile && symfile_objfile->obfd \
  48    && bfd_get_arch (symfile_objfile->obfd) == bfd_arch_spu)
  49
  50
  51 /* Relocate main SPE executable.  */
  52 static void
  53 spu_relocate_main_executable (int spufs_fd)
  54 {
  55   struct section_offsets *new_offsets;
  56   int i;
  57
  58   if (symfile_objfile == NULL)
  59     return;
  60
  61   new_offsets = alloca (symfile_objfile->num_sections
  62                         * sizeof (struct section_offsets));
  63
  64   for (i = 0; i < symfile_objfile->num_sections; i++)
  65     new_offsets->offsets[i] = SPUADDR (spufs_fd, 0);
  66
  67   objfile_relocate (symfile_objfile, new_offsets);
  68 }
  69
  70 /* When running a stand-alone SPE executable, we may need to skip one more
  71    exec event on startup, to get past the binfmt_misc loader.  */
  72 static void
  73 spu_skip_standalone_loader (void)
  74 {
  75   if (target_has_execution && !current_inferior ()->attach_flag)
  76     {
  77       struct target_waitstatus ws;
  78
  79       /* Only some kernels report an extra SIGTRAP with the binfmt_misc
  80          loader; others do not.  In addition, if we have attached to an
  81          already running inferior instead of starting a new one, we will
  82          not see the extra SIGTRAP -- and we cannot readily distinguish
  83          the two cases, in particular with the extended-remote target.
  84
  85          Thus we issue a single-step here.  If no extra SIGTRAP was pending,
  86          this will step past the first instruction of the stand-alone SPE
  87          executable loader, but we don't care about that.  */
  88
  89       inferior_thread ()->control.in_infcall = 1; /* Suppress MI messages.  */
  90
  91       target_resume (inferior_ptid, 1, GDB_SIGNAL_0);
  92       target_wait (minus_one_ptid, &ws, 0);
  93       set_executing (minus_one_ptid, 0);
  94
  95       inferior_thread ()->control.in_infcall = 0;
  96     }
  97 }
  98
  99 static const struct objfile_data *ocl_program_data_key;
 100
 101 /* Appends OpenCL programs to the list of `struct so_list' objects.  */
 102 static void
 103 append_ocl_sos (struct so_list **link_ptr)
 104 {
 105   CORE_ADDR *ocl_program_addr_base;
 106   struct objfile *objfile;
 107
 108   ALL_OBJFILES (objfile)
 109     {
 110       ocl_program_addr_base = objfile_data (objfile, ocl_program_data_key);
 111       if (ocl_program_addr_base != NULL)
 112         {
 113           enum bfd_endian byte_order = bfd_big_endian (objfile->obfd)?
 114                                          BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
 115           volatile struct gdb_exception ex;
 116           TRY_CATCH (ex, RETURN_MASK_ALL)
 117             {
 118               CORE_ADDR data =
 119                 read_memory_unsigned_integer (*ocl_program_addr_base,
 120                                               sizeof (CORE_ADDR),
 121                                               byte_order);
 122               if (data != 0x0)
 123                 {
 124                   struct so_list *new;
 125
 126                   /* Allocate so_list structure.  */
 127                   new = XCNEW (struct so_list);
 128
 129                   /* Encode FD and object ID in path name.  */
 130                   xsnprintf (new->so_name, sizeof new->so_name, "@%s <%d>",
 131                              hex_string (data),
 132                              SPUADDR_SPU (*ocl_program_addr_base));
 133                   strcpy (new->so_original_name, new->so_name);
 134
 135                   *link_ptr = new;
 136                   link_ptr = &new->next;
 137                 }
 138             }
 139           if (ex.reason < 0)
 140             {
 141               /* Ignore memory errors.  */
 142               switch (ex.error)
 143                 {
 144                 case MEMORY_ERROR:
 145                   break;
 146                 default:
 147                   throw_exception (ex);
 148                   break;
 149                 }
 150             }
 151         }
 152     }
 153 }
 154
 155 /* Build a list of `struct so_list' objects describing the shared
 156    objects currently loaded in the inferior.  */
 157 static struct so_list *
 158 spu_current_sos (void)
 159 {
 160   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 161   struct so_list *head;
 162   struct so_list **link_ptr;
 163
 164   gdb_byte buf[MAX_SPE_FD * 4];
 165   int i, size;
 166
 167   /* First, retrieve the SVR4 shared library list.  */
 168   head = svr4_so_ops.current_sos ();
 169
 170   /* Append our libraries to the end of the list.  */
 171   for (link_ptr = &head; *link_ptr; link_ptr = &(*link_ptr)->next)
 172     ;
 173
 174   /* Determine list of SPU ids.  */
 175   size = target_read (&current_target, TARGET_OBJECT_SPU, NULL,
 176                       buf, 0, sizeof buf);
 177
 178   /* Do not add stand-alone SPE executable context as shared library,
 179      but relocate main SPE executable objfile.  */
 180   if (spu_standalone_p ())
 181     {
 182       if (size == 4)
 183         {
 184           int fd = extract_unsigned_integer (buf, 4, byte_order);
 185
 186           spu_relocate_main_executable (fd);
 187
 188           /* Re-enable breakpoints after main SPU context was established;
 189              see also comments in spu_solib_create_inferior_hook.  */
 190           enable_breakpoints_after_startup ();
 191         }
 192
 193       return head;
 194     }
 195
 196   /* Create an so_list entry for each SPU id.  */
 197   for (i = 0; i < size; i += 4)
 198     {
 199       int fd = extract_unsigned_integer (buf + i, 4, byte_order);
 200       struct so_list *new;
 201
 202       unsigned long long addr;
 203       char annex[32], id[100];
 204       int len;
 205
 206       /* Read object ID.  There's a race window where the inferior may have
 207          already created the SPE context, but not installed the object-id
 208          yet.  Skip such entries; we'll be back for them later.  */
 209       xsnprintf (annex, sizeof annex, "%d/object-id", fd);
 210       len = target_read (&current_target, TARGET_OBJECT_SPU, annex,
 211                          (gdb_byte *) id, 0, sizeof id);
 212       if (len <= 0 || len >= sizeof id)
 213         continue;
 214       id[len] = 0;
 215       if (sscanf (id, "0x%llx", &addr) != 1 || !addr)
 216         continue;
 217
 218       /* Allocate so_list structure.  */
 219       new = XCNEW (struct so_list);
 220
 221       /* Encode FD and object ID in path name.  Choose the name so as not
 222          to conflict with any (normal) SVR4 library path name.  */
 223       xsnprintf (new->so_name, sizeof new->so_name, "@%s <%d>",
 224                  hex_string (addr), fd);
 225       strcpy (new->so_original_name, new->so_name);
 226
 227       *link_ptr = new;
 228       link_ptr = &new->next;
 229     }
 230
 231   /* Append OpenCL sos.  */
 232   append_ocl_sos (link_ptr);
 233
 234   return head;
 235 }
 236
 237 /* Free so_list information.  */
 238 static void
 239 spu_free_so (struct so_list *so)
 240 {
 241   if (so->so_original_name[0] != '@')
 242     svr4_so_ops.free_so (so);
 243 }
 244
 245 /* Relocate section addresses.  */
 246 static void
 247 spu_relocate_section_addresses (struct so_list *so,
 248                                 struct target_section *sec)
 249 {
 250   if (so->so_original_name[0] != '@')
 251     svr4_so_ops.relocate_section_addresses (so, sec);
 252   else
 253     {
 254       unsigned long long addr;
 255       int fd;
 256
 257       /* Set addr_low/high to just LS offset for display.  */
 258       if (so->addr_low == 0 && so->addr_high == 0
 259           && strcmp (sec->the_bfd_section->name, ".text") == 0)
 260         {
 261           so->addr_low = sec->addr;
 262           so->addr_high = sec->endaddr;
 263         }
 264
 265       /* Decode object ID.  */
 266       if (sscanf (so->so_original_name, "@0x%llx <%d>", &addr, &fd) != 2)
 267         internal_error (__FILE__, __LINE__, "bad object ID");
 268
 269       sec->addr = SPUADDR (fd, sec->addr);
 270       sec->endaddr = SPUADDR (fd, sec->endaddr);
 271     }
 272 }
 273
 274
 275 /* Inferior memory should contain an SPE executable image at location ADDR.
 276    Allocate a BFD representing that executable.  Return NULL on error.  */
 277
 278 static void *
 279 spu_bfd_iovec_open (bfd *nbfd, void *open_closure)
 280 {
 281   return open_closure;
 282 }
 283
 284 static int
 285 spu_bfd_iovec_close (bfd *nbfd, void *stream)
 286 {
 287   xfree (stream);
 288
 289   /* Zero means success.  */
 290   return 0;
 291 }
 292
 293 static file_ptr
 294 spu_bfd_iovec_pread (bfd *abfd, void *stream, void *buf,
 295                      file_ptr nbytes, file_ptr offset)
 296 {
 297   CORE_ADDR addr = *(CORE_ADDR *)stream;
 298   int ret;
 299
 300   ret = target_read_memory (addr + offset, buf, nbytes);
 301   if (ret != 0)
 302     {
 303       bfd_set_error (bfd_error_invalid_operation);
 304       return -1;
 305     }
 306
 307   return nbytes;
 308 }
 309
 310 static int
 311 spu_bfd_iovec_stat (bfd *abfd, void *stream, struct stat *sb)
 312 {
 313   /* We don't have an easy way of finding the size of embedded spu
 314      images.  We could parse the in-memory ELF header and section
 315      table to find the extent of the last section but that seems
 316      pointless when the size is needed only for checks of other
 317      parsed values in dbxread.c.  */
 318   sb->st_size = INT_MAX;
 319   return 0;
 320 }
 321
 322 static bfd *
 323 spu_bfd_fopen (char *name, CORE_ADDR addr)
 324 {
 325   bfd *nbfd;
 326
 327   CORE_ADDR *open_closure = xmalloc (sizeof (CORE_ADDR));
 328   *open_closure = addr;
 329
 330   nbfd = gdb_bfd_openr_iovec (name, "elf32-spu",
 331                               spu_bfd_iovec_open, open_closure,
 332                               spu_bfd_iovec_pread, spu_bfd_iovec_close,
 333                               spu_bfd_iovec_stat);
 334   if (!nbfd)
 335     return NULL;
 336
 337   if (!bfd_check_format (nbfd, bfd_object))
 338     {
 339       gdb_bfd_unref (nbfd);
 340       return NULL;
 341     }
 342
 343   return nbfd;
 344 }
 345
 346 /* Open shared library BFD.  */
 347 static bfd *
 348 spu_bfd_open (char *pathname)
 349 {
 350   char *original_name = strrchr (pathname, '@');
 351   bfd *abfd;
 352   asection *spu_name;
 353   unsigned long long addr;
 354   int fd;
 355
 356   /* Handle regular SVR4 libraries.  */
 357   if (!original_name)
 358     return svr4_so_ops.bfd_open (pathname);
 359
 360   /* Decode object ID.  */
 361   if (sscanf (original_name, "@0x%llx <%d>", &addr, &fd) != 2)
 362     internal_error (__FILE__, __LINE__, "bad object ID");
 363
 364   /* Open BFD representing SPE executable.  */
 365   abfd = spu_bfd_fopen (original_name, (CORE_ADDR) addr);
 366   if (!abfd)
 367     error (_("Cannot read SPE executable at %s"), original_name);
 368
 369   /* Retrieve SPU name note.  */
 370   spu_name = bfd_get_section_by_name (abfd, ".note.spu_name");
 371   if (spu_name)
 372     {
 373       int sect_size = bfd_section_size (abfd, spu_name);
 374
 375       if (sect_size > 20)
 376         {
 377           char *buf = alloca (sect_size - 20 + strlen (original_name) + 1);
 378
 379           bfd_get_section_contents (abfd, spu_name, buf, 20, sect_size - 20);
 380           buf[sect_size - 20] = '\0';
 381
 382           strcat (buf, original_name);
 383
 384           xfree ((char *)abfd->filename);
 385           abfd->filename = xstrdup (buf);
 386         }
 387     }
 388
 389   return abfd;
 390 }
 391
 392 /* Lookup global symbol in a SPE executable.  */
 393 static struct symbol *
 394 spu_lookup_lib_symbol (const struct objfile *objfile,
 395                        const char *name,
 396                        const domain_enum domain)
 397 {
 398   if (bfd_get_arch (objfile->obfd) == bfd_arch_spu)
 399     return lookup_global_symbol_from_objfile (objfile, name, domain);
 400
 401   if (svr4_so_ops.lookup_lib_global_symbol != NULL)
 402     return svr4_so_ops.lookup_lib_global_symbol (objfile, name, domain);
 403   return NULL;
 404 }
 405
 406 /* Enable shared library breakpoint.  */
 407 static int
 408 spu_enable_break (struct objfile *objfile)
 409 {
 410   struct bound_minimal_symbol spe_event_sym;
 411
 412   /* The libspe library will call __spe_context_update_event whenever any
 413      SPE context is allocated or destroyed.  */
 414   spe_event_sym = lookup_minimal_symbol ("__spe_context_update_event",
 415                                          NULL, objfile);
 416
 417   /* Place a solib_event breakpoint on the symbol.  */
 418   if (spe_event_sym.minsym)
 419     {
 420       CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (spe_event_sym);
 421
 422       addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), addr,
 423                                                  &current_target);
 424       create_solib_event_breakpoint (target_gdbarch (), addr);
 425       return 1;
 426     }
 427
 428   return 0;
 429 }
 430
 431 /* Enable shared library breakpoint for the
 432    OpenCL runtime running on the SPU.  */
 433 static void
 434 ocl_enable_break (struct objfile *objfile)
 435 {
 436   struct bound_minimal_symbol event_sym;
 437   struct bound_minimal_symbol addr_sym;
 438
 439   /* The OpenCL runtime on the SPU will call __opencl_program_update_event
 440      whenever an OpenCL program is loaded.  */
 441   event_sym = lookup_minimal_symbol ("__opencl_program_update_event", NULL,
 442                                      objfile);
 443   /* The PPU address of the OpenCL program can be found
 444      at opencl_elf_image_address.  */
 445   addr_sym = lookup_minimal_symbol ("opencl_elf_image_address", NULL, objfile);
 446
 447   if (event_sym.minsym && addr_sym.minsym)
 448     {
 449       /* Place a solib_event breakpoint on the symbol.  */
 450       CORE_ADDR event_addr = BMSYMBOL_VALUE_ADDRESS (event_sym);
 451       create_solib_event_breakpoint (get_objfile_arch (objfile), event_addr);
 452
 453       /* Store the address of the symbol that will point to OpenCL program
 454          using the per-objfile private data mechanism.  */
 455       if (objfile_data (objfile, ocl_program_data_key) == NULL)
 456         {
 457           CORE_ADDR *ocl_program_addr_base = OBSTACK_CALLOC (
 458                   &objfile->objfile_obstack,
 459                   objfile->sections_end - objfile->sections,
 460                   CORE_ADDR);
 461           *ocl_program_addr_base = BMSYMBOL_VALUE_ADDRESS (addr_sym);
 462           set_objfile_data (objfile, ocl_program_data_key,
 463                             ocl_program_addr_base);
 464         }
 465     }
 466 }
 467
 468 /* Create inferior hook.  */
 469 static void
 470 spu_solib_create_inferior_hook (int from_tty)
 471 {
 472   /* Handle SPE stand-alone executables.  */
 473   if (spu_standalone_p ())
 474     {
 475       /* After an SPE stand-alone executable was loaded, we'll receive
 476          an additional trap due to the binfmt_misc handler.  Make sure
 477          to skip that trap.  */
 478       spu_skip_standalone_loader ();
 479
 480       /* If the user established breakpoints before starting the inferior, GDB
 481          would attempt to insert those now.  This would fail because the SPU
 482          context has not yet been created and the SPU executable has not yet
 483          been loaded.  To prevent such failures, we disable all user-created
 484          breakpoints now; they will be re-enabled in spu_current_sos once the
 485          main SPU context has been detected.  */
 486       disable_breakpoints_before_startup ();
 487
 488       /* A special case arises when re-starting an executable, because at
 489          this point it still resides at the relocated address range that was
 490          determined during its last execution.  We need to undo the relocation
 491          so that that multi-architecture target recognizes the stand-alone
 492          initialization special case.  */
 493       spu_relocate_main_executable (-1);
 494     }
 495
 496   /* Call SVR4 hook -- this will re-insert the SVR4 solib breakpoints.  */
 497   svr4_so_ops.solib_create_inferior_hook (from_tty);
 498
 499   /* If the inferior is statically linked against libspe, we need to install
 500      our own solib breakpoint right now.  Otherwise, it will be installed by
 501      the solib_loaded observer below as soon as libspe is loaded.  */
 502   spu_enable_break (NULL);
 503 }
 504
 505 /* Install SPE "shared library" handling.  This is called by -tdep code
 506    that wants to support SPU as a secondary architecture.  */
 507 void
 508 set_spu_solib_ops (struct gdbarch *gdbarch)
 509 {
 510   static struct target_so_ops spu_so_ops;
 511
 512   /* Initialize this lazily, to avoid an initialization order
 513      dependency on solib-svr4.c's _initialize routine.  */
 514   if (spu_so_ops.current_sos == NULL)
 515     {
 516       spu_so_ops = svr4_so_ops;
 517       spu_so_ops.solib_create_inferior_hook = spu_solib_create_inferior_hook;
 518       spu_so_ops.relocate_section_addresses = spu_relocate_section_addresses;
 519       spu_so_ops.free_so = spu_free_so;
 520       spu_so_ops.current_sos = spu_current_sos;
 521       spu_so_ops.bfd_open = spu_bfd_open;
 522       spu_so_ops.lookup_lib_global_symbol = spu_lookup_lib_symbol;
 523     }
 524
 525   set_solib_ops (gdbarch, &spu_so_ops);
 526 }
 527
 528 /* Observer for the solib_loaded event.  Used to install our breakpoint
 529    if libspe is a shared library.  */
 530 static void
 531 spu_solib_loaded (struct so_list *so)
 532 {
 533   if (strstr (so->so_original_name, "/libspe") != NULL)
 534     {
 535       solib_read_symbols (so, 0);
 536       spu_enable_break (so->objfile);
 537     }
 538   /* In case the OpenCL runtime is loaded we install a breakpoint
 539      to get notified whenever an OpenCL program gets loaded.  */
 540   if (strstr (so->so_name, "CLRuntimeAccelCellSPU@") != NULL)
 541     {
 542       solib_read_symbols (so, 0);
 543       ocl_enable_break (so->objfile);
 544     }
 545 }
 546
 547 /* -Wmissing-prototypes */
 548 extern initialize_file_ftype _initialize_spu_solib;
 549
 550 void
 551 _initialize_spu_solib (void)
 552 {
 553   observer_attach_solib_loaded (spu_solib_loaded);
 554   ocl_program_data_key = register_objfile_data ();
 555 }
 556