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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [solib.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman
/* Handle shared libraries for GDB, the GNU Debugger.
2
 
3
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4
   1999, 2000, 2001, 2002 Free Software Foundation, Inc.
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 2 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, write to the Free Software
20
   Foundation, Inc., 59 Temple Place - Suite 330,
21
   Boston, MA 02111-1307, USA.  */
22
 
23
#include "defs.h"
24
 
25
#include <sys/types.h>
26
#include <fcntl.h>
27
#include "gdb_string.h"
28
#include "symtab.h"
29
#include "bfd.h"
30
#include "symfile.h"
31
#include "objfiles.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
 
44
#include "solist.h"
45
 
46
/* external data declarations */
47
 
48
/* FIXME: gdbarch needs to control this variable */
49
struct target_so_ops *current_target_so_ops;
50
 
51
/* local data declarations */
52
 
53
static struct so_list *so_list_head;    /* List of known shared objects */
54
 
55
static int solib_cleanup_queued = 0;     /* make_run_cleanup called */
56
 
57
/* Local function prototypes */
58
 
59
static void do_clear_solib (PTR);
60
 
61
/* If non-zero, this is a prefix that will be added to the front of the name
62
   shared libraries with an absolute filename for loading.  */
63
static char *solib_absolute_prefix = NULL;
64
 
65
/* If non-empty, this is a search path for loading non-absolute shared library
66
   symbol files.  This takes precedence over the environment variables PATH
67
   and LD_LIBRARY_PATH.  */
68
static char *solib_search_path = NULL;
69
 
70
/*
71
 
72
   GLOBAL FUNCTION
73
 
74
   solib_open -- Find a shared library file and open it.
75
 
76
   SYNOPSIS
77
 
78
   int solib_open (char *in_patname, char **found_pathname);
79
 
80
   DESCRIPTION
81
 
82
   Global variable SOLIB_ABSOLUTE_PREFIX is used as a prefix directory
83
   to search for shared libraries if they have an absolute path.
84
 
85
   Global variable SOLIB_SEARCH_PATH is used as a prefix directory
86
   (or set of directories, as in LD_LIBRARY_PATH) to search for all
87
   shared libraries if not found in SOLIB_ABSOLUTE_PREFIX.
88
 
89
   Search order:
90
   * If path is absolute, look in SOLIB_ABSOLUTE_PREFIX.
91
   * If path is absolute or relative, look for it literally (unmodified).
92
   * Look in SOLIB_SEARCH_PATH.
93
   * Look in inferior's $PATH.
94
   * Look in inferior's $LD_LIBRARY_PATH.
95
 
96
   RETURNS
97
 
98
   file handle for opened solib, or -1 for failure.  */
99
 
100
int
101
solib_open (char *in_pathname, char **found_pathname)
102
{
103
  int found_file = -1;
104
  char *temp_pathname = NULL;
105
  char *p = in_pathname;
106
 
107
  while (*p && !IS_DIR_SEPARATOR (*p))
108
    p++;
109
 
110
  if (*p)
111
    {
112
      if (! IS_ABSOLUTE_PATH (in_pathname) || solib_absolute_prefix == NULL)
113
        temp_pathname = in_pathname;
114
      else
115
        {
116
          int prefix_len = strlen (solib_absolute_prefix);
117
 
118
          /* Remove trailing slashes from absolute prefix.  */
119
          while (prefix_len > 0
120
                 && IS_DIR_SEPARATOR (solib_absolute_prefix[prefix_len - 1]))
121
            prefix_len--;
122
 
123
          /* Cat the prefixed pathname together.  */
124
          temp_pathname = alloca (prefix_len + strlen (in_pathname) + 1);
125
          strncpy (temp_pathname, solib_absolute_prefix, prefix_len);
126
          temp_pathname[prefix_len] = '\0';
127
          strcat (temp_pathname, in_pathname);
128
        }
129
 
130
      /* Now see if we can open it.  */
131
      found_file = open (temp_pathname, O_RDONLY, 0);
132
    }
133
 
134
  /* If the search in solib_absolute_prefix failed, and the path name is
135
     absolute at this point, make it relative.  (openp will try and open the
136
     file according to its absolute path otherwise, which is not what we want.)
137
     Affects subsequent searches for this solib.  */
138
  if (found_file < 0 && IS_ABSOLUTE_PATH (in_pathname))
139
    {
140
      /* First, get rid of any drive letters etc.  */
141
      while (!IS_DIR_SEPARATOR (*in_pathname))
142
        in_pathname++;
143
 
144
      /* Next, get rid of all leading dir separators.  */
145
      while (IS_DIR_SEPARATOR (*in_pathname))
146
        in_pathname++;
147
    }
148
 
149
  /* If not found, next search the solib_search_path (if any).  */
150
  if (found_file < 0 && solib_search_path != NULL)
151
    found_file = openp (solib_search_path,
152
                        1, in_pathname, O_RDONLY, 0, &temp_pathname);
153
 
154
  /* If not found, next search the solib_search_path (if any) for the basename
155
     only (ignoring the path).  This is to allow reading solibs from a path
156
     that differs from the opened path.  */
157
  if (found_file < 0 && solib_search_path != NULL)
158
    found_file = openp (solib_search_path,
159
                        1, lbasename (in_pathname), O_RDONLY, 0,
160
                        &temp_pathname);
161
 
162
  /* If not found, next search the inferior's $PATH environment variable. */
163
  if (found_file < 0 && solib_search_path != NULL)
164
    found_file = openp (get_in_environ (inferior_environ, "PATH"),
165
                        1, in_pathname, O_RDONLY, 0, &temp_pathname);
166
 
167
  /* If not found, next search the inferior's $LD_LIBRARY_PATH
168
     environment variable. */
169
  if (found_file < 0 && solib_search_path != NULL)
170
    found_file = openp (get_in_environ (inferior_environ, "LD_LIBRARY_PATH"),
171
                        1, in_pathname, O_RDONLY, 0, &temp_pathname);
172
 
173
  /* Done.  If not found, tough luck.  Return found_file and
174
     (optionally) found_pathname.  */
175
  if (found_pathname != NULL && temp_pathname != NULL)
176
    *found_pathname = xstrdup (temp_pathname);
177
  return found_file;
178
}
179
 
180
 
181
/*
182
 
183
   LOCAL FUNCTION
184
 
185
   solib_map_sections -- open bfd and build sections for shared lib
186
 
187
   SYNOPSIS
188
 
189
   static int solib_map_sections (struct so_list *so)
190
 
191
   DESCRIPTION
192
 
193
   Given a pointer to one of the shared objects in our list
194
   of mapped objects, use the recorded name to open a bfd
195
   descriptor for the object, build a section table, and then
196
   relocate all the section addresses by the base address at
197
   which the shared object was mapped.
198
 
199
   FIXMES
200
 
201
   In most (all?) cases the shared object file name recorded in the
202
   dynamic linkage tables will be a fully qualified pathname.  For
203
   cases where it isn't, do we really mimic the systems search
204
   mechanism correctly in the below code (particularly the tilde
205
   expansion stuff?).
206
 */
207
 
208
static int
209
solib_map_sections (PTR arg)
210
{
211
  struct so_list *so = (struct so_list *) arg;  /* catch_errors bogon */
212
  char *filename;
213
  char *scratch_pathname;
214
  int scratch_chan;
215
  struct section_table *p;
216
  struct cleanup *old_chain;
217
  bfd *abfd;
218
 
219
  filename = tilde_expand (so->so_name);
220
 
221
  old_chain = make_cleanup (xfree, filename);
222
  scratch_chan = solib_open (filename, &scratch_pathname);
223
 
224
  if (scratch_chan < 0)
225
    {
226
      perror_with_name (filename);
227
    }
228
 
229
  /* Leave scratch_pathname allocated.  abfd->name will point to it.  */
230
  abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
231
  if (!abfd)
232
    {
233
      close (scratch_chan);
234
      error ("Could not open `%s' as an executable file: %s",
235
             scratch_pathname, bfd_errmsg (bfd_get_error ()));
236
    }
237
 
238
  /* Leave bfd open, core_xfer_memory and "info files" need it.  */
239
  so->abfd = abfd;
240
  abfd->cacheable = 1;
241
 
242
  /* copy full path name into so_name, so that later symbol_file_add
243
     can find it */
244
  if (strlen (scratch_pathname) >= SO_NAME_MAX_PATH_SIZE)
245
    error ("Full path name length of shared library exceeds SO_NAME_MAX_PATH_SIZE in so_list structure.");
246
  strcpy (so->so_name, scratch_pathname);
247
 
248
  if (!bfd_check_format (abfd, bfd_object))
249
    {
250
      error ("\"%s\": not in executable format: %s.",
251
             scratch_pathname, bfd_errmsg (bfd_get_error ()));
252
    }
253
  if (build_section_table (abfd, &so->sections, &so->sections_end))
254
    {
255
      error ("Can't find the file sections in `%s': %s",
256
             bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
257
    }
258
 
259
  for (p = so->sections; p < so->sections_end; p++)
260
    {
261
      /* Relocate the section binding addresses as recorded in the shared
262
         object's file by the base address to which the object was actually
263
         mapped. */
264
      TARGET_SO_RELOCATE_SECTION_ADDRESSES (so, p);
265
      if (STREQ (p->the_bfd_section->name, ".text"))
266
        {
267
          so->textsection = p;
268
        }
269
    }
270
 
271
  /* Free the file names, close the file now.  */
272
  do_cleanups (old_chain);
273
 
274
  return (1);
275
}
276
 
277
/* LOCAL FUNCTION
278
 
279
   free_so --- free a `struct so_list' object
280
 
281
   SYNOPSIS
282
 
283
   void free_so (struct so_list *so)
284
 
285
   DESCRIPTION
286
 
287
   Free the storage associated with the `struct so_list' object SO.
288
   If we have opened a BFD for SO, close it.
289
 
290
   The caller is responsible for removing SO from whatever list it is
291
   a member of.  If we have placed SO's sections in some target's
292
   section table, the caller is responsible for removing them.
293
 
294
   This function doesn't mess with objfiles at all.  If there is an
295
   objfile associated with SO that needs to be removed, the caller is
296
   responsible for taking care of that.  */
297
 
298
void
299
free_so (struct so_list *so)
300
{
301
  char *bfd_filename = 0;
302
 
303
  if (so->sections)
304
    xfree (so->sections);
305
 
306
  if (so->abfd)
307
    {
308
      bfd_filename = bfd_get_filename (so->abfd);
309
      if (! bfd_close (so->abfd))
310
        warning ("cannot close \"%s\": %s",
311
                 bfd_filename, bfd_errmsg (bfd_get_error ()));
312
    }
313
 
314
  if (bfd_filename)
315
    xfree (bfd_filename);
316
 
317
  TARGET_SO_FREE_SO (so);
318
 
319
  xfree (so);
320
}
321
 
322
 
323
/* A small stub to get us past the arg-passing pinhole of catch_errors.  */
324
 
325
static int
326
symbol_add_stub (PTR arg)
327
{
328
  register struct so_list *so = (struct so_list *) arg;  /* catch_errs bogon */
329
  struct section_addr_info *sap;
330
 
331
  /* Have we already loaded this shared object?  */
332
  ALL_OBJFILES (so->objfile)
333
    {
334
      if (strcmp (so->objfile->name, so->so_name) == 0)
335
        return 1;
336
    }
337
 
338
  sap = build_section_addr_info_from_section_table (so->sections,
339
                                                    so->sections_end);
340
 
341
  so->objfile = symbol_file_add (so->so_name, so->from_tty,
342
                                 sap, 0, OBJF_SHARED);
343
  free_section_addr_info (sap);
344
 
345
  return (1);
346
}
347
 
348
 
349
/* LOCAL FUNCTION
350
 
351
   update_solib_list --- synchronize GDB's shared object list with inferior's
352
 
353
   SYNOPSIS
354
 
355
   void update_solib_list (int from_tty, struct target_ops *TARGET)
356
 
357
   Extract the list of currently loaded shared objects from the
358
   inferior, and compare it with the list of shared objects currently
359
   in GDB's so_list_head list.  Edit so_list_head to bring it in sync
360
   with the inferior's new list.
361
 
362
   If we notice that the inferior has unloaded some shared objects,
363
   free any symbolic info GDB had read about those shared objects.
364
 
365
   Don't load symbolic info for any new shared objects; just add them
366
   to the list, and leave their symbols_loaded flag clear.
367
 
368
   If FROM_TTY is non-null, feel free to print messages about what
369
   we're doing.
370
 
371
   If TARGET is non-null, add the sections of all new shared objects
372
   to TARGET's section table.  Note that this doesn't remove any
373
   sections for shared objects that have been unloaded, and it
374
   doesn't check to see if the new shared objects are already present in
375
   the section table.  But we only use this for core files and
376
   processes we've just attached to, so that's okay.  */
377
 
378
void
379
update_solib_list (int from_tty, struct target_ops *target)
380
{
381
  struct so_list *inferior = TARGET_SO_CURRENT_SOS ();
382
  struct so_list *gdb, **gdb_link;
383
 
384
  /* If we are attaching to a running process for which we
385
     have not opened a symbol file, we may be able to get its
386
     symbols now!  */
387
  if (attach_flag &&
388
      symfile_objfile == NULL)
389
    catch_errors (TARGET_SO_OPEN_SYMBOL_FILE_OBJECT, (PTR) &from_tty,
390
                  "Error reading attached process's symbol file.\n",
391
                  RETURN_MASK_ALL);
392
 
393
  /* Since this function might actually add some elements to the
394
     so_list_head list, arrange for it to be cleaned up when
395
     appropriate.  */
396
  if (!solib_cleanup_queued)
397
    {
398
      make_run_cleanup (do_clear_solib, NULL);
399
      solib_cleanup_queued = 1;
400
    }
401
 
402
  /* GDB and the inferior's dynamic linker each maintain their own
403
     list of currently loaded shared objects; we want to bring the
404
     former in sync with the latter.  Scan both lists, seeing which
405
     shared objects appear where.  There are three cases:
406
 
407
     - A shared object appears on both lists.  This means that GDB
408
     knows about it already, and it's still loaded in the inferior.
409
     Nothing needs to happen.
410
 
411
     - A shared object appears only on GDB's list.  This means that
412
     the inferior has unloaded it.  We should remove the shared
413
     object from GDB's tables.
414
 
415
     - A shared object appears only on the inferior's list.  This
416
     means that it's just been loaded.  We should add it to GDB's
417
     tables.
418
 
419
     So we walk GDB's list, checking each entry to see if it appears
420
     in the inferior's list too.  If it does, no action is needed, and
421
     we remove it from the inferior's list.  If it doesn't, the
422
     inferior has unloaded it, and we remove it from GDB's list.  By
423
     the time we're done walking GDB's list, the inferior's list
424
     contains only the new shared objects, which we then add.  */
425
 
426
  gdb = so_list_head;
427
  gdb_link = &so_list_head;
428
  while (gdb)
429
    {
430
      struct so_list *i = inferior;
431
      struct so_list **i_link = &inferior;
432
 
433
      /* Check to see whether the shared object *gdb also appears in
434
         the inferior's current list.  */
435
      while (i)
436
        {
437
          if (! strcmp (gdb->so_original_name, i->so_original_name))
438
            break;
439
 
440
          i_link = &i->next;
441
          i = *i_link;
442
        }
443
 
444
      /* If the shared object appears on the inferior's list too, then
445
         it's still loaded, so we don't need to do anything.  Delete
446
         it from the inferior's list, and leave it on GDB's list.  */
447
      if (i)
448
        {
449
          *i_link = i->next;
450
          free_so (i);
451
          gdb_link = &gdb->next;
452
          gdb = *gdb_link;
453
        }
454
 
455
      /* If it's not on the inferior's list, remove it from GDB's tables.  */
456
      else
457
        {
458
          *gdb_link = gdb->next;
459
 
460
          /* Unless the user loaded it explicitly, free SO's objfile.  */
461
          if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED))
462
            free_objfile (gdb->objfile);
463
 
464
          /* Some targets' section tables might be referring to
465
             sections from so->abfd; remove them.  */
466
          remove_target_sections (gdb->abfd);
467
 
468
          free_so (gdb);
469
          gdb = *gdb_link;
470
        }
471
    }
472
 
473
  /* Now the inferior's list contains only shared objects that don't
474
     appear in GDB's list --- those that are newly loaded.  Add them
475
     to GDB's shared object list.  */
476
  if (inferior)
477
    {
478
      struct so_list *i;
479
 
480
      /* Add the new shared objects to GDB's list.  */
481
      *gdb_link = inferior;
482
 
483
      /* Fill in the rest of each of the `struct so_list' nodes.  */
484
      for (i = inferior; i; i = i->next)
485
        {
486
          i->from_tty = from_tty;
487
 
488
          /* Fill in the rest of the `struct so_list' node.  */
489
          catch_errors (solib_map_sections, i,
490
                        "Error while mapping shared library sections:\n",
491
                        RETURN_MASK_ALL);
492
 
493
          /* If requested, add the shared object's sections to the TARGET's
494
             section table.  Do this immediately after mapping the object so
495
             that later nodes in the list can query this object, as is needed
496
             in solib-osf.c.  */
497
          if (target)
498
            {
499
              int count = (i->sections_end - i->sections);
500
              if (count > 0)
501
                {
502
                  int space = target_resize_to_sections (target, count);
503
                  memcpy (target->to_sections + space,
504
                          i->sections,
505
                          count * sizeof (i->sections[0]));
506
                }
507
            }
508
        }
509
    }
510
}
511
 
