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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [solib.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Handle shared libraries for GDB, the GNU Debugger.
2
 
3
   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4
   2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
 
24
#include <sys/types.h>
25
#include <fcntl.h>
26
#include "gdb_string.h"
27
#include "symtab.h"
28
#include "bfd.h"
29
#include "symfile.h"
30
#include "objfiles.h"
31
#include "exceptions.h"
32
#include "gdbcore.h"
33
#include "command.h"
34
#include "target.h"
35
#include "frame.h"
36
#include "gdb_regex.h"
37
#include "inferior.h"
38
#include "environ.h"
39
#include "language.h"
40
#include "gdbcmd.h"
41
#include "completer.h"
42
#include "filenames.h"          /* for DOSish file names */
43
#include "exec.h"
44
#include "solist.h"
45
#include "observer.h"
46
#include "readline/readline.h"
47
 
48
/* Architecture-specific operations.  */
49
 
50
/* Per-architecture data key.  */
51
static struct gdbarch_data *solib_data;
52
 
53
static void *
54
solib_init (struct obstack *obstack)
55
{
56
  struct target_so_ops **ops;
57
 
58
  ops = OBSTACK_ZALLOC (obstack, struct target_so_ops *);
59
  *ops = current_target_so_ops;
60
  return ops;
61
}
62
 
63
static struct target_so_ops *
64
solib_ops (struct gdbarch *gdbarch)
65
{
66
  struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
67
  return *ops;
68
}
69
 
70
/* Set the solib operations for GDBARCH to NEW_OPS.  */
71
 
72
void
73
set_solib_ops (struct gdbarch *gdbarch, struct target_so_ops *new_ops)
74
{
75
  struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
76
  *ops = new_ops;
77
}
78
 
79
 
80
/* external data declarations */
81
 
82
/* FIXME: gdbarch needs to control this variable, or else every
83
   configuration needs to call set_solib_ops.  */
84
struct target_so_ops *current_target_so_ops;
85
 
86
/* local data declarations */
87
 
88
static struct so_list *so_list_head;    /* List of known shared objects */
89
 
90
/* Local function prototypes */
91
 
92
/* If non-empty, this is a search path for loading non-absolute shared library
93
   symbol files.  This takes precedence over the environment variables PATH
94
   and LD_LIBRARY_PATH.  */
95
static char *solib_search_path = NULL;
96
static void
97
show_solib_search_path (struct ui_file *file, int from_tty,
98
                        struct cmd_list_element *c, const char *value)
99
{
100
  fprintf_filtered (file, _("\
101
The search path for loading non-absolute shared library symbol files is %s.\n"),
102
                    value);
103
}
104
 
105
/*
106
 
107
   GLOBAL FUNCTION
108
 
109
   solib_open -- Find a shared library file and open it.
110
 
111
   SYNOPSIS
112
 
113
   int solib_open (char *in_patname, char **found_pathname);
114
 
115
   DESCRIPTION
116
 
117
   Global variable GDB_SYSROOT is used as a prefix directory
118
   to search for shared libraries if they have an absolute path.
119
 
120
   Global variable SOLIB_SEARCH_PATH is used as a prefix directory
121
   (or set of directories, as in LD_LIBRARY_PATH) to search for all
122
   shared libraries if not found in GDB_SYSROOT.
123
 
124
   Search algorithm:
125
   * If there is a gdb_sysroot and path is absolute:
126
   *   Search for gdb_sysroot/path.
127
   * else
128
   *   Look for it literally (unmodified).
129
   * Look in SOLIB_SEARCH_PATH.
130
   * If available, use target defined search function.
131
   * If gdb_sysroot is NOT set, perform the following two searches:
132
   *   Look in inferior's $PATH.
133
   *   Look in inferior's $LD_LIBRARY_PATH.
134
   *
135
   * The last check avoids doing this search when targetting remote
136
   * machines since gdb_sysroot will almost always be set.
137
 
138
   RETURNS
139
 
140
   file handle for opened solib, or -1 for failure.  */
141
 
142
int
143
solib_open (char *in_pathname, char **found_pathname)
144
{
145
  struct target_so_ops *ops = solib_ops (current_gdbarch);
146
  int found_file = -1;
147
  char *temp_pathname = NULL;
148
  char *p = in_pathname;
149
  int gdb_sysroot_is_empty;
150
 
151
  gdb_sysroot_is_empty = (gdb_sysroot == NULL || *gdb_sysroot == 0);
152
 
153
  if (! IS_ABSOLUTE_PATH (in_pathname) || gdb_sysroot_is_empty)
154
    temp_pathname = in_pathname;
155
  else
156
    {
157
      int prefix_len = strlen (gdb_sysroot);
158
 
159
      /* Remove trailing slashes from absolute prefix.  */
160
      while (prefix_len > 0
161
             && IS_DIR_SEPARATOR (gdb_sysroot[prefix_len - 1]))
162
        prefix_len--;
163
 
164
      /* Cat the prefixed pathname together.  */
165
      temp_pathname = alloca (prefix_len + strlen (in_pathname) + 1);
166
      strncpy (temp_pathname, gdb_sysroot, prefix_len);
167
      temp_pathname[prefix_len] = '\0';
168
      strcat (temp_pathname, in_pathname);
169
    }
170
 
171
  /* Now see if we can open it.  */
172
  found_file = open (temp_pathname, O_RDONLY | O_BINARY, 0);
173
 
174
  /* We try to find the library in various ways.  After each attempt
175
     (except for the one above), either found_file >= 0 and
176
     temp_pathname is a malloc'd string, or found_file < 0 and
177
     temp_pathname does not point to storage that needs to be
178
     freed.  */
179
 
180
    if (found_file < 0)
181
      temp_pathname = NULL;
182
    else
183
      temp_pathname = xstrdup (temp_pathname);
184
 
185
  /* If the search in gdb_sysroot failed, and the path name is
186
     absolute at this point, make it relative.  (openp will try and open the
187
     file according to its absolute path otherwise, which is not what we want.)
188
     Affects subsequent searches for this solib.  */
189
  if (found_file < 0 && IS_ABSOLUTE_PATH (in_pathname))
190
    {
191
      /* First, get rid of any drive letters etc.  */
192
      while (!IS_DIR_SEPARATOR (*in_pathname))
193
        in_pathname++;
194
 
195
      /* Next, get rid of all leading dir separators.  */
196
      while (IS_DIR_SEPARATOR (*in_pathname))
197
        in_pathname++;
198
    }
199
 
200
  /* If not found, search the solib_search_path (if any).  */
201
  if (found_file < 0 && solib_search_path != NULL)
202
    found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST,
203
                        in_pathname, O_RDONLY | O_BINARY, 0, &temp_pathname);
204
 
205
  /* If not found, next search the solib_search_path (if any) for the basename
206
     only (ignoring the path).  This is to allow reading solibs from a path
207
     that differs from the opened path.  */
208
  if (found_file < 0 && solib_search_path != NULL)
209
    found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST,
210
                        lbasename (in_pathname), O_RDONLY | O_BINARY, 0,
211
                        &temp_pathname);
212
 
213
  /* If not found, try to use target supplied solib search method */
214
  if (found_file < 0 && ops->find_and_open_solib)
215
    found_file = ops->find_and_open_solib (in_pathname, O_RDONLY | O_BINARY,
216
                                           &temp_pathname);
217
 
218
  /* If not found, next search the inferior's $PATH environment variable. */
219
  if (found_file < 0 && gdb_sysroot_is_empty)
220
    found_file = openp (get_in_environ (inferior_environ, "PATH"),
221
                        OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY, 0,
222
                        &temp_pathname);
223
 
224
  /* If not found, next search the inferior's $LD_LIBRARY_PATH
225
     environment variable. */
226
  if (found_file < 0 && gdb_sysroot_is_empty)
227
    found_file = openp (get_in_environ (inferior_environ, "LD_LIBRARY_PATH"),
228
                        OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY, 0,
229
                        &temp_pathname);
230
 
231
  /* Done.  If not found, tough luck.  Return found_file and
232
     (optionally) found_pathname.  */
233
  if (temp_pathname)
234
    {
235
      if (found_pathname != NULL)
236
        *found_pathname = temp_pathname;
237
      else
238
        xfree (temp_pathname);
239
    }
240
  return found_file;
241
}
242
 
