1 /* Cell SPU GNU/Linux support -- shared library handling.
2 Copyright (C) 2009 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 2 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, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
26 #include "gdb_assert.h"
28 #include "arch-utils.h"
32 #include "solib-svr4.h"
37 #include "breakpoint.h"
38 #include "gdbthread.h"
42 /* Highest SPE id (file handle) the inferior may have. */
43 #define MAX_SPE_FD 1024
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)
51 /* Relocate main SPE executable. */
53 spu_relocate_main_executable (int spufs_fd
)
55 struct objfile
*objfile
;
56 struct cleanup
*old_chain
;
57 struct section_offsets
*new_offsets
;
60 for (objfile
= symfile_objfile
;
62 objfile
= objfile
->separate_debug_objfile
)
64 new_offsets
= xcalloc (objfile
->num_sections
,
65 sizeof (struct section_offsets
));
66 old_chain
= make_cleanup (xfree
, new_offsets
);
68 for (i
= 0; i
< objfile
->num_sections
; i
++)
69 new_offsets
->offsets
[i
] = SPUADDR (spufs_fd
, 0);
71 objfile_relocate (objfile
, new_offsets
);
72 do_cleanups (old_chain
);
76 /* When running a stand-alone SPE executable, we may need to skip one more
77 exec event on startup, to get past the binfmt_misc loader. */
79 spu_skip_standalone_loader (void)
81 if (target_has_execution
&& !current_inferior ()->attach_flag
)
83 struct target_waitstatus ws
;
85 /* Only some kernels report an extra SIGTRAP with the binfmt_misc
86 loader; others do not. In addition, if we have attached to an
87 already running inferior instead of starting a new one, we will
88 not see the extra SIGTRAP -- and we cannot readily distinguish
89 the two cases, in particular with the extended-remote target.
91 Thus we issue a single-step here. If no extra SIGTRAP was pending,
92 this will step past the first instruction of the stand-alone SPE
93 executable loader, but we don't care about that. */
95 inferior_thread ()->in_infcall
= 1; /* Suppress MI messages. */
97 target_resume (inferior_ptid
, 1, TARGET_SIGNAL_0
);
98 target_wait (minus_one_ptid
, &ws
, 0);
99 set_executing (minus_one_ptid
, 0);
101 inferior_thread ()->in_infcall
= 0;
105 /* Build a list of `struct so_list' objects describing the shared
106 objects currently loaded in the inferior. */
107 static struct so_list
*
108 spu_current_sos (void)
110 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
111 struct so_list
*head
;
112 struct so_list
**link_ptr
;
114 char buf
[MAX_SPE_FD
* 4];
117 /* First, retrieve the SVR4 shared library list. */
118 head
= svr4_so_ops
.current_sos ();
120 /* Append our libraries to the end of the list. */
121 for (link_ptr
= &head
; *link_ptr
; link_ptr
= &(*link_ptr
)->next
)
124 /* Determine list of SPU ids. */
125 size
= target_read (¤t_target
, TARGET_OBJECT_SPU
, NULL
,
128 /* Do not add stand-alone SPE executable context as shared library,
129 but relocate main SPE executable objfile. */
130 if (spu_standalone_p ())
134 int fd
= extract_unsigned_integer (buf
, 4, byte_order
);
135 spu_relocate_main_executable (fd
);
137 /* Re-enable breakpoints after main SPU context was established;
138 see also comments in spu_solib_create_inferior_hook. */
139 enable_breakpoints_after_startup ();
145 /* Create an so_list entry for each SPU id. */
146 for (i
= 0; i
< size
; i
+= 4)
148 int fd
= extract_unsigned_integer (buf
+ i
, 4, byte_order
);
151 unsigned long long addr
;
152 char annex
[32], id
[100];
155 /* Read object ID. There's a race window where the inferior may have
156 already created the SPE context, but not installed the object-id
157 yet. Skip such entries; we'll be back for them later. */
158 xsnprintf (annex
, sizeof annex
, "%d/object-id", fd
);
159 len
= target_read (¤t_target
, TARGET_OBJECT_SPU
, annex
,
161 if (len
<= 0 || len
>= sizeof id
)
164 if (sscanf (id
, "0x%llx", &addr
) != 1 || !addr
)
167 /* Allocate so_list structure. */
168 new = XZALLOC (struct so_list
);
170 /* Encode FD and object ID in path name. Choose the name so as not
171 to conflict with any (normal) SVR4 library path name. */
172 xsnprintf (new->so_name
, sizeof new->so_name
, "@0x%llx <%d>", addr
, fd
);
173 strcpy (new->so_original_name
, new->so_name
);
176 link_ptr
= &new->next
;
182 /* Free so_list information. */
184 spu_free_so (struct so_list
*so
)
186 if (so
->so_original_name
[0] != '@')
187 svr4_so_ops
.free_so (so
);
190 /* Relocate section addresses. */
192 spu_relocate_section_addresses (struct so_list
*so
,
193 struct target_section
*sec
)
195 if (so
->so_original_name
[0] != '@')
196 svr4_so_ops
.relocate_section_addresses (so
, sec
);
199 unsigned long long addr
;
202 /* Set addr_low/high to just LS offset for display. */
203 if (so
->addr_low
== 0 && so
->addr_high
== 0
204 && strcmp (sec
->the_bfd_section
->name
, ".text") == 0)
206 so
->addr_low
= sec
->addr
;
207 so
->addr_high
= sec
->endaddr
;
210 /* Decode object ID. */
211 if (sscanf (so
->so_original_name
, "@0x%llx <%d>", &addr
, &fd
) != 2)
212 internal_error (__FILE__
, __LINE__
, "bad object ID");
214 sec
->addr
= SPUADDR (fd
, sec
->addr
);
215 sec
->endaddr
= SPUADDR (fd
, sec
->endaddr
);
220 /* Inferior memory should contain an SPE executable image at location ADDR.
221 Allocate a BFD representing that executable. Return NULL on error. */
224 spu_bfd_iovec_open (bfd
*nbfd
, void *open_closure
)
230 spu_bfd_iovec_close (bfd
*nbfd
, void *stream
)
237 spu_bfd_iovec_pread (bfd
*abfd
, void *stream
, void *buf
,
238 file_ptr nbytes
, file_ptr offset
)
240 CORE_ADDR addr
= *(CORE_ADDR
*)stream
;
243 ret
= target_read_memory (addr
+ offset
, buf
, nbytes
);
246 bfd_set_error (bfd_error_invalid_operation
);
254 spu_bfd_iovec_stat (bfd
*abfd
, void *stream
, struct stat
*sb
)
256 /* We don't have an easy way of finding the size of embedded spu
257 images. We could parse the in-memory ELF header and section
258 table to find the extent of the last section but that seems
259 pointless when the size is needed only for checks of other
260 parsed values in dbxread.c. */
261 sb
->st_size
= INT_MAX
;
266 spu_bfd_fopen (char *name
, CORE_ADDR addr
)
270 CORE_ADDR
*open_closure
= xmalloc (sizeof (CORE_ADDR
));
271 *open_closure
= addr
;
273 nbfd
= bfd_openr_iovec (xstrdup (name
), "elf32-spu",
274 spu_bfd_iovec_open
, open_closure
,
275 spu_bfd_iovec_pread
, spu_bfd_iovec_close
,
280 if (!bfd_check_format (nbfd
, bfd_object
))
289 /* Open shared library BFD. */
291 spu_bfd_open (char *pathname
)
293 char *original_name
= strrchr (pathname
, '@');
296 unsigned long long addr
;
299 /* Handle regular SVR4 libraries. */
301 return svr4_so_ops
.bfd_open (pathname
);
303 /* Decode object ID. */
304 if (sscanf (original_name
, "@0x%llx <%d>", &addr
, &fd
) != 2)
305 internal_error (__FILE__
, __LINE__
, "bad object ID");
307 /* Open BFD representing SPE executable. */
308 abfd
= spu_bfd_fopen (original_name
, (CORE_ADDR
) addr
);
310 error (_("Cannot read SPE executable at %s"), original_name
);
312 /* Retrieve SPU name note. */
313 spu_name
= bfd_get_section_by_name (abfd
, ".note.spu_name");
316 int sect_size
= bfd_section_size (abfd
, spu_name
);
319 char *buf
= alloca (sect_size
- 20 + strlen (original_name
) + 1);
320 bfd_get_section_contents (abfd
, spu_name
, buf
, 20, sect_size
- 20);
321 buf
[sect_size
- 20] = '\0';
323 strcat (buf
, original_name
);
325 xfree ((char *)abfd
->filename
);
326 abfd
->filename
= xstrdup (buf
);
333 /* Lookup global symbol in a SPE executable. */
334 static struct symbol
*
335 spu_lookup_lib_symbol (const struct objfile
*objfile
,
337 const char *linkage_name
,
338 const domain_enum domain
)
340 if (bfd_get_arch (objfile
->obfd
) == bfd_arch_spu
)
341 return lookup_global_symbol_from_objfile (objfile
, name
, linkage_name
,
344 if (svr4_so_ops
.lookup_lib_global_symbol
!= NULL
)
345 return svr4_so_ops
.lookup_lib_global_symbol (objfile
, name
, linkage_name
,
350 /* Enable shared library breakpoint. */
352 spu_enable_break (struct objfile
*objfile
)
354 struct minimal_symbol
*spe_event_sym
= NULL
;
356 /* The libspe library will call __spe_context_update_event whenever any
357 SPE context is allocated or destroyed. */
358 spe_event_sym
= lookup_minimal_symbol ("__spe_context_update_event",
361 /* Place a solib_event breakpoint on the symbol. */
364 CORE_ADDR addr
= SYMBOL_VALUE_ADDRESS (spe_event_sym
);
365 addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch
, addr
,
367 create_solib_event_breakpoint (target_gdbarch
, addr
);
374 /* Create inferior hook. */
376 spu_solib_create_inferior_hook (void)
378 /* Remove all previously installed solib breakpoints. Both the SVR4
379 code and us will re-install all required breakpoints. */
380 remove_solib_event_breakpoints ();
382 /* Handle SPE stand-alone executables. */
383 if (spu_standalone_p ())
385 /* After an SPE stand-alone executable was loaded, we'll receive
386 an additional trap due to the binfmt_misc handler. Make sure
387 to skip that trap. */
388 spu_skip_standalone_loader ();
390 /* If the user established breakpoints before starting the inferior, GDB
391 would attempt to insert those now. This would fail because the SPU
392 context has not yet been created and the SPU executable has not yet
393 been loaded. To prevent such failures, we disable all user-created
394 breakpoints now; they will be re-enabled in spu_current_sos once the
395 main SPU context has been detected. */
396 disable_breakpoints_before_startup ();
398 /* A special case arises when re-starting an executable, because at
399 this point it still resides at the relocated address range that was
400 determined during its last execution. We need to undo the relocation
401 so that that multi-architecture target recognizes the stand-alone
402 initialization special case. */
403 spu_relocate_main_executable (-1);
406 /* Call SVR4 hook -- this will re-insert the SVR4 solib breakpoints. */
407 svr4_so_ops
.solib_create_inferior_hook ();
409 /* If the inferior is statically linked against libspe, we need to install
410 our own solib breakpoint right now. Otherwise, it will be installed by
411 the solib_loaded observer below as soon as libspe is loaded. */
412 spu_enable_break (NULL
);
415 /* Install SPE "shared library" handling. This is called by -tdep code
416 that wants to support SPU as a secondary architecture. */
418 set_spu_solib_ops (struct gdbarch
*gdbarch
)
420 static struct target_so_ops spu_so_ops
;
422 /* Initialize this lazily, to avoid an initialization order
423 dependency on solib-svr4.c's _initialize routine. */
424 if (spu_so_ops
.current_sos
== NULL
)
426 spu_so_ops
= svr4_so_ops
;
427 spu_so_ops
.solib_create_inferior_hook
= spu_solib_create_inferior_hook
;
428 spu_so_ops
.relocate_section_addresses
= spu_relocate_section_addresses
;
429 spu_so_ops
.free_so
= spu_free_so
;
430 spu_so_ops
.current_sos
= spu_current_sos
;
431 spu_so_ops
.bfd_open
= spu_bfd_open
;
432 spu_so_ops
.lookup_lib_global_symbol
= spu_lookup_lib_symbol
;
435 set_solib_ops (gdbarch
, &spu_so_ops
);
438 /* Observer for the solib_loaded event. Used to install our breakpoint
439 if libspe is a shared library. */
441 spu_solib_loaded (struct so_list
*so
)
443 if (strstr (so
->so_original_name
, "/libspe") != NULL
)
445 solib_read_symbols (so
, so
->from_tty
? SYMFILE_VERBOSE
: 0);
446 spu_enable_break (so
->objfile
);
451 _initialize_spu_solib (void)
453 observer_attach_solib_loaded (spu_solib_loaded
);