512
 
513
/* GLOBAL FUNCTION
514
 
515
   solib_add -- read in symbol info for newly added shared libraries
516
 
517
   SYNOPSIS
518
 
519
   void solib_add (char *pattern, int from_tty, struct target_ops
520
   *TARGET, int readsyms)
521
 
522
   DESCRIPTION
523
 
524
   Read in symbolic information for any shared objects whose names
525
   match PATTERN.  (If we've already read a shared object's symbol
526
   info, leave it alone.)  If PATTERN is zero, read them all.
527
 
528
   If READSYMS is 0, defer reading symbolic information until later
529
   but still do any needed low level processing.
530
 
531
   FROM_TTY and TARGET are as described for update_solib_list, above.  */
532
 
533
void
534
solib_add (char *pattern, int from_tty, struct target_ops *target, int readsyms)
535
{
536
  struct so_list *gdb;
537
 
538
  if (pattern)
539
    {
540
      char *re_err = re_comp (pattern);
541
 
542
      if (re_err)
543
        error ("Invalid regexp: %s", re_err);
544
    }
545
 
546
  update_solib_list (from_tty, target);
547
 
548
  /* Walk the list of currently loaded shared libraries, and read
549
     symbols for any that match the pattern --- or any whose symbols
550
     aren't already loaded, if no pattern was given.  */
551
  {
552
    int any_matches = 0;
553
    int loaded_any_symbols = 0;
554
 
555
    for (gdb = so_list_head; gdb; gdb = gdb->next)
556
      if (! pattern || re_exec (gdb->so_name))
557
        {
558
          any_matches = 1;
559
 
560
          if (gdb->symbols_loaded)
561
            {
562
              if (from_tty)
563
                printf_unfiltered ("Symbols already loaded for %s\n",
564
                                   gdb->so_name);
565
            }
566
          else if (readsyms)
567
            {
568
              if (catch_errors
569
                  (symbol_add_stub, gdb,
570
                   "Error while reading shared library symbols:\n",
571
                   RETURN_MASK_ALL))
572
                {
573
                  if (from_tty)
574
                    printf_unfiltered ("Loaded symbols for %s\n",
575
                                       gdb->so_name);
576
                  gdb->symbols_loaded = 1;
577
                  loaded_any_symbols = 1;
578
                }
579
            }
580
        }
581
 
582
    if (from_tty && pattern && ! any_matches)
583
      printf_unfiltered
584
        ("No loaded shared libraries match the pattern `%s'.\n", pattern);
585
 
586
    if (loaded_any_symbols)
587
      {
588
        /* Getting new symbols may change our opinion about what is
589
           frameless.  */
590
        reinit_frame_cache ();
591
 
592
        TARGET_SO_SPECIAL_SYMBOL_HANDLING ();
593
      }
594
  }
595
}
596
 