243
 
244
/*
245
 
246
   LOCAL FUNCTION
247
 
248
   solib_map_sections -- open bfd and build sections for shared lib
249
 
250
   SYNOPSIS
251
 
252
   static int solib_map_sections (struct so_list *so)
253
 
254
   DESCRIPTION
255
 
256
   Given a pointer to one of the shared objects in our list
257
   of mapped objects, use the recorded name to open a bfd
258
   descriptor for the object, build a section table, and then
259
   relocate all the section addresses by the base address at
260
   which the shared object was mapped.
261
 
262
   FIXMES
263
 
264
   In most (all?) cases the shared object file name recorded in the
265
   dynamic linkage tables will be a fully qualified pathname.  For
266
   cases where it isn't, do we really mimic the systems search
267
   mechanism correctly in the below code (particularly the tilde
268
   expansion stuff?).
269
 */
270
 
271
static int
272
solib_map_sections (void *arg)
273
{
274
  struct so_list *so = (struct so_list *) arg;  /* catch_errors bogon */
275
  char *filename;
276
  char *scratch_pathname;
277
  int scratch_chan;
278
  struct section_table *p;
279
  struct cleanup *old_chain;
280
  bfd *abfd;
281
 
282
  filename = tilde_expand (so->so_name);
283
 
284
  old_chain = make_cleanup (xfree, filename);
285
  scratch_chan = solib_open (filename, &scratch_pathname);
286
 
287
  if (scratch_chan < 0)
288
    {
289
      perror_with_name (filename);
290
    }
291
 
292
  /* Leave scratch_pathname allocated.  abfd->name will point to it.  */
293
  abfd = bfd_fopen (scratch_pathname, gnutarget, FOPEN_RB, scratch_chan);
294
  if (!abfd)
295
    {
296
      close (scratch_chan);
297
      error (_("Could not open `%s' as an executable file: %s"),
298
             scratch_pathname, bfd_errmsg (bfd_get_error ()));
299
    }
300
 
301
  /* Leave bfd open, core_xfer_memory and "info files" need it.  */
302
  so->abfd = abfd;
303
  bfd_set_cacheable (abfd, 1);
304
 
305
  /* copy full path name into so_name, so that later symbol_file_add
306
     can find it */
307
  if (strlen (scratch_pathname) >= SO_NAME_MAX_PATH_SIZE)
308
    error (_("Full path name length of shared library exceeds SO_NAME_MAX_PATH_SIZE in so_list structure."));
309
  strcpy (so->so_name, scratch_pathname);
310
 
311
  if (!bfd_check_format (abfd, bfd_object))
312
    {
313
      error (_("\"%s\": not in executable format: %s."),
314
             scratch_pathname, bfd_errmsg (bfd_get_error ()));
315
    }
316
  if (build_section_table (abfd, &so->sections, &so->sections_end))
317
    {
318
      error (_("Can't find the file sections in `%s': %s"),
319
             bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
320
    }
321
 
322
  for (p = so->sections; p < so->sections_end; p++)
323
    {
324
      struct target_so_ops *ops = solib_ops (current_gdbarch);
325
 
326
      /* Relocate the section binding addresses as recorded in the shared
327
         object's file by the base address to which the object was actually
328
         mapped. */
329
      ops->relocate_section_addresses (so, p);
330
 
331
      /* If the target didn't provide information about the address
332
         range of the shared object, assume we want the location of
333
         the .text section.  */
334
      if (so->addr_low == 0 && so->addr_high == 0
335
          && strcmp (p->the_bfd_section->name, ".text") == 0)
336
        {
337
          so->addr_low = p->addr;
338
          so->addr_high = p->endaddr;
339
        }
340
    }
341
 
342
  /* Free the file names, close the file now.  */
343
  do_cleanups (old_chain);
344
 
345
  return (1);
346
}
347
 
348
/* LOCAL FUNCTION
349
 
350
   free_so --- free a `struct so_list' object
351
 
352
   SYNOPSIS
353
 
354
   void free_so (struct so_list *so)
355
 
356
   DESCRIPTION
357
 
358
   Free the storage associated with the `struct so_list' object SO.
359
   If we have opened a BFD for SO, close it.
360
 
361
   The caller is responsible for removing SO from whatever list it is
362
   a member of.  If we have placed SO's sections in some target's
363
   section table, the caller is responsible for removing them.
364
 
365
   This function doesn't mess with objfiles at all.  If there is an
366
   objfile associated with SO that needs to be removed, the caller is
367
   responsible for taking care of that.  */
368
 
369
void
370
free_so (struct so_list *so)
371
{
372
  struct target_so_ops *ops = solib_ops (current_gdbarch);
373
  char *bfd_filename = 0;
374
 
375
  if (so->sections)
376
    xfree (so->sections);
377
 
378
  if (so->abfd)
379
    {
380
      bfd_filename = bfd_get_filename (so->abfd);
381
      if (! bfd_close (so->abfd))
382
        warning (_("cannot close \"%s\": %s"),
383
                 bfd_filename, bfd_errmsg (bfd_get_error ()));
384
    }
385
 
386
  if (bfd_filename)
387
    xfree (bfd_filename);
388
 
389
  ops->free_so (so);
390
 
391
  xfree (so);
392
}
393
 
394
 
395
/* Return address of first so_list entry in master shared object list.  */
396
struct so_list *
397
master_so_list (void)
398
{
399
  return so_list_head;
400
}
401
 
402
 
403
/* A small stub to get us past the arg-passing pinhole of catch_errors.  */
404
 
405
static int
406
symbol_add_stub (void *arg)
407
{
408
  struct so_list *so = (struct so_list *) arg;  /* catch_errs bogon */
409
  struct section_addr_info *sap;
410
 
411
  /* Have we already loaded this shared object?  */
412
  ALL_OBJFILES (so->objfile)
413
    {
414
      if (strcmp (so->objfile->name, so->so_name) == 0)
415
        return 1;
416
    }
417
 
418
  sap = build_section_addr_info_from_section_table (so->sections,
419
                                                    so->sections_end);
420
 
421
  so->objfile = symbol_file_add (so->so_name, so->from_tty,
422
                                 sap, 0, OBJF_SHARED);
423
  free_section_addr_info (sap);
424
 
425
  return (1);
426
}
427
 
428
/* Read in symbols for shared object SO.  If FROM_TTY is non-zero, be
429
   chatty about it.  Return non-zero if any symbols were actually
430
   loaded.  */
431
 
432
int
433
solib_read_symbols (struct so_list *so, int from_tty)
434
{
435
  if (so->symbols_loaded)
436
    {
437
      if (from_tty)
438
        printf_unfiltered (_("Symbols already loaded for %s\n"), so->so_name);
439
    }
440
  else if (so->abfd == NULL)
441
    {
442
      if (from_tty)
443
        printf_unfiltered (_("Symbol file not found for %s\n"), so->so_name);
444
    }
445
  else
446
    {
447
      if (catch_errors (symbol_add_stub, so,
448
                        "Error while reading shared library symbols:\n",
449
                        RETURN_MASK_ALL))
450
        {
451
          if (from_tty)
452
            printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name);
453
          so->symbols_loaded = 1;
454
          return 1;
455
        }
456
    }
457
 
458
  return 0;
459
}
460
 
