gdb/solib-spu.c

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