gdb/osfsolib.c

   1 /* Handle OSF/1 shared libraries for GDB, the GNU Debugger.
   2    Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 /* FIXME: Most of this code could be merged with solib.c by using
  23    next_link_map_member and xfer_link_map_member in solib.c.  */
  24
  25 #include "defs.h"
  26
  27 #include <sys/types.h>
  28 #include <signal.h>
  29 #include "gdb_string.h"
  30 #include <fcntl.h>
  31
  32 #include "symtab.h"
  33 #include "bfd.h"
  34 #include "symfile.h"
  35 #include "objfiles.h"
  36 #include "gdbcore.h"
  37 #include "command.h"
  38 #include "target.h"
  39 #include "frame.h"
  40 #include "gdb_regex.h"
  41 #include "inferior.h"
  42 #include "language.h"
  43 #include "gdbcmd.h"
  44
  45 #define MAX_PATH_SIZE 1024      /* FIXME: Should be dynamic */
  46
  47 /* When handling shared libraries, GDB has to find out the pathnames
  48    of all shared libraries that are currently loaded (to read in their
  49    symbols) and where the shared libraries are loaded in memory
  50    (to relocate them properly from their prelinked addresses to the
  51    current load address).
  52
  53    Under OSF/1 there are two possibilities to get at this information:
  54    1) Peek around in the runtime loader structures.
  55    These are not documented, and they are not defined in the system
  56    header files. The definitions below were obtained by experimentation,
  57    but they seem stable enough.
  58    2) Use the undocumented libxproc.a library, which contains the
  59    equivalent ldr_* routines.
  60    This approach is somewhat cleaner, but it requires that the GDB
  61    executable is dynamically linked. In addition it requires a
  62    NAT_CLIBS= -lxproc -Wl,-expect_unresolved,ldr_process_context
  63    linker specification for GDB and all applications that are using
  64    libgdb.
  65    We will use the peeking approach until it becomes unwieldy.  */
  66
  67 #ifndef USE_LDR_ROUTINES
  68
  69 /* Definition of runtime loader structures, found by experimentation.  */
  70 #define RLD_CONTEXT_ADDRESS     0x3ffc0000000
  71
  72 typedef struct
  73   {
  74     CORE_ADDR next;
  75     CORE_ADDR previous;
  76     CORE_ADDR unknown1;
  77     char *module_name;
  78     CORE_ADDR modinfo_addr;
  79     long module_id;
  80     CORE_ADDR unknown2;
  81     CORE_ADDR unknown3;
  82     long region_count;
  83     CORE_ADDR regioninfo_addr;
  84   }
  85 ldr_module_info_t;
  86
  87 typedef struct
  88   {
  89     long unknown1;
  90     CORE_ADDR regionname_addr;
  91     long protection;
  92     CORE_ADDR vaddr;
  93     CORE_ADDR mapaddr;
  94     long size;
  95     long unknown2[5];
  96   }
  97 ldr_region_info_t;
  98
  99 typedef struct
 100   {
 101     CORE_ADDR unknown1;
 102     CORE_ADDR unknown2;
 103     CORE_ADDR head;
 104     CORE_ADDR tail;
 105   }
 106 ldr_context_t;
 107
 108 static ldr_context_t ldr_context;
 109
 110 #else
 111
 112 #include <loader.h>
 113 static ldr_process_t fake_ldr_process;
 114
 115 /* Called by ldr_* routines to read memory from the current target.  */
 116
 117 static int ldr_read_memory (CORE_ADDR, char *, int, int);
 118
 119 static int
 120 ldr_read_memory (CORE_ADDR memaddr, char *myaddr, int len, int readstring)
 121 {
 122   int result;
 123   char *buffer;
 124
 125   if (readstring)
 126     {
 127       target_read_string (memaddr, &buffer, len, &result);
 128       if (result == 0)
 129         strcpy (myaddr, buffer);
 130       xfree (buffer);
 131     }
 132   else
 133     result = target_read_memory (memaddr, myaddr, len);
 134
 135   if (result != 0)
 136     result = -result;
 137   return result;
 138 }
 139
 140 #endif
 141
 142 /* Define our own link_map structure.
 143    This will help to share code with solib.c.  */
 144
 145 struct link_map
 146 {
 147   CORE_ADDR l_offset;           /* prelink to load address offset */
 148   char *l_name;                 /* full name of loaded object */
 149   ldr_module_info_t module_info;        /* corresponding module info */
 150 };
 151
 152 #define LM_OFFSET(so) ((so) -> lm.l_offset)
 153 #define LM_NAME(so) ((so) -> lm.l_name)
 154
 155 struct so_list
 156   {
 157     struct so_list *next;       /* next structure in linked list */
 158     struct link_map lm;         /* copy of link map from inferior */
 159     struct link_map *lmaddr;    /* addr in inferior lm was read from */
 160     CORE_ADDR lmend;            /* upper addr bound of mapped object */
 161     char so_name[MAX_PATH_SIZE];        /* shared object lib name (FIXME) */
 162     char symbols_loaded;        /* flag: symbols read in yet? */
 163     char from_tty;              /* flag: print msgs? */
 164     struct objfile *objfile;    /* objfile for loaded lib */
 165     struct section_table *sections;
 166     struct section_table *sections_end;
 167     struct section_table *textsection;
 168     bfd *abfd;
 169   };
 170
 171 static struct so_list *so_list_head;    /* List of known shared objects */
 172
 173 extern int fdmatch (int, int);  /* In libiberty */
 174
 175 /* Local function prototypes */
 176
 177 static void sharedlibrary_command (char *, int);
 178
 179 static void info_sharedlibrary_command (char *, int);
 180
 181 static int symbol_add_stub (char *);
 182
 183 static struct so_list *find_solib (struct so_list *);
 184
 185 static struct link_map *first_link_map_member (void);
 186
 187 static struct link_map *next_link_map_member (struct so_list *);
 188
 189 static void xfer_link_map_member (struct so_list *, struct link_map *);
 190
 191 static int solib_map_sections (char *);
 192
 193 /*
 194
 195    LOCAL FUNCTION
 196
 197    solib_map_sections -- open bfd and build sections for shared lib
 198
 199    SYNOPSIS
 200
 201    static int solib_map_sections (struct so_list *so)
 202
 203    DESCRIPTION
 204
 205    Given a pointer to one of the shared objects in our list
 206    of mapped objects, use the recorded name to open a bfd
 207    descriptor for the object, build a section table, and then
 208    relocate all the section addresses by the base address at
 209    which the shared object was mapped.
 210
 211    FIXMES
 212
 213    In most (all?) cases the shared object file name recorded in the
 214    dynamic linkage tables will be a fully qualified pathname.  For
 215    cases where it isn't, do we really mimic the systems search
 216    mechanism correctly in the below code (particularly the tilde
 217    expansion stuff?).
 218  */
 219
 220 static int
 221 solib_map_sections (char *arg)
 222 {
 223   struct so_list *so = (struct so_list *) arg;  /* catch_errors bogon */
 224   char *filename;
 225   char *scratch_pathname;
 226   int scratch_chan;
 227   struct section_table *p;
 228   struct cleanup *old_chain;
 229   bfd *abfd;
 230
 231   filename = tilde_expand (so->so_name);
 232   old_chain = make_cleanup (xfree, filename);
 233
 234   scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
 235                         &scratch_pathname);
 236   if (scratch_chan < 0)
 237     {
 238       scratch_chan = openp (getenv ("LD_LIBRARY_PATH"), 1, filename,
 239                             O_RDONLY, 0, &scratch_pathname);
 240     }
 241   if (scratch_chan < 0)
 242     {
 243       perror_with_name (filename);
 244     }
 245   /* Leave scratch_pathname allocated.  bfd->name will point to it.  */
 246
 247   abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
 248   if (!abfd)
 249     {
 250       close (scratch_chan);
 251       error ("Could not open `%s' as an executable file: %s",
 252              scratch_pathname, bfd_errmsg (bfd_get_error ()));
 253     }
 254   /* Leave bfd open, core_xfer_memory and "info files" need it.  */
 255   so->abfd = abfd;
 256   abfd->cacheable = true;
 257
 258   if (!bfd_check_format (abfd, bfd_object))
 259     {
 260       error ("\"%s\": not in executable format: %s.",
 261              scratch_pathname, bfd_errmsg (bfd_get_error ()));
 262     }
 263   if (build_section_table (abfd, &so->sections, &so->sections_end))
 264     {
 265       error ("Can't find the file sections in `%s': %s",
 266              bfd_get_filename (exec_bfd), bfd_errmsg (bfd_get_error ()));
 267     }
 268
 269   for (p = so->sections; p < so->sections_end; p++)
 270     {
 271       /* Relocate the section binding addresses as recorded in the shared
 272          object's file by the offset to get the address to which the
 273          object was actually mapped.  */
 274       p->addr += LM_OFFSET (so);
 275       p->endaddr += LM_OFFSET (so);
 276       so->lmend = (CORE_ADDR) max (p->endaddr, so->lmend);
 277       if (STREQ (p->the_bfd_section->name, ".text"))
 278         {
 279           so->textsection = p;
 280         }
 281     }
 282
 283   /* Free the file names, close the file now.  */
 284   do_cleanups (old_chain);
 285
 286   return (1);
 287 }
 288
 289 /*
 290
 291    LOCAL FUNCTION
 292
 293    first_link_map_member -- locate first member in dynamic linker's map
 294
 295    SYNOPSIS
 296
 297    static struct link_map *first_link_map_member (void)
 298
 299    DESCRIPTION
 300
 301    Read in a copy of the first member in the inferior's dynamic
 302    link map from the inferior's dynamic linker structures, and return
 303    a pointer to the copy in our address space.
 304  */
 305
 306 static struct link_map *
 307 first_link_map_member (void)
 308 {
 309   struct link_map *lm = NULL;
 310   static struct link_map first_lm;
 311
 312 #ifdef USE_LDR_ROUTINES
 313   ldr_module_t mod_id = LDR_NULL_MODULE;
 314   size_t retsize;
 315
 316   fake_ldr_process = ldr_core_process ();
 317   ldr_set_core_reader (ldr_read_memory);
 318   ldr_xdetach (fake_ldr_process);
 319   if (ldr_xattach (fake_ldr_process) != 0
 320       || ldr_next_module (fake_ldr_process, &mod_id) != 0
 321       || mod_id == LDR_NULL_MODULE
 322       || ldr_inq_module (fake_ldr_process, mod_id,
 323                          &first_lm.module_info, sizeof (ldr_module_info_t),
 324                          &retsize) != 0)
 325     return lm;
 326 #else
 327   CORE_ADDR ldr_context_addr;
 328
 329   if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS,
 330                           (char *) &ldr_context_addr,
 331                           sizeof (CORE_ADDR)) != 0
 332       || target_read_memory (ldr_context_addr,
 333                              (char *) &ldr_context,
 334                              sizeof (ldr_context_t)) != 0
 335       || target_read_memory ((CORE_ADDR) ldr_context.head,
 336                              (char *) &first_lm.module_info,
 337                              sizeof (ldr_module_info_t)) != 0)
 338     return lm;
 339 #endif
 340
 341   lm = &first_lm;
 342
 343   /* The first entry is for the main program and should be skipped.  */
 344   lm->l_name = NULL;
 345
 346   return lm;
 347 }
 348
 349 static struct link_map *
 350 next_link_map_member (struct so_list *so_list_ptr)
 351 {
 352   struct link_map *lm = NULL;
 353   static struct link_map next_lm;
 354 #ifdef USE_LDR_ROUTINES
 355   ldr_module_t mod_id = so_list_ptr->lm.module_info.lmi_modid;
 356   size_t retsize;
 357
 358   if (ldr_next_module (fake_ldr_process, &mod_id) != 0
 359       || mod_id == LDR_NULL_MODULE
 360       || ldr_inq_module (fake_ldr_process, mod_id,
 361                          &next_lm.module_info, sizeof (ldr_module_info_t),
 362                          &retsize) != 0)
 363     return lm;
 364
 365   lm = &next_lm;
 366   lm->l_name = lm->module_info.lmi_name;
 367 #else
 368   CORE_ADDR ldr_context_addr;
 369
 370   /* Reread context in case ldr_context.tail was updated.  */
 371
 372   if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS,
 373                           (char *) &ldr_context_addr,
 374                           sizeof (CORE_ADDR)) != 0
 375       || target_read_memory (ldr_context_addr,
 376                              (char *) &ldr_context,
 377                              sizeof (ldr_context_t)) != 0
 378       || so_list_ptr->lm.module_info.modinfo_addr == ldr_context.tail
 379       || target_read_memory (so_list_ptr->lm.module_info.next,
 380                              (char *) &next_lm.module_info,
 381                              sizeof (ldr_module_info_t)) != 0)
 382     return lm;
 383
 384   lm = &next_lm;
 385   lm->l_name = lm->module_info.module_name;
 386 #endif
 387   return lm;
 388 }
 389
 390 static void
 391 xfer_link_map_member (struct so_list *so_list_ptr, struct link_map *lm)
 392 {
 393   int i;
 394   so_list_ptr->lm = *lm;
 395
 396   /* OSF/1 shared libraries are pre-linked to particular addresses,
 397      but the runtime loader may have to relocate them if the
 398      address ranges of the libraries used by the target executable clash,
 399      or if the target executable is linked with the -taso option.
 400      The offset is the difference between the address where the shared
 401      library is mapped and the pre-linked address of the shared library.
 402
 403      FIXME:  GDB is currently unable to relocate the shared library
 404      sections by different offsets. If sections are relocated by
 405      different offsets, put out a warning and use the offset of the
 406      first section for all remaining sections.  */
 407   LM_OFFSET (so_list_ptr) = 0;
 408
 409   /* There is one entry that has no name (for the inferior executable)
 410      since it is not a shared object. */
 411   if (LM_NAME (so_list_ptr) != 0)
 412     {
 413
 414 #ifdef USE_LDR_ROUTINES
 415       int len = strlen (LM_NAME (so_list_ptr) + 1);
 416
 417       if (len > MAX_PATH_SIZE)
 418         len = MAX_PATH_SIZE;
 419       strncpy (so_list_ptr->so_name, LM_NAME (so_list_ptr), MAX_PATH_SIZE);
 420       so_list_ptr->so_name[MAX_PATH_SIZE - 1] = '\0';
 421
 422       for (i = 0; i < lm->module_info.lmi_nregion; i++)
 423         {
 424           ldr_region_info_t region_info;
 425           size_t retsize;
 426           CORE_ADDR region_offset;
 427
 428           if (ldr_inq_region (fake_ldr_process, lm->module_info.lmi_modid,
 429                               i, &region_info, sizeof (region_info),
 430                               &retsize) != 0)
 431             break;
 432           region_offset = (CORE_ADDR) region_info.lri_mapaddr
 433             - (CORE_ADDR) region_info.lri_vaddr;
 434           if (i == 0)
 435             LM_OFFSET (so_list_ptr) = region_offset;
 436           else if (LM_OFFSET (so_list_ptr) != region_offset)
 437             warning ("cannot handle shared library relocation for %s (%s)",
 438                      so_list_ptr->so_name, region_info.lri_name);
 439         }
 440 #else
 441       int errcode;
 442       char *buffer;
 443       target_read_string ((CORE_ADDR) LM_NAME (so_list_ptr), &buffer,
 444                           MAX_PATH_SIZE - 1, &errcode);
 445       if (errcode != 0)
 446         error ("xfer_link_map_member: Can't read pathname for load map: %s\n",
 447                safe_strerror (errcode));
 448       strncpy (so_list_ptr->so_name, buffer, MAX_PATH_SIZE - 1);
 449       xfree (buffer);
 450       so_list_ptr->so_name[MAX_PATH_SIZE - 1] = '\0';
 451
 452       for (i = 0; i < lm->module_info.region_count; i++)
 453         {
 454           ldr_region_info_t region_info;
 455           CORE_ADDR region_offset;
 456
 457           if (target_read_memory (lm->module_info.regioninfo_addr
 458                                   + i * sizeof (region_info),
 459                                   (char *) &region_info,
 460                                   sizeof (region_info)) != 0)
 461             break;
 462           region_offset = region_info.mapaddr - region_info.vaddr;
 463           if (i == 0)
 464             LM_OFFSET (so_list_ptr) = region_offset;
 465           else if (LM_OFFSET (so_list_ptr) != region_offset)
 466             {
 467               char *region_name;
 468               target_read_string (region_info.regionname_addr, &buffer,
 469                                   MAX_PATH_SIZE - 1, &errcode);
 470               if (errcode == 0)
 471                 region_name = buffer;
 472               else
 473                 region_name = "??";
 474               warning ("cannot handle shared library relocation for %s (%s)",
 475                        so_list_ptr->so_name, region_name);
 476               xfree (buffer);
 477             }
 478         }
 479 #endif
 480
 481       catch_errors (solib_map_sections, (char *) so_list_ptr,
 482                     "Error while mapping shared library sections:\n",
 483                     RETURN_MASK_ALL);
 484     }
 485 }
 486
 487 /*
 488
 489    LOCAL FUNCTION
 490
 491    find_solib -- step through list of shared objects
 492
 493    SYNOPSIS
 494
 495    struct so_list *find_solib (struct so_list *so_list_ptr)
 496
 497    DESCRIPTION
 498
 499    This module contains the routine which finds the names of any
 500    loaded "images" in the current process. The argument in must be
 501    NULL on the first call, and then the returned value must be passed
 502    in on subsequent calls. This provides the capability to "step" down
 503    the list of loaded objects. On the last object, a NULL value is
 504    returned.
 505
 506    The arg and return value are "struct link_map" pointers, as defined
 507    in <link.h>.
 508  */
 509
 510 static struct so_list *
 511 find_solib (struct so_list *so_list_ptr)
 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           xfree (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         xfree (bfd_filename);
 817       xfree (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 (minus_one_ptid, 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 }