461
/* LOCAL FUNCTION
462
 
463
   update_solib_list --- synchronize GDB's shared object list with inferior's
464
 
465
   SYNOPSIS
466
 
467
   void update_solib_list (int from_tty, struct target_ops *TARGET)
468
 
469
   Extract the list of currently loaded shared objects from the
470
   inferior, and compare it with the list of shared objects currently
471
   in GDB's so_list_head list.  Edit so_list_head to bring it in sync
472
   with the inferior's new list.
473
 
474
   If we notice that the inferior has unloaded some shared objects,
475
   free any symbolic info GDB had read about those shared objects.
476
 
477
   Don't load symbolic info for any new shared objects; just add them
478
   to the list, and leave their symbols_loaded flag clear.
479
 
480
   If FROM_TTY is non-null, feel free to print messages about what
481
   we're doing.
482
 
483
   If TARGET is non-null, add the sections of all new shared objects
484
   to TARGET's section table.  Note that this doesn't remove any
485
   sections for shared objects that have been unloaded, and it
486
   doesn't check to see if the new shared objects are already present in
487
   the section table.  But we only use this for core files and
488
   processes we've just attached to, so that's okay.  */
489
 
490
static void
491
update_solib_list (int from_tty, struct target_ops *target)
492
{
493
  struct target_so_ops *ops = solib_ops (current_gdbarch);
494
  struct so_list *inferior = ops->current_sos();
495
  struct so_list *gdb, **gdb_link;
496
 
497
  /* If we are attaching to a running process for which we
498
     have not opened a symbol file, we may be able to get its
499
     symbols now!  */
500
  if (attach_flag &&
501
      symfile_objfile == NULL)
502
    catch_errors (ops->open_symbol_file_object, &from_tty,
503
                  "Error reading attached process's symbol file.\n",
504
                  RETURN_MASK_ALL);
505
 
506
  /* GDB and the inferior's dynamic linker each maintain their own
507
     list of currently loaded shared objects; we want to bring the
508
     former in sync with the latter.  Scan both lists, seeing which
509
     shared objects appear where.  There are three cases:
510
 
511
     - A shared object appears on both lists.  This means that GDB
512
     knows about it already, and it's still loaded in the inferior.
513
     Nothing needs to happen.
514
 
515
     - A shared object appears only on GDB's list.  This means that
516
     the inferior has unloaded it.  We should remove the shared
517
     object from GDB's tables.
518
 
519
     - A shared object appears only on the inferior's list.  This
520
     means that it's just been loaded.  We should add it to GDB's
521
     tables.
522
 
523
     So we walk GDB's list, checking each entry to see if it appears
524
     in the inferior's list too.  If it does, no action is needed, and
525
     we remove it from the inferior's list.  If it doesn't, the
526
     inferior has unloaded it, and we remove it from GDB's list.  By
527
     the time we're done walking GDB's list, the inferior's list
528
     contains only the new shared objects, which we then add.  */
529
 
530
  gdb = so_list_head;
531
  gdb_link = &so_list_head;
532
  while (gdb)
533
    {
534
      struct so_list *i = inferior;
535
      struct so_list **i_link = &inferior;
536
 
537
      /* Check to see whether the shared object *gdb also appears in
538
         the inferior's current list.  */
539
      while (i)
540
        {
541
          if (ops->same)
542
            {
543
              if (ops->same (gdb, i))
544
                break;
545
            }
546
          else
547
            {
548
              if (! strcmp (gdb->so_original_name, i->so_original_name))
549
                break;
550
            }
551
 
552
          i_link = &i->next;
553
          i = *i_link;
554
        }
555
 
556
      /* If the shared object appears on the inferior's list too, then
557
         it's still loaded, so we don't need to do anything.  Delete
558
         it from the inferior's list, and leave it on GDB's list.  */
559
      if (i)
560
        {
561
          *i_link = i->next;
562
          free_so (i);
563
          gdb_link = &gdb->next;
564
          gdb = *gdb_link;
565
        }
566
 
567
      /* If it's not on the inferior's list, remove it from GDB's tables.  */
568
      else
569
        {
570
          /* Notify any observer that the shared object has been
571
             unloaded before we remove it from GDB's tables.  */
572
          observer_notify_solib_unloaded (gdb);
573
 
574
          *gdb_link = gdb->next;
575
 
576
          /* Unless the user loaded it explicitly, free SO's objfile.  */
577
          if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED))
578
            free_objfile (gdb->objfile);
579
 
580
          /* Some targets' section tables might be referring to
581
             sections from so->abfd; remove them.  */
582
          remove_target_sections (gdb->abfd);
583
 
584
          free_so (gdb);
585
          gdb = *gdb_link;
586
        }
