1 /* Cell SPU GNU/Linux support -- shared library handling.
2 Copyright (C) 2009-2015 Free Software Foundation, Inc.
4 Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
6 This file is part of GDB.
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.
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.
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/>. */
22 #include "solib-spu.h"
25 #include "arch-utils.h"
29 #include "solib-svr4.h"
34 #include "breakpoint.h"
35 #include "gdbthread.h"
40 /* Highest SPE id (file handle) the inferior may have. */
41 #define MAX_SPE_FD 1024
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)
49 /* Relocate main SPE executable. */
51 spu_relocate_main_executable (int spufs_fd
)
53 struct section_offsets
*new_offsets
;
56 if (symfile_objfile
== NULL
)
59 new_offsets
= alloca (symfile_objfile
->num_sections
60 * sizeof (struct section_offsets
));
62 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
63 new_offsets
->offsets
[i
] = SPUADDR (spufs_fd
, 0);
65 objfile_relocate (symfile_objfile
, new_offsets
);
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. */
71 spu_skip_standalone_loader (void)
73 if (target_has_execution
&& !current_inferior ()->attach_flag
)
75 struct target_waitstatus ws
;
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.
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. */
87 inferior_thread ()->control
.in_infcall
= 1; /* Suppress MI messages. */
89 target_resume (inferior_ptid
, 1, GDB_SIGNAL_0
);
90 target_wait (minus_one_ptid
, &ws
, 0);
91 set_executing (minus_one_ptid
, 0);
93 inferior_thread ()->control
.in_infcall
= 0;
97 static const struct objfile_data
*ocl_program_data_key
;
99 /* Appends OpenCL programs to the list of `struct so_list' objects. */
101 append_ocl_sos (struct so_list
**link_ptr
)
103 CORE_ADDR
*ocl_program_addr_base
;
104 struct objfile
*objfile
;
106 ALL_OBJFILES (objfile
)
108 ocl_program_addr_base
= objfile_data (objfile
, ocl_program_data_key
);
109 if (ocl_program_addr_base
!= NULL
)
111 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
)?
112 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
116 read_memory_unsigned_integer (*ocl_program_addr_base
,
121 struct so_list
*newobj
;
123 /* Allocate so_list structure. */
124 newobj
= XCNEW (struct so_list
);
126 /* Encode FD and object ID in path name. */
127 xsnprintf (newobj
->so_name
, sizeof newobj
->so_name
, "@%s <%d>",
129 SPUADDR_SPU (*ocl_program_addr_base
));
130 strcpy (newobj
->so_original_name
, newobj
->so_name
);
133 link_ptr
= &newobj
->next
;
136 CATCH (ex
, RETURN_MASK_ALL
)
138 /* Ignore memory errors. */
144 throw_exception (ex
);
153 /* Build a list of `struct so_list' objects describing the shared
154 objects currently loaded in the inferior. */
155 static struct so_list
*
156 spu_current_sos (void)
158 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
159 struct so_list
*head
;
160 struct so_list
**link_ptr
;
162 gdb_byte buf
[MAX_SPE_FD
* 4];
165 /* First, retrieve the SVR4 shared library list. */
166 head
= svr4_so_ops
.current_sos ();
168 /* Append our libraries to the end of the list. */
169 for (link_ptr
= &head
; *link_ptr
; link_ptr
= &(*link_ptr
)->next
)
172 /* Determine list of SPU ids. */
173 size
= target_read (¤t_target
, TARGET_OBJECT_SPU
, NULL
,
176 /* Do not add stand-alone SPE executable context as shared library,
177 but relocate main SPE executable objfile. */
178 if (spu_standalone_p ())
182 int fd
= extract_unsigned_integer (buf
, 4, byte_order
);
184 spu_relocate_main_executable (fd
);
186 /* Re-enable breakpoints after main SPU context was established;
187 see also comments in spu_solib_create_inferior_hook. */
188 enable_breakpoints_after_startup ();
194 /* Create an so_list entry for each SPU id. */
195 for (i
= 0; i
< size
; i
+= 4)
197 int fd
= extract_unsigned_integer (buf
+ i
, 4, byte_order
);
198 struct so_list
*newobj
;
200 unsigned long long addr
;
201 char annex
[32], id
[100];
204 /* Read object ID. There's a race window where the inferior may have
205 already created the SPE context, but not installed the object-id
206 yet. Skip such entries; we'll be back for them later. */
207 xsnprintf (annex
, sizeof annex
, "%d/object-id", fd
);
208 len
= target_read (¤t_target
, TARGET_OBJECT_SPU
, annex
,
209 (gdb_byte
*) id
, 0, sizeof id
);
210 if (len
<= 0 || len
>= sizeof id
)
213 if (sscanf (id
, "0x%llx", &addr
) != 1 || !addr
)
216 /* Allocate so_list structure. */
217 newobj
= XCNEW (struct so_list
);
219 /* Encode FD and object ID in path name. Choose the name so as not
220 to conflict with any (normal) SVR4 library path name. */
221 xsnprintf (newobj
->so_name
, sizeof newobj
->so_name
, "@%s <%d>",
222 hex_string (addr
), fd
);
223 strcpy (newobj
->so_original_name
, newobj
->so_name
);
226 link_ptr
= &newobj
->next
;
229 /* Append OpenCL sos. */
230 append_ocl_sos (link_ptr
);
235 /* Free so_list information. */
237 spu_free_so (struct so_list
*so
)
239 if (so
->so_original_name
[0] != '@')
240 svr4_so_ops
.free_so (so
);
243 /* Relocate section addresses. */
245 spu_relocate_section_addresses (struct so_list
*so
,
246 struct target_section
*sec
)
248 if (so
->so_original_name
[0] != '@')
249 svr4_so_ops
.relocate_section_addresses (so
, sec
);
252 unsigned long long addr
;
255 /* Set addr_low/high to just LS offset for display. */
256 if (so
->addr_low
== 0 && so
->addr_high
== 0
257 && strcmp (sec
->the_bfd_section
->name
, ".text") == 0)
259 so
->addr_low
= sec
->addr
;
260 so
->addr_high
= sec
->endaddr
;
263 /* Decode object ID. */
264 if (sscanf (so
->so_original_name
, "@0x%llx <%d>", &addr
, &fd
) != 2)
265 internal_error (__FILE__
, __LINE__
, "bad object ID");
267 sec
->addr
= SPUADDR (fd
, sec
->addr
);
268 sec
->endaddr
= SPUADDR (fd
, sec
->endaddr
);
273 /* Inferior memory should contain an SPE executable image at location ADDR.
274 Allocate a BFD representing that executable. Return NULL on error. */
277 spu_bfd_iovec_open (bfd
*nbfd
, void *open_closure
)
283 spu_bfd_iovec_close (bfd
*nbfd
, void *stream
)
287 /* Zero means success. */
292 spu_bfd_iovec_pread (bfd
*abfd
, void *stream
, void *buf
,
293 file_ptr nbytes
, file_ptr offset
)
295 CORE_ADDR addr
= *(CORE_ADDR
*)stream
;
298 ret
= target_read_memory (addr
+ offset
, buf
, nbytes
);
301 bfd_set_error (bfd_error_invalid_operation
);
309 spu_bfd_iovec_stat (bfd
*abfd
, void *stream
, struct stat
*sb
)
311 /* We don't have an easy way of finding the size of embedded spu
312 images. We could parse the in-memory ELF header and section
313 table to find the extent of the last section but that seems
314 pointless when the size is needed only for checks of other
315 parsed values in dbxread.c. */
316 memset (sb
, 0, sizeof (struct stat
));
317 sb
->st_size
= INT_MAX
;
322 spu_bfd_fopen (char *name
, CORE_ADDR addr
)
325 CORE_ADDR
*open_closure
= XNEW (CORE_ADDR
);
327 *open_closure
= addr
;
329 nbfd
= gdb_bfd_openr_iovec (name
, "elf32-spu",
330 spu_bfd_iovec_open
, open_closure
,
331 spu_bfd_iovec_pread
, spu_bfd_iovec_close
,
336 if (!bfd_check_format (nbfd
, bfd_object
))
338 gdb_bfd_unref (nbfd
);
345 /* Open shared library BFD. */
347 spu_bfd_open (char *pathname
)
349 char *original_name
= strrchr (pathname
, '@');
352 unsigned long long addr
;
355 /* Handle regular SVR4 libraries. */
357 return svr4_so_ops
.bfd_open (pathname
);
359 /* Decode object ID. */
360 if (sscanf (original_name
, "@0x%llx <%d>", &addr
, &fd
) != 2)
361 internal_error (__FILE__
, __LINE__
, "bad object ID");
363 /* Open BFD representing SPE executable. */
364 abfd
= spu_bfd_fopen (original_name
, (CORE_ADDR
) addr
);
366 error (_("Cannot read SPE executable at %s"), original_name
);
368 /* Retrieve SPU name note. */
369 spu_name
= bfd_get_section_by_name (abfd
, ".note.spu_name");
372 int sect_size
= bfd_section_size (abfd
, spu_name
);
376 char *buf
= alloca (sect_size
- 20 + strlen (original_name
) + 1);
378 bfd_get_section_contents (abfd
, spu_name
, buf
, 20, sect_size
- 20);
379 buf
[sect_size
- 20] = '\0';
381 strcat (buf
, original_name
);
383 xfree ((char *)abfd
->filename
);
384 abfd
->filename
= xstrdup (buf
);
391 /* Lookup global symbol in a SPE executable. */
392 static struct block_symbol
393 spu_lookup_lib_symbol (struct objfile
*objfile
,
395 const domain_enum domain
)
397 if (bfd_get_arch (objfile
->obfd
) == bfd_arch_spu
)
398 return lookup_global_symbol_from_objfile (objfile
, name
, domain
);
400 if (svr4_so_ops
.lookup_lib_global_symbol
!= NULL
)
401 return svr4_so_ops
.lookup_lib_global_symbol (objfile
, name
, domain
);
402 return (struct block_symbol
) {NULL
, NULL
};
405 /* Enable shared library breakpoint. */
407 spu_enable_break (struct objfile
*objfile
)
409 struct bound_minimal_symbol spe_event_sym
;
411 /* The libspe library will call __spe_context_update_event whenever any
412 SPE context is allocated or destroyed. */
413 spe_event_sym
= lookup_minimal_symbol ("__spe_context_update_event",
416 /* Place a solib_event breakpoint on the symbol. */
417 if (spe_event_sym
.minsym
)
419 CORE_ADDR addr
= BMSYMBOL_VALUE_ADDRESS (spe_event_sym
);
421 addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (), addr
,
423 create_solib_event_breakpoint (target_gdbarch (), addr
);
430 /* Enable shared library breakpoint for the
431 OpenCL runtime running on the SPU. */
433 ocl_enable_break (struct objfile
*objfile
)
435 struct bound_minimal_symbol event_sym
;
436 struct bound_minimal_symbol addr_sym
;
438 /* The OpenCL runtime on the SPU will call __opencl_program_update_event
439 whenever an OpenCL program is loaded. */
440 event_sym
= lookup_minimal_symbol ("__opencl_program_update_event", NULL
,
442 /* The PPU address of the OpenCL program can be found
443 at opencl_elf_image_address. */
444 addr_sym
= lookup_minimal_symbol ("opencl_elf_image_address", NULL
, objfile
);
446 if (event_sym
.minsym
&& addr_sym
.minsym
)
448 /* Place a solib_event breakpoint on the symbol. */
449 CORE_ADDR event_addr
= BMSYMBOL_VALUE_ADDRESS (event_sym
);
450 create_solib_event_breakpoint (get_objfile_arch (objfile
), event_addr
);
452 /* Store the address of the symbol that will point to OpenCL program
453 using the per-objfile private data mechanism. */
454 if (objfile_data (objfile
, ocl_program_data_key
) == NULL
)
456 CORE_ADDR
*ocl_program_addr_base
= OBSTACK_CALLOC (
457 &objfile
->objfile_obstack
,
458 objfile
->sections_end
- objfile
->sections
,
460 *ocl_program_addr_base
= BMSYMBOL_VALUE_ADDRESS (addr_sym
);
461 set_objfile_data (objfile
, ocl_program_data_key
,
462 ocl_program_addr_base
);
467 /* Create inferior hook. */
469 spu_solib_create_inferior_hook (int from_tty
)
471 /* Handle SPE stand-alone executables. */
472 if (spu_standalone_p ())
474 /* After an SPE stand-alone executable was loaded, we'll receive
475 an additional trap due to the binfmt_misc handler. Make sure
476 to skip that trap. */
477 spu_skip_standalone_loader ();
479 /* If the user established breakpoints before starting the inferior, GDB
480 would attempt to insert those now. This would fail because the SPU
481 context has not yet been created and the SPU executable has not yet
482 been loaded. To prevent such failures, we disable all user-created
483 breakpoints now; they will be re-enabled in spu_current_sos once the
484 main SPU context has been detected. */
485 disable_breakpoints_before_startup ();
487 /* A special case arises when re-starting an executable, because at
488 this point it still resides at the relocated address range that was
489 determined during its last execution. We need to undo the relocation
490 so that that multi-architecture target recognizes the stand-alone
491 initialization special case. */
492 spu_relocate_main_executable (-1);
495 /* Call SVR4 hook -- this will re-insert the SVR4 solib breakpoints. */
496 svr4_so_ops
.solib_create_inferior_hook (from_tty
);
498 /* If the inferior is statically linked against libspe, we need to install
499 our own solib breakpoint right now. Otherwise, it will be installed by
500 the solib_loaded observer below as soon as libspe is loaded. */
501 spu_enable_break (NULL
);
504 /* Install SPE "shared library" handling. This is called by -tdep code
505 that wants to support SPU as a secondary architecture. */
507 set_spu_solib_ops (struct gdbarch
*gdbarch
)
509 static struct target_so_ops spu_so_ops
;
511 /* Initialize this lazily, to avoid an initialization order
512 dependency on solib-svr4.c's _initialize routine. */
513 if (spu_so_ops
.current_sos
== NULL
)
515 spu_so_ops
= svr4_so_ops
;
516 spu_so_ops
.solib_create_inferior_hook
= spu_solib_create_inferior_hook
;
517 spu_so_ops
.relocate_section_addresses
= spu_relocate_section_addresses
;
518 spu_so_ops
.free_so
= spu_free_so
;
519 spu_so_ops
.current_sos
= spu_current_sos
;
520 spu_so_ops
.bfd_open
= spu_bfd_open
;
521 spu_so_ops
.lookup_lib_global_symbol
= spu_lookup_lib_symbol
;
524 set_solib_ops (gdbarch
, &spu_so_ops
);
527 /* Observer for the solib_loaded event. Used to install our breakpoint
528 if libspe is a shared library. */
530 spu_solib_loaded (struct so_list
*so
)
532 if (strstr (so
->so_original_name
, "/libspe") != NULL
)
534 solib_read_symbols (so
, 0);
535 spu_enable_break (so
->objfile
);
537 /* In case the OpenCL runtime is loaded we install a breakpoint
538 to get notified whenever an OpenCL program gets loaded. */
539 if (strstr (so
->so_name
, "CLRuntimeAccelCellSPU@") != NULL
)
541 solib_read_symbols (so
, 0);
542 ocl_enable_break (so
->objfile
);
546 /* -Wmissing-prototypes */
547 extern initialize_file_ftype _initialize_spu_solib
;
550 _initialize_spu_solib (void)
552 observer_attach_solib_loaded (spu_solib_loaded
);
553 ocl_program_data_key
= register_objfile_data ();