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