587
    }
588
 
589
  /* Now the inferior's list contains only shared objects that don't
590
     appear in GDB's list --- those that are newly loaded.  Add them
591
     to GDB's shared object list.  */
592
  if (inferior)
593
    {
594
      struct so_list *i;
595
 
596
      /* Add the new shared objects to GDB's list.  */
597
      *gdb_link = inferior;
598
 
599
      /* Fill in the rest of each of the `struct so_list' nodes.  */
600
      for (i = inferior; i; i = i->next)
601
        {
602
          i->from_tty = from_tty;
603
 
604
          /* Fill in the rest of the `struct so_list' node.  */
605
          catch_errors (solib_map_sections, i,
606
                        "Error while mapping shared library sections:\n",
607
                        RETURN_MASK_ALL);
608
 
609
          /* If requested, add the shared object's sections to the TARGET's
610
             section table.  Do this immediately after mapping the object so
611
             that later nodes in the list can query this object, as is needed
612
             in solib-osf.c.  */
613
          if (target)
614
            {
615
              int count = (i->sections_end - i->sections);
616
              if (count > 0)
617
                {
618
                  int space = target_resize_to_sections (target, count);
619
                  memcpy (target->to_sections + space,
620
                          i->sections,
621
                          count * sizeof (i->sections[0]));
622
                }
623
            }
624
 
625
          /* Notify any observer that the shared object has been
626
             loaded now that we've added it to GDB's tables.  */
627
          observer_notify_solib_loaded (i);
628
        }
629
    }
