gdb/osfsolib.c

   1 /* Handle OSF/1 shared libraries for GDB, the GNU Debugger.
   2    Copyright 1993, 94, 95, 96, 98, 1999 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 /* FIXME: Most of this code could be merged with solib.c by using
  22    next_link_map_member and xfer_link_map_member in solib.c.  */
  23
  24 #include "defs.h"
  25
  26 #include <sys/types.h>
  27 #include <signal.h>
  28 #include "gdb_string.h"
  29 #include <fcntl.h>
  30
  31 #include "symtab.h"
  32 #include "bfd.h"
  33 #include "symfile.h"
  34 #include "objfiles.h"
  35 #include "gdbcore.h"
  36 #include "command.h"
  37 #include "target.h"
  38 #include "frame.h"
  39 #include "gdb_regex.h"
  40 #include "inferior.h"
  41 #include "language.h"
  42 #include "gdbcmd.h"
  43
  44 #define MAX_PATH_SIZE 1024      /* FIXME: Should be dynamic */
  45
  46 /* When handling shared libraries, GDB has to find out the pathnames
  47    of all shared libraries that are currently loaded (to read in their
  48    symbols) and where the shared libraries are loaded in memory
  49    (to relocate them properly from their prelinked addresses to the
  50    current load address).
  51
  52    Under OSF/1 there are two possibilities to get at this information:
  53    1) Peek around in the runtime loader structures.
  54    These are not documented, and they are not defined in the system
  55    header files. The definitions below were obtained by experimentation,
  56    but they seem stable enough.
  57    2) Use the undocumented libxproc.a library, which contains the
  58    equivalent ldr_* routines.
  59    This approach is somewhat cleaner, but it requires that the GDB
  60    executable is dynamically linked. In addition it requires a
  61    NAT_CLIBS= -lxproc -Wl,-expect_unresolved,ldr_process_context
  62    linker specification for GDB and all applications that are using
  63    libgdb.
  64    We will use the peeking approach until it becomes unwieldy.  */
  65
  66 #ifndef USE_LDR_ROUTINES
  67
  68 /* Definition of runtime loader structures, found by experimentation.  */
  69 #define RLD_CONTEXT_ADDRESS     0x3ffc0000000
  70
  71 typedef struct
  72   {
  73     CORE_ADDR next;
  74     CORE_ADDR previous;
  75     CORE_ADDR unknown1;
  76     char *module_name;
  77     CORE_ADDR modinfo_addr;
  78     long module_id;
  79     CORE_ADDR unknown2;
  80     CORE_ADDR unknown3;
  81     long region_count;
  82     CORE_ADDR regioninfo_addr;
  83   }
  84 ldr_module_info_t;
  85
  86 typedef struct
  87   {
  88     long unknown1;
  89     CORE_ADDR regionname_addr;
  90     long protection;
  91     CORE_ADDR vaddr;
  92     CORE_ADDR mapaddr;
  93     long size;
  94     long unknown2[5];
  95   }
  96 ldr_region_info_t;
  97
  98 typedef struct
  99   {
 100     CORE_ADDR unknown1;
 101     CORE_ADDR unknown2;
 102     CORE_ADDR head;
 103     CORE_ADDR tail;
 104   }
 105 ldr_context_t;
 106
 107 static ldr_context_t ldr_context;
 108
 109 #else
 110
 111 #include <loader.h>
 112 static ldr_process_t fake_ldr_process;
 113
 114 /* Called by ldr_* routines to read memory from the current target.  */
 115
 116 static int ldr_read_memory (CORE_ADDR, char *, int, int);
 117
 118 static int
 119 ldr_read_memory (CORE_ADDR memaddr, char *myaddr, int len, int readstring)
 120 {
 121   int result;
 122   char *buffer;
 123
 124   if (readstring)
 125     {
 126       target_read_string (memaddr, &buffer, len, &result);
 127       if (result == 0)
 128         strcpy (myaddr, buffer);
 129       free (buffer);
 130     }
 131   else
 132     result = target_read_memory (memaddr, myaddr, len);
 133
 134   if (result != 0)
 135     result = -result;
 136   return result;
 137 }
 138
 139 #endif
 140
 141 /* Define our own link_map structure.
 142    This will help to share code with solib.c.  */
 143
 144 struct link_map
 145 {
 146   CORE_ADDR l_offset;           /* prelink to load address offset */
 147   char *l_name;                 /* full name of loaded object */
 148   ldr_module_info_t module_info;        /* corresponding module info */
 149 };
 150
 151 #define LM_OFFSET(so) ((so) -> lm.l_offset)
 152 #define LM_NAME(so) ((so) -> lm.l_name)
 153
 154 struct so_list
 155   {
 156     struct so_list *next;       /* next structure in linked list */
 157     struct link_map lm;         /* copy of link map from inferior */
 158     struct link_map *lmaddr;    /* addr in inferior lm was read from */
 159     CORE_ADDR lmend;            /* upper addr bound of mapped object */
 160     char so_name[MAX_PATH_SIZE];        /* shared object lib name (FIXME) */
 161     char symbols_loaded;        /* flag: symbols read in yet? */
 162     char from_tty;              /* flag: print msgs? */
 163     struct objfile *objfile;    /* objfile for loaded lib */
 164     struct section_table *sections;
 165     struct section_table *sections_end;
 166     struct section_table *textsection;
 167     bfd *abfd;
 168   };
 169
 170 static struct so_list *so_list_head;    /* List of known shared objects */
 171
 172 extern int fdmatch (int, int);  /* In libiberty */
 173
 174 /* Local function prototypes */
 175
 176 static void sharedlibrary_command (char *, int);
 177
 178 static void info_sharedlibrary_command (char *, int);
 179
 180 static int symbol_add_stub (char *);
 181
 182 static struct so_list *find_solib (struct so_list *);
 183
 184 static struct link_map *first_link_map_member (void);
 185
 186 static struct link_map *next_link_map_member (struct so_list *);
 187
 188 static void xfer_link_map_member (struct so_list *, struct link_map *);
 189
 190 static int solib_map_sections (char *);
 191
 192 /*
 193
 194    LOCAL FUNCTION
 195
 196    solib_map_sections -- open bfd and build sections for shared lib
 197
 198    SYNOPSIS
 199
 200    static int solib_map_sections (struct so_list *so)
 201
 202    DESCRIPTION
 203
 204    Given a pointer to one of the shared objects in our list
 205    of mapped objects, use the recorded name to open a bfd
 206    descriptor for the object, build a section table, and then
 207    relocate all the section addresses by the base address at
 208    which the shared object was mapped.
 209
 210    FIXMES
 211
 212    In most (all?) cases the shared object file name recorded in the
 213    dynamic linkage tables will be a fully qualified pathname.  For
 214    cases where it isn't, do we really mimic the systems search
 215    mechanism correctly in the below code (particularly the tilde
 216    expansion stuff?).
 217  */
 218
 219 static int
 220 solib_map_sections (char *arg)
 221 {
 222   struct so_list *so = (struct so_list *) arg;  /* catch_errors bogon */
 223   char *filename;
 224   char *scratch_pathname;
 225   int scratch_chan;
 226   struct section_table *p;
 227   struct cleanup *old_chain;
 228   bfd *abfd;
 229
 230   filename = tilde_expand (so->so_name);
 231   old_chain = make_cleanup (free, filename);
 232
 233   scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
 234                         &scratch_pathname);
 235   if (scratch_chan < 0)
 236     {
 237       scratch_chan = openp (getenv ("LD_LIBRARY_PATH"), 1, filename,
 238                             O_RDONLY, 0, &scratch_pathname);
 239     }
 240   if (scratch_chan < 0)
 241     {
 242       perror_with_name (filename);
 243     }
 244   /* Leave scratch_pathname allocated.  bfd->name will point to it.  */
 245
 246   abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
 247   if (!abfd)
 248     {
 249       close (scratch_chan);
 250       error ("Could not open `%s' as an executable file: %s",
 251              scratch_pathname, bfd_errmsg (bfd_get_error ()));
 252     }
 253   /* Leave bfd open, core_xfer_memory and "info files" need it.  */
 254   so->abfd = abfd;
 255   abfd->cacheable = true;
 256
 257   if (!bfd_check_format (abfd, bfd_object))
 258     {
 259       error ("\"%s\": not in executable format: %s.",
 260              scratch_pathname, bfd_errmsg (bfd_get_error ()));
 261     }
 262   if (build_section_table (abfd, &so->sections, &so->sections_end))
 263     {
 264       error ("Can't find the file sections in `%s': %s",
 265              bfd_get_filename (exec_bfd), bfd_errmsg (bfd_get_error ()));
 266     }
 267
 268   for (p = so->sections; p < so->sections_end; p++)
 269     {
 270       /* Relocate the section binding addresses as recorded in the shared
 271          object's file by the offset to get the address to which the
 272          object was actually mapped.  */
 273       p->addr += LM_OFFSET (so);
 274       p->endaddr += LM_OFFSET (so);
 275       so->lmend = (CORE_ADDR) max (p->endaddr, so->lmend);
 276       if (STREQ (p->the_bfd_section->name, ".text"))
 277         {
 278           so->textsection = p;
 279         }
 280     }
 281
 282   /* Free the file names, close the file now.  */
 283   do_cleanups (old_chain);
 284
 285   return (1);
 286 }
 287
 288 /*
 289
 290    LOCAL FUNCTION
 291
 292    first_link_map_member -- locate first member in dynamic linker's map
 293
 294    SYNOPSIS
 295
 296    static struct link_map *first_link_map_member (void)
 297
 298    DESCRIPTION
 299
 300    Read in a copy of the first member in the inferior's dynamic
 301    link map from the inferior's dynamic linker structures, and return
 302    a pointer to the copy in our address space.
 303  */
 304
 305 static struct link_map *
 306 first_link_map_member (void)
 307 {
 308   struct link_map *lm = NULL;
 309   static struct link_map first_lm;
 310
 311 #ifdef USE_LDR_ROUTINES
 312   ldr_module_t mod_id = LDR_NULL_MODULE;
 313   size_t retsize;
 314
 315   fake_ldr_process = ldr_core_process ();
 316   ldr_set_core_reader (ldr_read_memory);
 317   ldr_xdetach (fake_ldr_process);
 318   if (ldr_xattach (fake_ldr_process) != 0
 319       || ldr_next_module (fake_ldr_process, &mod_id) != 0
 320       || mod_id == LDR_NULL_MODULE
 321       || ldr_inq_module (fake_ldr_process, mod_id,
 322                          &first_lm.module_info, sizeof (ldr_module_info_t),
 323                          &retsize) != 0)
 324     return lm;
 325 #else
 326   CORE_ADDR ldr_context_addr;
 327
 328   if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS,
 329                           (char *) &ldr_context_addr,
 330                           sizeof (CORE_ADDR)) != 0
 331       || target_read_memory (ldr_context_addr,
 332                              (char *) &ldr_context,
 333                              sizeof (ldr_context_t)) != 0
 334       || target_read_memory ((CORE_ADDR) ldr_context.head,
 335                              (char *) &first_lm.module_info,
 336                              sizeof (ldr_module_info_t)) != 0)
 337     return lm;
 338 #endif
 339
 340   lm = &first_lm;
 341
 342   /* The first entry is for the main program and should be skipped.  */
 343   lm->l_name = NULL;
 344
 345   return lm;
 346 }
 347
 348 static struct link_map *
 349 next_link_map_member (struct so_list *so_list_ptr)
 350 {
 351   struct link_map *lm = NULL;
 352   static struct link_map next_lm;
 353 #ifdef USE_LDR_ROUTINES
 354   ldr_module_t mod_id = so_list_ptr->lm.module_info.lmi_modid;
 355   size_t retsize;
 356
 357   if (ldr_next_module (fake_ldr_process, &mod_id) != 0
 358       || mod_id == LDR_NULL_MODULE
 359       || ldr_inq_module (fake_ldr_process, mod_id,
 360                          &next_lm.module_info, sizeof (ldr_module_info_t),
 361                          &retsize) != 0)
 362     return lm;
 363
 364   lm = &next_lm;
 365   lm->l_name = lm->module_info.lmi_name;
 366 #else
 367   CORE_ADDR ldr_context_addr;
 368
 369   /* Reread context in case ldr_context.tail was updated.  */
 370
 371   if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS,
 372                           (char *) &ldr_context_addr,
 373                           sizeof (CORE_ADDR)) != 0
 374       || target_read_memory (ldr_context_addr,
 375                              (char *) &ldr_context,
 376                              sizeof (ldr_context_t)) != 0
 377       || so_list_ptr->lm.module_info.modinfo_addr == ldr_context.tail
 378       || target_read_memory (so_list_ptr->lm.module_info.next,
 379                              (char *) &next_lm.module_info,
 380                              sizeof (ldr_module_info_t)) != 0)
 381     return lm;
 382
 383   lm = &next_lm;
 384   lm->l_name = lm->module_info.module_name;
 385 #endif
 386   return lm;
 387 }
 388
 389 static void
 390 xfer_link_map_member (struct so_list *so_list_ptr, struct link_map *lm)
 391 {
 392   int i;
 393   so_list_ptr->lm = *lm;
 394
 395   /* OSF/1 shared libraries are pre-linked to particular addresses,
 396      but the runtime loader may have to relocate them if the
 397      address ranges of the libraries used by the target executable clash,
 398      or if the target executable is linked with the -taso option.
 399      The offset is the difference between the address where the shared
 400      library is mapped and the pre-linked address of the shared library.
 401
 402      FIXME:  GDB is currently unable to relocate the shared library
 403      sections by different offsets. If sections are relocated by
 404      different offsets, put out a warning and use the offset of the
 405      first section for all remaining sections.  */
 406   LM_OFFSET (so_list_ptr) = 0;
 407
 408   /* There is one entry that has no name (for the inferior executable)
 409      since it is not a shared object. */
 410   if (LM_NAME (so_list_ptr) != 0)
 411     {
 412
 413 #ifdef USE_LDR_ROUTINES
 414       int len = strlen (LM_NAME (so_list_ptr) + 1);
 415
 416       if (len > MAX_PATH_SIZE)
 417         len = MAX_PATH_SIZE;
 418       strncpy (so_list_ptr->so_name, LM_NAME (so_list_ptr), MAX_PATH_SIZE);
 419       so_list_ptr->so_name[MAX_PATH_SIZE - 1] = '\0';
 420
 421       for (i = 0; i < lm->module_info.lmi_nregion; i++)
 422         {
 423           ldr_region_info_t region_info;
 424           size_t retsize;
 425           CORE_ADDR region_offset;
 426
 427           if (ldr_inq_region (fake_ldr_process, lm->module_info.lmi_modid,
 428                               i, &region_info, sizeof (region_info),
 429                               &retsize) != 0)
 430             break;
 431           region_offset = (CORE_ADDR) region_info.lri_mapaddr
 432             - (CORE_ADDR) region_info.lri_vaddr;
 433           if (i == 0)
 434             LM_OFFSET (so_list_ptr) = region_offset;
 435           else if (LM_OFFSET (so_list_ptr) != region_offset)
 436             warning ("cannot handle shared library relocation for %s (%s)",
 437                      so_list_ptr->so_name, region_info.lri_name);
 438         }
 439 #else
 440       int errcode;
 441       char *buffer;
 442       target_read_string ((CORE_ADDR) LM_NAME (so_list_ptr), &buffer,
 443                           MAX_PATH_SIZE - 1, &errcode);
 444       if (errcode != 0)
 445         error ("xfer_link_map_member: Can't read pathname for load map: %s\n",
 446                safe_strerror (errcode));
 447       strncpy (so_list_ptr->so_name, buffer, MAX_PATH_SIZE - 1);
 448       free (buffer);
 449       so_list_ptr->so_name[MAX_PATH_SIZE - 1] = '\0';
 450
 451       for (i = 0; i < lm->module_info.region_count; i++)
 452         {
 453           ldr_region_info_t region_info;
 454           CORE_ADDR region_offset;
 455
 456           if (target_read_memory (lm->module_info.regioninfo_addr
 457                                   + i * sizeof (region_info),
 458                                   (char *) &region_info,
 459                                   sizeof (region_info)) != 0)
 460             break;
 461           region_offset = region_info.mapaddr - region_info.vaddr;
 462           if (i == 0)
 463             LM_OFFSET (so_list_ptr) = region_offset;
 464           else if (LM_OFFSET (so_list_ptr) != region_offset)
 465             {
 466               char *region_name;
 467               target_read_string (region_info.regionname_addr, &buffer,
 468                                   MAX_PATH_SIZE - 1, &errcode);
 469               if (errcode == 0)
 470                 region_name = buffer;
 471               else
 472                 region_name = "??";
 473               warning ("cannot handle shared library relocation for %s (%s)",
 474                        so_list_ptr->so_name, region_name);
 475               free (buffer);
 476             }
 477         }
 478 #endif
 479
 480       catch_errors (solib_map_sections, (char *) so_list_ptr,
 481                     "Error while mapping shared library sections:\n",
 482                     RETURN_MASK_ALL);
 483     }
 484 }
 485
 486 /*
 487
 488    LOCAL FUNCTION
 489
 490    find_solib -- step through list of shared objects
 491
 492    SYNOPSIS
 493
 494    struct so_list *find_solib (struct so_list *so_list_ptr)
 495
 496    DESCRIPTION
 497
 498    This module contains the routine which finds the names of any
 499    loaded "images" in the current process. The argument in must be
 500    NULL on the first call, and then the returned value must be passed
 501    in on subsequent calls. This provides the capability to "step" down
 502    the list of loaded objects. On the last object, a NULL value is
 503    returned.
 504
 505    The arg and return value are "struct link_map" pointers, as defined
 506    in <link.h>.
 507  */
 508
 509 static struct so_list *
 510 find_solib (so_list_ptr)
 511      struct so_list *so_list_ptr;       /* Last lm or NULL for first one */
 512 {
 513   struct so_list *so_list_next = NULL;
 514   struct link_map *lm = NULL;
 515   struct so_list *new;
 516
 517   if (so_list_ptr == NULL)
 518     {
 519       /* We are setting up for a new scan through the loaded images. */
 520       if ((so_list_next = so_list_head) == NULL)
 521         {
 522           /* Find the first link map list member. */
 523           lm = first_link_map_member ();
 524         }
 525     }
 526   else
 527     {
 528       /* We have been called before, and are in the process of walking
 529          the shared library list.  Advance to the next shared object. */
 530       lm = next_link_map_member (so_list_ptr);
 531       so_list_next = so_list_ptr->next;
 532     }
 533   if ((so_list_next == NULL) && (lm != NULL))
 534     {
 535       /* Get next link map structure from inferior image and build a local
 536          abbreviated load_map structure */
 537       new = (struct so_list *) xmalloc (sizeof (struct so_list));
 538       memset ((char *) new, 0, sizeof (struct so_list));
 539       new->lmaddr = lm;
 540       /* Add the new node as the next node in the list, or as the root
 541          node if this is the first one. */
 542       if (so_list_ptr != NULL)
 543         {
 544           so_list_ptr->next = new;
 545         }
 546       else
 547         {
 548           so_list_head = new;
 549         }
 550       so_list_next = new;
 551       xfer_link_map_member (new, lm);
 552     }
 553   return (so_list_next);
 554 }
 555
 556 /* A small stub to get us past the arg-passing pinhole of catch_errors.  */
 557
 558 static int
 559 symbol_add_stub (char *arg)
 560 {
 561   register struct so_list *so = (struct so_list *) arg;         /* catch_errs bogon */
 562   CORE_ADDR text_addr = 0;
 563   struct section_addr_info section_addrs;
 564
 565   memset (&section_addrs, 0, sizeof (section_addrs));
 566   if (so->textsection)
 567     text_addr = so->textsection->addr;
 568   else if (so->abfd != NULL)
 569     {
 570       asection *lowest_sect;
 571
 572       /* If we didn't find a mapped non zero sized .text section, set up
 573          text_addr so that the relocation in symbol_file_add does no harm.  */
 574
 575       lowest_sect = bfd_get_section_by_name (so->abfd, ".text");
 576       if (lowest_sect == NULL)
 577         bfd_map_over_sections (so->abfd, find_lowest_section,
 578                                (PTR) &lowest_sect);
 579       if (lowest_sect)
 580         text_addr = bfd_section_vma (so->abfd, lowest_sect) + LM_OFFSET (so);
 581     }
 582
 583   section_addrs.other[0].addr = text_addr;
 584   section_addrs.other[0].name = ".text";
 585   so->objfile = symbol_file_add (so->so_name, so->from_tty,
 586                                  &section_addrs, 0, OBJF_SHARED);
 587   return (1);
 588 }
 589
 590 /*
 591
 592    GLOBAL FUNCTION
 593
 594    solib_add -- add a shared library file to the symtab and section list
 595
 596    SYNOPSIS
 597
 598    void solib_add (char *arg_string, int from_tty,
 599    struct target_ops *target)
 600
 601    DESCRIPTION
 602
 603  */
 604
 605 void
 606 solib_add (char *arg_string, int from_tty, struct target_ops *target)
 607 {
 608   register struct so_list *so = NULL;   /* link map state variable */
 609
 610   /* Last shared library that we read.  */
 611   struct so_list *so_last = NULL;
 612
 613   char *re_err;
 614   int count;
 615   int old;
 616
 617   if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
 618     {
 619       error ("Invalid regexp: %s", re_err);
 620     }
 621
 622
 623   /* Add the shared library sections to the section table of the
 624      specified target, if any.  */
 625   if (target)
 626     {
 627       /* Count how many new section_table entries there are.  */
 628       so = NULL;
 629       count = 0;
 630       while ((so = find_solib (so)) != NULL)
 631         {
 632           if (so->so_name[0])
 633             {
 634               count += so->sections_end - so->sections;
 635             }
 636         }
 637
 638       if (count)
 639         {
 640           /* Add these section table entries to the target's table.  */
 641
 642           old = target_resize_to_sections (target, count);
 643
 644           while ((so = find_solib (so)) != NULL)
 645             {
 646               if (so->so_name[0])
 647                 {
 648                   count = so->sections_end - so->sections;
 649                   memcpy ((char *) (target->to_sections + old),
 650                           so->sections,
 651                           (sizeof (struct section_table)) * count);
 652                   old += count;
 653                 }
 654             }
 655         }
 656     }
 657
 658   /* Now add the symbol files.  */
 659   so = NULL;
 660   while ((so = find_solib (so)) != NULL)
 661     {
 662       if (so->so_name[0] && re_exec (so->so_name))
 663         {
 664           so->from_tty = from_tty;
 665           if (so->symbols_loaded)
 666             {
 667               if (from_tty)
 668                 {
 669                   printf_unfiltered ("Symbols already loaded for %s\n", so->so_name);
 670                 }
 671             }
 672           else if (catch_errors
 673                    (symbol_add_stub, (char *) so,
 674                     "Error while reading shared library symbols:\n",
 675                     RETURN_MASK_ALL))
 676             {
 677               so_last = so;
 678               so->symbols_loaded = 1;
 679             }
 680         }
 681     }
 682
 683   /* Getting new symbols may change our opinion about what is
 684      frameless.  */
 685   if (so_last)
 686     reinit_frame_cache ();
 687 }
 688
 689 /*
 690
 691    LOCAL FUNCTION
 692
 693    info_sharedlibrary_command -- code for "info sharedlibrary"
 694
 695    SYNOPSIS
 696
 697    static void info_sharedlibrary_command ()
 698
 699    DESCRIPTION
 700
 701    Walk through the shared library list and print information
 702    about each attached library.
 703  */
 704
 705 static void
 706 info_sharedlibrary_command (char *ignore, int from_tty)
 707 {
 708   register struct so_list *so = NULL;   /* link map state variable */
 709   int header_done = 0;
 710
 711   if (exec_bfd == NULL)
 712     {
 713       printf_unfiltered ("No executable file.\n");
 714       return;
 715     }
 716   while ((so = find_solib (so)) != NULL)
 717     {
 718       if (so->so_name[0])
 719         {
 720           unsigned long txt_start = 0;
 721           unsigned long txt_end = 0;
 722
 723           if (!header_done)
 724             {
 725               printf_unfiltered ("%-20s%-20s%-12s%s\n", "From", "To", "Syms Read",
 726                                  "Shared Object Library");
 727               header_done++;
 728             }
 729           if (so->textsection)
 730             {
 731               txt_start = (unsigned long) so->textsection->addr;
 732               txt_end = (unsigned long) so->textsection->endaddr;
 733             }
 734           printf_unfiltered ("%-20s", local_hex_string_custom (txt_start, "08l"));
 735           printf_unfiltered ("%-20s", local_hex_string_custom (txt_end, "08l"));
 736           printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
 737           printf_unfiltered ("%s\n", so->so_name);
 738         }
 739     }
 740   if (so_list_head == NULL)
 741     {
 742       printf_unfiltered ("No shared libraries loaded at this time.\n");
 743     }
 744 }
 745
 746 /*
 747
 748    GLOBAL FUNCTION
 749
 750    solib_address -- check to see if an address is in a shared lib
 751
 752    SYNOPSIS
 753
 754    char *solib_address (CORE_ADDR address)
 755
 756    DESCRIPTION
 757
 758    Provides a hook for other gdb routines to discover whether or
 759    not a particular address is within the mapped address space of
 760    a shared library.  Any address between the base mapping address
 761    and the first address beyond the end of the last mapping, is
 762    considered to be within the shared library address space, for
 763    our purposes.
 764
 765    For example, this routine is called at one point to disable
 766    breakpoints which are in shared libraries that are not currently
 767    mapped in.
 768  */
 769
 770 char *
 771 solib_address (CORE_ADDR address)
 772 {
 773   register struct so_list *so = 0;      /* link map state variable */
 774
 775   while ((so = find_solib (so)) != NULL)
 776     {
 777       if (so->so_name[0] && so->textsection)
 778         {
 779           if ((address >= (CORE_ADDR) so->textsection->addr) &&
 780               (address < (CORE_ADDR) so->textsection->endaddr))
 781             return (so->so_name);
 782         }
 783     }
 784   return (0);
 785 }
 786
 787 /* Called by free_all_symtabs */
 788
 789 void
 790 clear_solib (void)
 791 {
 792   struct so_list *next;
 793   char *bfd_filename;
 794
 795   disable_breakpoints_in_shlibs (1);
 796
 797   while (so_list_head)
 798     {
 799       if (so_list_head->sections)
 800         {
 801           free ((PTR) so_list_head->sections);
 802         }
 803       if (so_list_head->abfd)
 804         {
 805           bfd_filename = bfd_get_filename (so_list_head->abfd);
 806           if (!bfd_close (so_list_head->abfd))
 807             warning ("cannot close \"%s\": %s",
 808                      bfd_filename, bfd_errmsg (bfd_get_error ()));
 809         }
 810       else
 811         /* This happens for the executable on SVR4.  */
 812         bfd_filename = NULL;
 813
 814       next = so_list_head->next;
 815       if (bfd_filename)
 816         free ((PTR) bfd_filename);
 817       free ((PTR) so_list_head);
 818       so_list_head = next;
 819     }
 820 }
 821
 822 /*
 823
 824    GLOBAL FUNCTION
 825
 826    solib_create_inferior_hook -- shared library startup support
 827
 828    SYNOPSIS
 829
 830    void solib_create_inferior_hook()
 831
 832    DESCRIPTION
 833
 834    When gdb starts up the inferior, it nurses it along (through the
 835    shell) until it is ready to execute it's first instruction.  At this
 836    point, this function gets called via expansion of the macro
 837    SOLIB_CREATE_INFERIOR_HOOK.
 838    For a statically bound executable, this first instruction is the
 839    one at "_start", or a similar text label. No further processing is
 840    needed in that case.
 841    For a dynamically bound executable, this first instruction is somewhere
 842    in the rld, and the actual user executable is not yet mapped in.
 843    We continue the inferior again, rld then maps in the actual user
 844    executable and any needed shared libraries and then sends
 845    itself a SIGTRAP.
 846    At that point we discover the names of all shared libraries and
 847    read their symbols in.
 848
 849    FIXME
 850
 851    This code does not properly handle hitting breakpoints which the
 852    user might have set in the rld itself.  Proper handling would have
 853    to check if the SIGTRAP happened due to a kill call.
 854
 855    Also, what if child has exit()ed?  Must exit loop somehow.
 856  */
 857
 858 void
 859 solib_create_inferior_hook (void)
 860 {
 861
 862   /* Nothing to do for statically bound executables.  */
 863
 864   if (symfile_objfile == NULL
 865       || symfile_objfile->obfd == NULL
 866       || ((bfd_get_file_flags (symfile_objfile->obfd) & DYNAMIC) == 0))
 867     return;
 868
 869   /* Now run the target.  It will eventually get a SIGTRAP, at
 870      which point all of the libraries will have been mapped in and we
 871      can go groveling around in the rld structures to find
 872      out what we need to know about them. */
 873
 874   clear_proceed_status ();
 875   stop_soon_quietly = 1;
 876   stop_signal = TARGET_SIGNAL_0;
 877   do
 878     {
 879       target_resume (-1, 0, stop_signal);
 880       wait_for_inferior ();
 881     }
 882   while (stop_signal != TARGET_SIGNAL_TRAP);
 883
 884   /*  solib_add will call reinit_frame_cache.
 885      But we are stopped in the runtime loader and we do not have symbols
 886      for the runtime loader. So heuristic_proc_start will be called
 887      and will put out an annoying warning.
 888      Delaying the resetting of stop_soon_quietly until after symbol loading
 889      suppresses the warning.  */
 890   if (auto_solib_add)
 891     solib_add ((char *) 0, 0, (struct target_ops *) 0);
 892   stop_soon_quietly = 0;
 893 }
 894
 895
 896 /*
 897
 898    LOCAL FUNCTION
 899
 900    sharedlibrary_command -- handle command to explicitly add library
 901
 902    SYNOPSIS
 903
 904    static void sharedlibrary_command (char *args, int from_tty)
 905
 906    DESCRIPTION
 907
 908  */
 909
 910 static void
 911 sharedlibrary_command (char *args, int from_tty)
 912 {
 913   dont_repeat ();
 914   solib_add (args, from_tty, (struct target_ops *) 0);
 915 }
 916
 917 void
 918 _initialize_solib (void)
 919 {
 920   add_com ("sharedlibrary", class_files, sharedlibrary_command,
 921            "Load shared object library symbols for files matching REGEXP.");
 922   add_info ("sharedlibrary", info_sharedlibrary_command,
 923             "Status of loaded shared object libraries.");
 924
 925   add_show_from_set
 926     (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
 927                   (char *) &auto_solib_add,
 928                   "Set autoloading of shared library symbols.\n\
 929 If nonzero, symbols from all shared object libraries will be loaded\n\
 930 automatically when the inferior begins execution or when the dynamic linker\n\
 931 informs gdb that a new library has been loaded.  Otherwise, symbols\n\
 932 must be loaded manually, using `sharedlibrary'.",
 933                   &setlist),
 934      &showlist);
 935 }