597
 
598
/*
599
 
600
   LOCAL FUNCTION
601
 
602
   info_sharedlibrary_command -- code for "info sharedlibrary"
603
 
604
   SYNOPSIS
605
 
606
   static void info_sharedlibrary_command ()
607
 
608
   DESCRIPTION
609
 
610
   Walk through the shared library list and print information
611
   about each attached library.
612
 */
613
 
614
static void
615
info_sharedlibrary_command (char *ignore, int from_tty)
616
{
617
  register struct so_list *so = NULL;   /* link map state variable */
618
  int header_done = 0;
619
  int addr_width;
620
  char *addr_fmt;
621
 
622
  if (TARGET_PTR_BIT == 32)
623
    {
624
      addr_width = 8 + 4;
625
      addr_fmt = "08l";
626
    }
627
  else if (TARGET_PTR_BIT == 64)
628
    {
629
      addr_width = 16 + 4;
630
      addr_fmt = "016l";
631
    }
632
  else
633
    {
634
      internal_error (__FILE__, __LINE__,
635
                      "TARGET_PTR_BIT returned unknown size %d",
636
                      TARGET_PTR_BIT);
637
    }
638
 
639
  update_solib_list (from_tty, 0);
640
 
641
  for (so = so_list_head; so; so = so->next)
642
    {
643
      if (so->so_name[0])
644
        {
645
          if (!header_done)
646
            {
647
              printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width, "From",
648
                                 addr_width, "To", "Syms Read",
649
                                 "Shared Object Library");
650
              header_done++;
651
            }
652
 
653
          printf_unfiltered ("%-*s", addr_width,
654
                             so->textsection != NULL
655
                               ? local_hex_string_custom (
656
                                   (LONGEST) so->textsection->addr,
657
                                   addr_fmt)
658
                               : "");
659
          printf_unfiltered ("%-*s", addr_width,
660
                             so->textsection != NULL
661
                               ? local_hex_string_custom (
662
                                   (LONGEST) so->textsection->endaddr,
663
                                   addr_fmt)
664
                               : "");
665
          printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
666
          printf_unfiltered ("%s\n", so->so_name);
667
        }
668
    }