630
}
631
 
632
/* Return non-zero if SO is the libpthread shared library.
633
 
634
   Uses a fairly simplistic heuristic approach where we check
635
   the file name against "/libpthread".  This can lead to false
636
   positives, but this should be good enough in practice.  */
637
 
638
static int
639
libpthread_solib_p (struct so_list *so)
640
{
641
  return (strstr (so->so_name, "/libpthread") != NULL);
642
}
643
 
644
/* GLOBAL FUNCTION
645
 
646
   solib_add -- read in symbol info for newly added shared libraries
647
 
648
   SYNOPSIS
649
 
650
   void solib_add (char *pattern, int from_tty, struct target_ops
651
   *TARGET, int readsyms)
652
 
653
   DESCRIPTION
654
 
655
   Read in symbolic information for any shared objects whose names
656
   match PATTERN.  (If we've already read a shared object's symbol
657
   info, leave it alone.)  If PATTERN is zero, read them all.
658
 
659
   If READSYMS is 0, defer reading symbolic information until later
660
   but still do any needed low level processing.
661
 
662
   FROM_TTY and TARGET are as described for update_solib_list, above.  */
663
 
664
void
665
solib_add (char *pattern, int from_tty, struct target_ops *target, int readsyms)
666
{
667
  struct so_list *gdb;
668
 
669
  if (pattern)
670
    {
671
      char *re_err = re_comp (pattern);
672
 
673
      if (re_err)
674
        error (_("Invalid regexp: %s"), re_err);
675
    }
676
 
677
  update_solib_list (from_tty, target);
678
 
679
  /* Walk the list of currently loaded shared libraries, and read
680
     symbols for any that match the pattern --- or any whose symbols
681
     aren't already loaded, if no pattern was given.  */
682
  {
683
    int any_matches = 0;
684
    int loaded_any_symbols = 0;
685
 
686
    for (gdb = so_list_head; gdb; gdb = gdb->next)
687
      if (! pattern || re_exec (gdb->so_name))
688
        {
689
          /* Normally, we would read the symbols from that library
690
             only if READSYMS is set.  However, we're making a small
691
             exception for the pthread library, because we sometimes
692
             need the library symbols to be loaded in order to provide
693
             thread support (x86-linux for instance).  */
694
          const int add_this_solib =
695
            (readsyms || libpthread_solib_p (gdb));
696
 
697
          any_matches = 1;
698
          if (add_this_solib && solib_read_symbols (gdb, from_tty))
699
            loaded_any_symbols = 1;
700
        }
701
 
702
    if (from_tty && pattern && ! any_matches)
703
      printf_unfiltered
704
        ("No loaded shared libraries match the pattern `%s'.\n", pattern);
705
 
706
    if (loaded_any_symbols)
707
      {
708
        struct target_so_ops *ops = solib_ops (current_gdbarch);
709
 
710
        /* Getting new symbols may change our opinion about what is
711
           frameless.  */
712
        reinit_frame_cache ();
713
 
714
        ops->special_symbol_handling ();
715
      }
716
  }
717
}
718
 
