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