669
  if (so_list_head == NULL)
670
    {
671
      printf_unfiltered ("No shared libraries loaded at this time.\n");
672
    }
673
}
674
 
675
/*
676
 
677
   GLOBAL FUNCTION
678
 
679
   solib_address -- check to see if an address is in a shared lib
680
 
681
   SYNOPSIS
682
 
683
   char * solib_address (CORE_ADDR address)
684
 
685
   DESCRIPTION
686
 
687
   Provides a hook for other gdb routines to discover whether or
688
   not a particular address is within the mapped address space of
689
   a shared library.
690
 
691
   For example, this routine is called at one point to disable
692
   breakpoints which are in shared libraries that are not currently
693
   mapped in.
694
 */
695
 
696
char *
697
solib_address (CORE_ADDR address)
698
{
699
  register struct so_list *so = 0;       /* link map state variable */
700
 
701
  for (so = so_list_head; so; so = so->next)
702
    {
703
      struct section_table *p;
704
 
705
      for (p = so->sections; p < so->sections_end; p++)
706
        {
707
          if (p->addr <= address && address < p->endaddr)
708
            return (so->so_name);
709
        }
710
    }
711
 
712
  return (0);
713
}
714
 
715
/* Called by free_all_symtabs */
716
 
717
void
718
clear_solib (void)
719
{
720
  /* This function is expected to handle ELF shared libraries.  It is
721
     also used on Solaris, which can run either ELF or a.out binaries
722
     (for compatibility with SunOS 4), both of which can use shared
723
     libraries.  So we don't know whether we have an ELF executable or
724
     an a.out executable until the user chooses an executable file.
725
 
726
     ELF shared libraries don't get mapped into the address space
727
     until after the program starts, so we'd better not try to insert
728
     breakpoints in them immediately.  We have to wait until the
729
     dynamic linker has loaded them; we'll hit a bp_shlib_event
730
     breakpoint (look for calls to create_solib_event_breakpoint) when
731
     it's ready.
732
 
733
     SunOS shared libraries seem to be different --- they're present
734
     as soon as the process begins execution, so there's no need to
735
     put off inserting breakpoints.  There's also nowhere to put a
736
     bp_shlib_event breakpoint, so if we put it off, we'll never get
737
     around to it.
738
 
739
     So: disable breakpoints only if we're using ELF shared libs.  */
740
  if (exec_bfd != NULL
741
      && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
742
    disable_breakpoints_in_shlibs (1);
743
 
744
  while (so_list_head)
745
    {
746
      struct so_list *so = so_list_head;
747
      so_list_head = so->next;
748
      if (so->abfd)
749
        remove_target_sections (so->abfd);
750
      free_so (so);
751
    }
752
 
753
  TARGET_SO_CLEAR_SOLIB ();
754
}
755
 
756
static void
757
do_clear_solib (PTR dummy)
758
{
759
  solib_cleanup_queued = 0;
760
  clear_solib ();
761
}
762
 
763
/* GLOBAL FUNCTION
764
 
765
   solib_create_inferior_hook -- shared library startup support
766
 
767
   SYNOPSIS
768
 
769
   void solib_create_inferior_hook()
770
 
771
   DESCRIPTION
772
 
773
   When gdb starts up the inferior, it nurses it along (through the
774
   shell) until it is ready to execute it's first instruction.  At this
775
   point, this function gets called via expansion of the macro
776
   SOLIB_CREATE_INFERIOR_HOOK.  */
777
 
778
void
779
solib_create_inferior_hook (void)
780
{
781
  TARGET_SO_SOLIB_CREATE_INFERIOR_HOOK ();
782
}
783
 
784
/* GLOBAL FUNCTION
785
 
786
   in_solib_dynsym_resolve_code -- check to see if an address is in
787
                                   dynamic loader's dynamic symbol
788
                                   resolution code
789
 
790
   SYNOPSIS
791
 
792
   int in_solib_dynsym_resolve_code (CORE_ADDR pc)
793
 
794
   DESCRIPTION
795
 
796
   Determine if PC is in the dynamic linker's symbol resolution
797
   code.  Return 1 if so, 0 otherwise.
798
*/
799
 
800
int
801
in_solib_dynsym_resolve_code (CORE_ADDR pc)
802
{
803
  return TARGET_SO_IN_DYNSYM_RESOLVE_CODE (pc);
804
}
805
 
806
/*
807
 
808
   LOCAL FUNCTION
809
 
810
   sharedlibrary_command -- handle command to explicitly add library
811
 
812
   SYNOPSIS
813
 
814
   static void sharedlibrary_command (char *args, int from_tty)
815
 
816
   DESCRIPTION
817
 
818
 */
819
 
820
static void
821
sharedlibrary_command (char *args, int from_tty)
822
{
823
  dont_repeat ();
824
  solib_add (args, from_tty, (struct target_ops *) 0, 1);
825
}
826
 
827
/* LOCAL FUNCTION
828
 
829
   no_shared_libraries -- handle command to explicitly discard symbols
830
   from shared libraries.
831
 
832
   DESCRIPTION
833
 
834
   Implements the command "nosharedlibrary", which discards symbols
835
   that have been auto-loaded from shared libraries.  Symbols from
836
   shared libraries that were added by explicit request of the user
837
   are not discarded.  Also called from remote.c.  */
838
 
839
void
840
no_shared_libraries (char *ignored, int from_tty)
841
{
842
  objfile_purge_solibs ();
843
  do_clear_solib (NULL);
844
}
845
 
846
void
847
_initialize_solib (void)
848
{
849
  struct cmd_list_element *c;
850
 
851
  add_com ("sharedlibrary", class_files, sharedlibrary_command,
852
           "Load shared object library symbols for files matching REGEXP.");
853
  add_info ("sharedlibrary", info_sharedlibrary_command,
854
            "Status of loaded shared object libraries.");
855
  add_com ("nosharedlibrary", class_files, no_shared_libraries,
856
           "Unload all shared object library symbols.");
857
 
858
  add_show_from_set
859
    (add_set_cmd ("auto-solib-add", class_support, var_boolean,
860
                  (char *) &auto_solib_add,
861
                  "Set autoloading of shared library symbols.\n\
862
If \"on\", symbols from all shared object libraries will be loaded\n\
863
automatically when the inferior begins execution, when the dynamic linker\n\
864
informs gdb that a new library has been loaded, or when attaching to the\n\
865
inferior.  Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
866
                  &setlist),
867
     &showlist);
868
 
869
  c = add_set_cmd ("solib-absolute-prefix", class_support, var_filename,
870
                   (char *) &solib_absolute_prefix,
871
                   "Set prefix for loading absolute shared library symbol files.\n\
872
For other (relative) files, you can add values using `set solib-search-path'.",
873
                   &setlist);
874
  add_show_from_set (c, &showlist);
875
  set_cmd_completer (c, filename_completer);
876
 
877
  c = add_set_cmd ("solib-search-path", class_support, var_string,
878
                   (char *) &solib_search_path,
879
                   "Set the search path for loading non-absolute shared library symbol files.\n\
880
This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
881
                   &setlist);
882
  add_show_from_set (c, &showlist);
883
  set_cmd_completer (c, filename_completer);
884
}

powered by: WebSVN 2.1.0

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