719
 
720
/*
721
 
722
   LOCAL FUNCTION
723
 
724
   info_sharedlibrary_command -- code for "info sharedlibrary"
725
 
726
   SYNOPSIS
727
 
728
   static void info_sharedlibrary_command ()
729
 
730
   DESCRIPTION
731
 
732
   Walk through the shared library list and print information
733
   about each attached library.
734
 */
735
 
736
static void
737
info_sharedlibrary_command (char *ignore, int from_tty)
738
{
739
  struct so_list *so = NULL;    /* link map state variable */
740
  int header_done = 0;
741
  int addr_width;
742
 
743
  /* "0x", a little whitespace, and two hex digits per byte of pointers.  */
744
  addr_width = 4 + (gdbarch_ptr_bit (current_gdbarch) / 4);
745
 
746
  update_solib_list (from_tty, 0);
747
 
748
  for (so = so_list_head; so; so = so->next)
749
    {
750
      if (so->so_name[0])
751
        {
752
          if (!header_done)
753
            {
754
              printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width, "From",
755
                                 addr_width, "To", "Syms Read",
756
                                 "Shared Object Library");
757
              header_done++;
758
            }
759
 
760
          printf_unfiltered ("%-*s", addr_width,
761
                             so->addr_high != 0
762
                               ? hex_string_custom (
763
                                   (LONGEST) so->addr_low,
764
                                   addr_width - 4)
765
                               : "");
766
          printf_unfiltered ("%-*s", addr_width,
767
                             so->addr_high != 0
768
                               ? hex_string_custom (
769
                                   (LONGEST) so->addr_high,
770
                                   addr_width - 4)
771
                               : "");
772
          printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
773
          printf_unfiltered ("%s\n", so->so_name);
774
        }
775
    }
776
  if (so_list_head == NULL)
777
    {
778
      printf_unfiltered (_("No shared libraries loaded at this time.\n"));
779
    }
780
}
781
 
