GDB (xrefs)
/tmp/gdb-7.10/gdb/solib-spu.c
Go to the documentation of this file.
1 /* Cell SPU GNU/Linux support -- shared library handling.
2  Copyright (C) 2009-2015 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 <sys/stat.h>
25 #include "arch-utils.h"
26 #include "bfd.h"
27 #include "symtab.h"
28 #include "solib.h"
29 #include "solib-svr4.h"
30 #include "solist.h"
31 #include "inferior.h"
32 #include "objfiles.h"
33 #include "observer.h"
34 #include "breakpoint.h"
35 #include "gdbthread.h"
36 #include "gdb_bfd.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
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
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 ()->control.in_infcall = 1; /* Suppress MI messages. */
88 
89  target_resume (inferior_ptid, 1, GDB_SIGNAL_0);
90  target_wait (minus_one_ptid, &ws, 0);
92 
94  }
95 }
96 
97 static const struct objfile_data *ocl_program_data_key;
98 
99 /* Appends OpenCL programs to the list of `struct so_list' objects. */
100 static void
101 append_ocl_sos (struct so_list **link_ptr)
102 {
103  CORE_ADDR *ocl_program_addr_base;
104  struct objfile *objfile;
105 
106  ALL_OBJFILES (objfile)
107  {
108  ocl_program_addr_base = objfile_data (objfile, ocl_program_data_key);
109  if (ocl_program_addr_base != NULL)
110  {
111  enum bfd_endian byte_order = bfd_big_endian (objfile->obfd)?
112  BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
113  TRY
114  {
115  CORE_ADDR data =
116  read_memory_unsigned_integer (*ocl_program_addr_base,
117  sizeof (CORE_ADDR),
118  byte_order);
119  if (data != 0x0)
120  {
121  struct so_list *newobj;
122 
123  /* Allocate so_list structure. */
124  newobj = XCNEW (struct so_list);
125 
126  /* Encode FD and object ID in path name. */
127  xsnprintf (newobj->so_name, sizeof newobj->so_name, "@%s <%d>",
128  hex_string (data),
129  SPUADDR_SPU (*ocl_program_addr_base));
130  strcpy (newobj->so_original_name, newobj->so_name);
131 
132  *link_ptr = newobj;
133  link_ptr = &newobj->next;
134  }
135  }
136  CATCH (ex, RETURN_MASK_ALL)
137  {
138  /* Ignore memory errors. */
139  switch (ex.error)
140  {
141  case MEMORY_ERROR:
142  break;
143  default:
144  throw_exception (ex);
145  break;
146  }
147  }
148  END_CATCH
149  }
150  }
151 }
152 
153 /* Build a list of `struct so_list' objects describing the shared
154  objects currently loaded in the inferior. */
155 static struct so_list *
157 {
158  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
159  struct so_list *head;
160  struct so_list **link_ptr;
161 
162  gdb_byte buf[MAX_SPE_FD * 4];
163  int i, size;
164 
165  /* First, retrieve the SVR4 shared library list. */
166  head = svr4_so_ops.current_sos ();
167 
168  /* Append our libraries to the end of the list. */
169  for (link_ptr = &head; *link_ptr; link_ptr = &(*link_ptr)->next)
170  ;
171 
172  /* Determine list of SPU ids. */
174  buf, 0, sizeof buf);
175 
176  /* Do not add stand-alone SPE executable context as shared library,
177  but relocate main SPE executable objfile. */
178  if (spu_standalone_p ())
179  {
180  if (size == 4)
181  {
182  int fd = extract_unsigned_integer (buf, 4, byte_order);
183 
185 
186  /* Re-enable breakpoints after main SPU context was established;
187  see also comments in spu_solib_create_inferior_hook. */
189  }
190 
191  return head;
192  }
193 
194  /* Create an so_list entry for each SPU id. */
195  for (i = 0; i < size; i += 4)
196  {
197  int fd = extract_unsigned_integer (buf + i, 4, byte_order);
198  struct so_list *newobj;
199 
200  unsigned long long addr;
201  char annex[32], id[100];
202  int len;
203 
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);
209  (gdb_byte *) id, 0, sizeof id);
210  if (len <= 0 || len >= sizeof id)
211  continue;
212  id[len] = 0;
213  if (sscanf (id, "0x%llx", &addr) != 1 || !addr)
214  continue;
215 
216  /* Allocate so_list structure. */
217  newobj = XCNEW (struct so_list);
218 
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);
224 
225  *link_ptr = newobj;
226  link_ptr = &newobj->next;
227  }
228 
229  /* Append OpenCL sos. */
230  append_ocl_sos (link_ptr);
231 
232  return head;
233 }
234 
235 /* Free so_list information. */
236 static void
237 spu_free_so (struct so_list *so)
238 {
239  if (so->so_original_name[0] != '@')
240  svr4_so_ops.free_so (so);
241 }
242 
243 /* Relocate section addresses. */
244 static void
246  struct target_section *sec)
247 {
248  if (so->so_original_name[0] != '@')
250  else
251  {
252  unsigned long long addr;
253  int fd;
254 
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)
258  {
259  so->addr_low = sec->addr;
260  so->addr_high = sec->endaddr;
261  }
262 
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");
266 
267  sec->addr = SPUADDR (fd, sec->addr);
268  sec->endaddr = SPUADDR (fd, sec->endaddr);
269  }
270 }
271 
272 
273 /* Inferior memory should contain an SPE executable image at location ADDR.
274  Allocate a BFD representing that executable. Return NULL on error. */
275 
276 static void *
277 spu_bfd_iovec_open (bfd *nbfd, void *open_closure)
278 {
279  return open_closure;
280 }
281 
282 static int
283 spu_bfd_iovec_close (bfd *nbfd, void *stream)
284 {
285  xfree (stream);
286 
287  /* Zero means success. */
288  return 0;
289 }
290 
291 static file_ptr
292 spu_bfd_iovec_pread (bfd *abfd, void *stream, void *buf,
293  file_ptr nbytes, file_ptr offset)
294 {
295  CORE_ADDR addr = *(CORE_ADDR *)stream;
296  int ret;
297 
298  ret = target_read_memory (addr + offset, buf, nbytes);
299  if (ret != 0)
300  {
301  bfd_set_error (bfd_error_invalid_operation);
302  return -1;
303  }
304 
305  return nbytes;
306 }
307 
308 static int
309 spu_bfd_iovec_stat (bfd *abfd, void *stream, struct stat *sb)
310 {
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;
318  return 0;
319 }
320 
321 static bfd *
323 {
324  bfd *nbfd;
325 
326  CORE_ADDR *open_closure = xmalloc (sizeof (CORE_ADDR));
327  *open_closure = addr;
328 
329  nbfd = gdb_bfd_openr_iovec (name, "elf32-spu",
330  spu_bfd_iovec_open, open_closure,
333  if (!nbfd)
334  return NULL;
335 
336  if (!bfd_check_format (nbfd, bfd_object))
337  {
338  gdb_bfd_unref (nbfd);
339  return NULL;
340  }
341 
342  return nbfd;
343 }
344 
345 /* Open shared library BFD. */
346 static bfd *
347 spu_bfd_open (char *pathname)
348 {
349  char *original_name = strrchr (pathname, '@');
350  bfd *abfd;
351  asection *spu_name;
352  unsigned long long addr;
353  int fd;
354 
355  /* Handle regular SVR4 libraries. */
356  if (!original_name)
357  return svr4_so_ops.bfd_open (pathname);
358 
359  /* Decode object ID. */
360  if (sscanf (original_name, "@0x%llx <%d>", &addr, &fd) != 2)
361  internal_error (__FILE__, __LINE__, "bad object ID");
362 
363  /* Open BFD representing SPE executable. */
364  abfd = spu_bfd_fopen (original_name, (CORE_ADDR) addr);
365  if (!abfd)
366  error (_("Cannot read SPE executable at %s"), original_name);
367 
368  /* Retrieve SPU name note. */
369  spu_name = bfd_get_section_by_name (abfd, ".note.spu_name");
370  if (spu_name)
371  {
372  int sect_size = bfd_section_size (abfd, spu_name);
373 
374  if (sect_size > 20)
375  {
376  char *buf = alloca (sect_size - 20 + strlen (original_name) + 1);
377 
378  bfd_get_section_contents (abfd, spu_name, buf, 20, sect_size - 20);
379  buf[sect_size - 20] = '\0';
380 
381  strcat (buf, original_name);
382 
383  xfree ((char *)abfd->filename);
384  abfd->filename = xstrdup (buf);
385  }
386  }
387 
388  return abfd;
389 }
390 
391 /* Lookup global symbol in a SPE executable. */
392 static struct symbol *
394  const char *name,
395  const domain_enum domain)
396 {
397  if (bfd_get_arch (objfile->obfd) == bfd_arch_spu)
398  return lookup_global_symbol_from_objfile (objfile, name, domain);
399 
401  return svr4_so_ops.lookup_lib_global_symbol (objfile, name, domain);
402  return NULL;
403 }
404 
405 /* Enable shared library breakpoint. */
406 static int
408 {
409  struct bound_minimal_symbol spe_event_sym;
410 
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",
414  NULL, objfile);
415 
416  /* Place a solib_event breakpoint on the symbol. */
417  if (spe_event_sym.minsym)
418  {
419  CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (spe_event_sym);
420 
422  &current_target);
424  return 1;
425  }
426 
427  return 0;
428 }
429 
430 /* Enable shared library breakpoint for the
431  OpenCL runtime running on the SPU. */
432 static void
434 {
435  struct bound_minimal_symbol event_sym;
436  struct bound_minimal_symbol addr_sym;
437 
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,
441  objfile);
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);
445 
446  if (event_sym.minsym && addr_sym.minsym)
447  {
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);
451 
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)
455  {
456  CORE_ADDR *ocl_program_addr_base = OBSTACK_CALLOC (
457  &objfile->objfile_obstack,
458  objfile->sections_end - objfile->sections,
459  CORE_ADDR);
460  *ocl_program_addr_base = BMSYMBOL_VALUE_ADDRESS (addr_sym);
461  set_objfile_data (objfile, ocl_program_data_key,
462  ocl_program_addr_base);
463  }
464  }
465 }
466 
467 /* Create inferior hook. */
468 static void
470 {
471  /* Handle SPE stand-alone executables. */
472  if (spu_standalone_p ())
473  {
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. */
478 
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. */
486 
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. */
493  }
494 
495  /* Call SVR4 hook -- this will re-insert the SVR4 solib breakpoints. */
497 
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);
502 }
503 
504 /* Install SPE "shared library" handling. This is called by -tdep code
505  that wants to support SPU as a secondary architecture. */
506 void
508 {
509  static struct target_so_ops spu_so_ops;
510 
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)
514  {
515  spu_so_ops = svr4_so_ops;
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;
522  }
523 
524  set_solib_ops (gdbarch, &spu_so_ops);
525 }
526 
527 /* Observer for the solib_loaded event. Used to install our breakpoint
528  if libspe is a shared library. */
529 static void
531 {
532  if (strstr (so->so_original_name, "/libspe") != NULL)
533  {
534  solib_read_symbols (so, 0);
536  }
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)
540  {
541  solib_read_symbols (so, 0);
543  }
544 }
545 
546 /* -Wmissing-prototypes */
548 
549 void
551 {
553  ocl_program_data_key = register_objfile_data ();
554 }
555 
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
struct symbol *(* lookup_lib_global_symbol)(struct objfile *objfile, const char *name, const domain_enum domain)
Definition: solist.h:140
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static void ocl_enable_break(struct objfile *objfile)
Definition: solib-spu.c:433
static void spu_relocate_main_executable(int spufs_fd)
Definition: solib-spu.c:51
#define SPUADDR(spu, addr)
Definition: spu-tdep.h:104
CORE_ADDR offsets[1]
Definition: symtab.h:907
#define OBSTACK_CALLOC(OBSTACK, NUMBER, TYPE)
Definition: gdb_obstack.h:30
void enable_breakpoints_after_startup(void)
Definition: breakpoint.c:8723
bfd * obfd
Definition: objfiles.h:313
bfd_vma CORE_ADDR
Definition: common-types.h:41
void disable_breakpoints_before_startup(void)
Definition: breakpoint.c:8716
void xfree(void *)
Definition: common-utils.c:97
struct so_list * next
Definition: solist.h:36
struct breakpoint * create_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7721
static void * spu_bfd_iovec_open(bfd *nbfd, void *open_closure)
Definition: solib-spu.c:277
static const struct objfile_data * ocl_program_data_key
Definition: solib-spu.c:97
void set_solib_ops(struct gdbarch *gdbarch, const struct target_so_ops *new_ops)
Definition: solib.c:76
#define INT_MAX
Definition: defs.h:509
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
static void spu_solib_loaded(struct so_list *so)
Definition: solib-spu.c:530
static void append_ocl_sos(struct so_list **link_ptr)
Definition: solib-spu.c:101
#define SPUADDR_SPU(addr)
Definition: spu-tdep.h:107
initialize_file_ftype _initialize_spu_solib
enum domain_enum_tag domain_enum
void(* relocate_section_addresses)(struct so_list *so, struct target_section *)
Definition: solist.h:84
#define spu_standalone_p()
Definition: solib-spu.c:44
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
struct thread_info * inferior_thread(void)
Definition: thread.c:85
void(* solib_create_inferior_hook)(int from_tty)
Definition: solist.h:101
struct so_list *(* current_sos)(void)
Definition: solist.h:116
void objfile_relocate(struct objfile *objfile, const struct section_offsets *new_offsets)
Definition: objfiles.c:836
bfd *(* bfd_open)(char *pathname)
Definition: solist.h:130
static int spu_bfd_iovec_stat(bfd *abfd, void *stream, struct stat *sb)
Definition: solib-spu.c:309
static struct so_list * spu_current_sos(void)
Definition: solib-spu.c:156
Definition: solist.h:30
struct symbol * lookup_global_symbol_from_objfile(struct objfile *main_objfile, const char *name, const domain_enum domain)
Definition: symtab.c:2290
#define _(String)
Definition: gdb_locale.h:40
#define END_CATCH
bfd * abfd
Definition: solist.h:63
struct obstack objfile_obstack
Definition: objfiles.h:328
#define TRY
const char *const name
Definition: aarch64-tdep.c:68
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
static void spu_solib_create_inferior_hook(int from_tty)
Definition: solib-spu.c:469
#define CATCH(EXCEPTION, MASK)
static void spu_relocate_section_addresses(struct so_list *so, struct target_section *sec)
Definition: solib-spu.c:245
struct target_ops current_target
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
void initialize_file_ftype(void)
Definition: defs.h:281
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:2975
void target_resume(ptid_t ptid, int step, enum gdb_signal signal)
Definition: target.c:2245
static void spu_skip_standalone_loader(void)
Definition: solib-spu.c:71
char so_original_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:49
int solib_read_symbols(struct so_list *so, int flags)
Definition: solib.c:669
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
static int spu_enable_break(struct objfile *objfile)
Definition: solib-spu.c:407
struct obj_section * sections
Definition: objfiles.h:386
char so_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:52
struct thread_control_state control
Definition: gdbthread.h:198
bfd * gdb_bfd_openr_iovec(const char *filename, const char *target, void *(*open_func)(struct bfd *nbfd, void *open_closure), void *open_closure, file_ptr(*pread_func)(struct bfd *nbfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset), int(*close_func)(struct bfd *nbfd, void *stream), int(*stat_func)(struct bfd *abfd, void *stream, struct stat *sb))
Definition: gdb_bfd.c:715
static bfd * spu_bfd_open(char *pathname)
Definition: solib-spu.c:347
#define symfile_objfile
Definition: progspace.h:216
CORE_ADDR endaddr
Definition: target.h:2260
#define target_has_execution
Definition: target.h:1726
ptid_t target_wait(ptid_t ptid, struct target_waitstatus *status, int options)
Definition: target.c:2227
struct bfd_section * the_bfd_section
Definition: target.h:2262
void set_spu_solib_ops(struct gdbarch *gdbarch)
Definition: solib-spu.c:507
void * xmalloc(YYSIZE_T)
CORE_ADDR addr
Definition: target.h:2259
void throw_exception(struct gdb_exception exception)
bfd_byte gdb_byte
Definition: common-types.h:38
struct target_so_ops svr4_so_ops
Definition: solib-svr4.c:3208
CORE_ADDR addr_low
Definition: solist.h:77
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
struct obj_section * sections_end
Definition: objfiles.h:386
ptid_t inferior_ptid
Definition: infcmd.c:124
struct minimal_symbol * minsym
Definition: minsyms.h:32
void(* free_so)(struct so_list *so)
Definition: solist.h:89
static struct symbol * spu_lookup_lib_symbol(struct objfile *objfile, const char *name, const domain_enum domain)
Definition: solib-spu.c:393
int offset
Definition: agent.c:65
static int spu_bfd_iovec_close(bfd *nbfd, void *stream)
Definition: solib-spu.c:283
static bfd * spu_bfd_fopen(char *name, CORE_ADDR addr)
Definition: solib-spu.c:322
struct inferior * current_inferior(void)
Definition: inferior.c:57
Definition: symtab.h:703
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1590
static void spu_free_so(struct so_list *so)
Definition: solib-spu.c:237
CORE_ADDR addr_high
Definition: solist.h:77
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
struct objfile * objfile
Definition: solist.h:69
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
#define MAX_SPE_FD
Definition: solib-spu.c:41
void set_executing(ptid_t ptid, int executing)
Definition: thread.c:850
static file_ptr spu_bfd_iovec_pread(bfd *abfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset)
Definition: solib-spu.c:292
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
ptid_t minus_one_ptid
Definition: ptid.c:26
struct observer * observer_attach_solib_loaded(observer_solib_loaded_ftype *f)
__extension__ enum domain_enum_tag domain
Definition: symtab.h:730
const ULONGEST const LONGEST len
Definition: target.h:309