OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [solib-spu.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* 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
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.