782
/*
783
 
784
   GLOBAL FUNCTION
785
 
786
   solib_address -- check to see if an address is in a shared lib
787
 
788
   SYNOPSIS
789
 
790
   char * solib_address (CORE_ADDR address)
791
 
792
   DESCRIPTION
793
 
794
   Provides a hook for other gdb routines to discover whether or
795
   not a particular address is within the mapped address space of
796
   a shared library.
797
 
798
   For example, this routine is called at one point to disable
799
   breakpoints which are in shared libraries that are not currently
800
   mapped in.
801
 */
802
 
803
char *
804
solib_address (CORE_ADDR address)
805
{
806
  struct so_list *so = 0;        /* link map state variable */
807
 
808
  for (so = so_list_head; so; so = so->next)
809
    {
810
      struct section_table *p;
811
 
812
      for (p = so->sections; p < so->sections_end; p++)
813
        {
814
          if (p->addr <= address && address < p->endaddr)
815
            return (so->so_name);
816
        }
817
    }
818
 
819
  return (0);
820
}
821
 
822
/* Called by free_all_symtabs */
823
 
824
void
825
clear_solib (void)
826
{
827
  struct target_so_ops *ops = solib_ops (current_gdbarch);
828
 
829
  /* This function is expected to handle ELF shared libraries.  It is
830
     also used on Solaris, which can run either ELF or a.out binaries
831
     (for compatibility with SunOS 4), both of which can use shared
832
     libraries.  So we don't know whether we have an ELF executable or
833
     an a.out executable until the user chooses an executable file.
834
 
835
     ELF shared libraries don't get mapped into the address space
836
     until after the program starts, so we'd better not try to insert
837
     breakpoints in them immediately.  We have to wait until the
838
     dynamic linker has loaded them; we'll hit a bp_shlib_event
839
     breakpoint (look for calls to create_solib_event_breakpoint) when
840
     it's ready.
841
 
842
     SunOS shared libraries seem to be different --- they're present
843
     as soon as the process begins execution, so there's no need to
844
     put off inserting breakpoints.  There's also nowhere to put a
845
     bp_shlib_event breakpoint, so if we put it off, we'll never get
846
     around to it.
847
 
848
     So: disable breakpoints only if we're using ELF shared libs.  */
849
  if (exec_bfd != NULL
850
      && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
851
    disable_breakpoints_in_shlibs ();
852
 
853
  while (so_list_head)
854
    {
855
      struct so_list *so = so_list_head;
856
      so_list_head = so->next;
857
      if (so->abfd)
858
        remove_target_sections (so->abfd);
859
      free_so (so);
860
    }
861
 
862
  ops->clear_solib ();
863
}
864
 
865
/* GLOBAL FUNCTION
866
 
867
   solib_create_inferior_hook -- shared library startup support
868
 
869
   SYNOPSIS
870
 
871
   void solib_create_inferior_hook ()
872
 
873
   DESCRIPTION
874
 
875
   When gdb starts up the inferior, it nurses it along (through the
876
   shell) until it is ready to execute it's first instruction.  At this
877
   point, this function gets called via expansion of the macro
878
   SOLIB_CREATE_INFERIOR_HOOK.  */
879
 
880
void
881
solib_create_inferior_hook (void)
882
{
883
  struct target_so_ops *ops = solib_ops (current_gdbarch);
884
  ops->solib_create_inferior_hook();
885
}
886
 
887
/* GLOBAL FUNCTION
888
 
889
   in_solib_dynsym_resolve_code -- check to see if an address is in
890
                                   dynamic loader's dynamic symbol
891
                                   resolution code
892
 
893
   SYNOPSIS
894
 
895
   int in_solib_dynsym_resolve_code (CORE_ADDR pc)
896
 
897
   DESCRIPTION
898
 
899
   Determine if PC is in the dynamic linker's symbol resolution
900
   code.  Return 1 if so, 0 otherwise.
901
*/
902
 
903
int
904
in_solib_dynsym_resolve_code (CORE_ADDR pc)
905
{
906
  struct target_so_ops *ops = solib_ops (current_gdbarch);
907
  return ops->in_dynsym_resolve_code (pc);
908
}
909
 
910
/*
911
 
912
   LOCAL FUNCTION
913
 
914
   sharedlibrary_command -- handle command to explicitly add library
915
 
916
   SYNOPSIS
917
 
918
   static void sharedlibrary_command (char *args, int from_tty)
919
 
920
   DESCRIPTION
921
 
922
 */
923
 
924
static void
925
sharedlibrary_command (char *args, int from_tty)
926
{
927
  dont_repeat ();
928
  solib_add (args, from_tty, (struct target_ops *) 0, 1);
929
}
930
 
931
/* LOCAL FUNCTION
932
 
933
   no_shared_libraries -- handle command to explicitly discard symbols
934
   from shared libraries.
935
 
936
   DESCRIPTION
937
 
938
   Implements the command "nosharedlibrary", which discards symbols
939
   that have been auto-loaded from shared libraries.  Symbols from
940
   shared libraries that were added by explicit request of the user
941
   are not discarded.  Also called from remote.c.  */
942
 
943
void
944
no_shared_libraries (char *ignored, int from_tty)
945
{
946
  objfile_purge_solibs ();
947
  clear_solib ();
948
}
949
 
950
static void
951
reload_shared_libraries (char *ignored, int from_tty,
952
                         struct cmd_list_element *e)
953
{
954
  no_shared_libraries (NULL, from_tty);
955
  solib_add (NULL, from_tty, NULL, auto_solib_add);
956
}
957
 
958
static void
959
show_auto_solib_add (struct ui_file *file, int from_tty,
960
                     struct cmd_list_element *c, const char *value)
961
{
962
  fprintf_filtered (file, _("Autoloading of shared library symbols is %s.\n"),
963
                    value);
964
}
965
 
966
 
967
/* Handler for library-specific lookup of global symbol NAME in OBJFILE.  Call
968
   the library-specific handler if it is installed for the current target.  */
969
 
970
struct symbol *
971
solib_global_lookup (const struct objfile *objfile,
972
                     const char *name,
973
                     const char *linkage_name,
974
                     const domain_enum domain,
975
                     struct symtab **symtab)
976
{
977
  struct target_so_ops *ops = solib_ops (current_gdbarch);
978
 
979
  if (ops->lookup_lib_global_symbol != NULL)
980
    return ops->lookup_lib_global_symbol (objfile, name, linkage_name,
981
                                          domain, symtab);
982
  return NULL;
983
}
984
 
985
 
986
extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
987
 
988
void
989
_initialize_solib (void)
990
{
991
  struct cmd_list_element *c;
992
 
993
  solib_data = gdbarch_data_register_pre_init (solib_init);
994
 
995
  add_com ("sharedlibrary", class_files, sharedlibrary_command,
996
           _("Load shared object library symbols for files matching REGEXP."));
997
  add_info ("sharedlibrary", info_sharedlibrary_command,
998
            _("Status of loaded shared object libraries."));
999
  add_com ("nosharedlibrary", class_files, no_shared_libraries,
1000
           _("Unload all shared object library symbols."));
1001
 
1002
  add_setshow_boolean_cmd ("auto-solib-add", class_support,
1003
                           &auto_solib_add, _("\
1004
Set autoloading of shared library symbols."), _("\
1005
Show autoloading of shared library symbols."), _("\
1006
If \"on\", symbols from all shared object libraries will be loaded\n\
1007
automatically when the inferior begins execution, when the dynamic linker\n\
1008
informs gdb that a new library has been loaded, or when attaching to the\n\
1009
inferior.  Otherwise, symbols must be loaded manually, using `sharedlibrary'."),
1010
                           NULL,
1011
                           show_auto_solib_add,
1012
                           &setlist, &showlist);
1013
 
1014
  add_setshow_filename_cmd ("sysroot", class_support,
1015
                            &gdb_sysroot, _("\
1016
Set an alternate system root."), _("\
1017
Show the current system root."), _("\
1018
The system root is used to load absolute shared library symbol files.\n\
1019
For other (relative) files, you can add directories using\n\
1020
`set solib-search-path'."),
1021
                            reload_shared_libraries,
1022
                            NULL,
1023
                            &setlist, &showlist);
1024
 
1025
  add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
1026
                 &setlist);
1027
  add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
1028
                 &showlist);
1029
 
1030
  add_setshow_optional_filename_cmd ("solib-search-path", class_support,
1031
                                     &solib_search_path, _("\
1032
Set the search path for loading non-absolute shared library symbol files."), _("\
1033
Show the search path for loading non-absolute shared library symbol files."), _("\
1034
This takes precedence over the environment variables PATH and LD_LIBRARY_PATH."),
1035
                                     reload_shared_libraries,
1036
                                     show_solib_search_path,
1037
                                     &setlist, &showlist);
1038
}

powered by: WebSVN 2.1.0

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