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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [solib.c] - Blame information for rev 578

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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