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 = 1;
 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, int readsyms)
 600
 601    DESCRIPTION
 602
 603  */
 604
 605 void
 606 solib_add (char *arg_string, int from_tty, struct target_ops *target, int readsyms)
 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 (!readsyms)
 618     return;
 619
 620   if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
 621     {
 622       error ("Invalid regexp: %s", re_err);
 623     }
 624
 625
 626   /* Add the shared library sections to the section table of the
 627      specified target, if any.  */
 628   if (target)
 629     {
 630       /* Count how many new section_table entries there are.  */
 631       so = NULL;
 632       count = 0;
 633       while ((so = find_solib (so)) != NULL)
 634         {
 635           if (so->so_name[0])
 636             {
 637               count += so->sections_end - so->sections;
 638             }
 639         }
 640
 641       if (count)
 642         {
 643           /* Add these section table entries to the target's table.  */
 644
 645           old = target_resize_to_sections (target, count);
 646
 647           while ((so = find_solib (so)) != NULL)
 648             {
 649               if (so->so_name[0])
 650                 {
 651                   count = so->sections_end - so->sections;
 652                   memcpy ((char *) (target->to_sections + old),
 653                           so->sections,
 654                           (sizeof (struct section_table)) * count);
 655                   old += count;
 656                 }
 657             }
 658         }
 659     }
 660
 661   /* Now add the symbol files.  */
 662   so = NULL;
 663   while ((so = find_solib (so)) != NULL)
 664     {
 665       if (so->so_name[0] && re_exec (so->so_name))
 666         {
 667           so->from_tty = from_tty;
 668           if (so->symbols_loaded)
 669             {
 670               if (from_tty)
 671                 {
 672                   printf_unfiltered ("Symbols already loaded for %s\n", so->so_name);
 673                 }
 674             }
 675           else if (catch_errors
 676                    (symbol_add_stub, (char *) so,
 677                     "Error while reading shared library symbols:\n",
 678                     RETURN_MASK_ALL))
 679             {
 680               so_last = so;
 681               so->symbols_loaded = 1;
 682             }
 683         }
 684     }
 685
 686   /* Getting new symbols may change our opinion about what is
 687      frameless.  */
 688   if (so_last)
 689     reinit_frame_cache ();
 690 }
 691
 692 /*
 693
 694    LOCAL FUNCTION
 695
 696    info_sharedlibrary_command -- code for "info sharedlibrary"
 697
 698    SYNOPSIS
 699
 700    static void info_sharedlibrary_command ()
 701
 702    DESCRIPTION
 703
 704    Walk through the shared library list and print information
 705    about each attached library.
 706  */
 707
 708 static void
 709 info_sharedlibrary_command (char *ignore, int from_tty)
 710 {
 711   register struct so_list *so = NULL;   /* link map state variable */
 712   int header_done = 0;
 713
 714   if (exec_bfd == NULL)
 715     {
 716       printf_unfiltered ("No executable file.\n");
 717       return;
 718     }
 719   while ((so = find_solib (so)) != NULL)
 720     {
 721       if (so->so_name[0])
 722         {
 723           unsigned long txt_start = 0;
 724           unsigned long txt_end = 0;
 725
 726           if (!header_done)
 727             {
 728               printf_unfiltered ("%-20s%-20s%-12s%s\n", "From", "To", "Syms Read",
 729                                  "Shared Object Library");
 730               header_done++;
 731             }
 732           if (so->textsection)
 733             {
 734               txt_start = (unsigned long) so->textsection->addr;
 735               txt_end = (unsigned long) so->textsection->endaddr;
 736             }
 737           printf_unfiltered ("%-20s", local_hex_string_custom (txt_start, "08l"));
 738           printf_unfiltered ("%-20s", local_hex_string_custom (txt_end, "08l"));
 739           printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
 740           printf_unfiltered ("%s\n", so->so_name);
 741         }
 742     }
 743   if (so_list_head == NULL)
 744     {
 745       printf_unfiltered ("No shared libraries loaded at this time.\n");
 746     }
 747 }
 748
 749 /*
 750
 751    GLOBAL FUNCTION
 752
 753    solib_address -- check to see if an address is in a shared lib
 754
 755    SYNOPSIS
 756
 757    char *solib_address (CORE_ADDR address)
 758
 759    DESCRIPTION
 760
 761    Provides a hook for other gdb routines to discover whether or
 762    not a particular address is within the mapped address space of
 763    a shared library.  Any address between the base mapping address
 764    and the first address beyond the end of the last mapping, is
 765    considered to be within the shared library address space, for
 766    our purposes.
 767
 768    For example, this routine is called at one point to disable
 769    breakpoints which are in shared libraries that are not currently
 770    mapped in.
 771  */
 772
 773 char *
 774 solib_address (CORE_ADDR address)
 775 {
 776   register struct so_list *so = 0;      /* link map state variable */
 777
 778   while ((so = find_solib (so)) != NULL)
 779     {
 780       if (so->so_name[0] && so->textsection)
 781         {
 782           if ((address >= (CORE_ADDR) so->textsection->addr) &&
 783               (address < (CORE_ADDR) so->textsection->endaddr))
 784             return (so->so_name);
 785         }
 786     }
 787   return (0);
 788 }
 789
 790 /* Called by free_all_symtabs */
 791
 792 void
 793 clear_solib (void)
 794 {
 795   struct so_list *next;
 796   char *bfd_filename;
 797
 798   disable_breakpoints_in_shlibs (1);
 799
 800   while (so_list_head)
 801     {
 802       if (so_list_head->sections)
 803         {
 804           xfree (so_list_head->sections);
 805         }
 806       if (so_list_head->abfd)
 807         {
 808           remove_target_sections (so_list_head->abfd);
 809           bfd_filename = bfd_get_filename (so_list_head->abfd);
 810           if (!bfd_close (so_list_head->abfd))
 811             warning ("cannot close \"%s\": %s",
 812                      bfd_filename, bfd_errmsg (bfd_get_error ()));
 813         }
 814       else
 815         /* This happens for the executable on SVR4.  */
 816         bfd_filename = NULL;
 817
 818       next = so_list_head->next;
 819       if (bfd_filename)
 820         xfree (bfd_filename);
 821       xfree (so_list_head);
 822       so_list_head = next;
 823     }
 824 }
 825
 826 /*
 827
 828    GLOBAL FUNCTION
 829
 830    solib_create_inferior_hook -- shared library startup support
 831
 832    SYNOPSIS
 833
 834    void solib_create_inferior_hook()
 835
 836    DESCRIPTION
 837
 838    When gdb starts up the inferior, it nurses it along (through the
 839    shell) until it is ready to execute it's first instruction.  At this
 840    point, this function gets called via expansion of the macro
 841    SOLIB_CREATE_INFERIOR_HOOK.
 842    For a statically bound executable, this first instruction is the
 843    one at "_start", or a similar text label. No further processing is
 844    needed in that case.
 845    For a dynamically bound executable, this first instruction is somewhere
 846    in the rld, and the actual user executable is not yet mapped in.
 847    We continue the inferior again, rld then maps in the actual user
 848    executable and any needed shared libraries and then sends
 849    itself a SIGTRAP.
 850    At that point we discover the names of all shared libraries and
 851    read their symbols in.
 852
 853    FIXME
 854
 855    This code does not properly handle hitting breakpoints which the
 856    user might have set in the rld itself.  Proper handling would have
 857    to check if the SIGTRAP happened due to a kill call.
 858
 859    Also, what if child has exit()ed?  Must exit loop somehow.
 860  */
 861
 862 void
 863 solib_create_inferior_hook (void)
 864 {
 865
 866   /* Nothing to do for statically bound executables.  */
 867
 868   if (symfile_objfile == NULL
 869       || symfile_objfile->obfd == NULL
 870       || ((bfd_get_file_flags (symfile_objfile->obfd) & DYNAMIC) == 0))
 871     return;
 872
 873   /* Now run the target.  It will eventually get a SIGTRAP, at
 874      which point all of the libraries will have been mapped in and we
 875      can go groveling around in the rld structures to find
 876      out what we need to know about them. */
 877
 878   clear_proceed_status ();
 879   stop_soon_quietly = 1;
 880   stop_signal = TARGET_SIGNAL_0;
 881   do
 882     {
 883       target_resume (minus_one_ptid, 0, stop_signal);
 884       wait_for_inferior ();
 885     }
 886   while (stop_signal != TARGET_SIGNAL_TRAP);
 887
 888   /*  solib_add will call reinit_frame_cache.
 889      But we are stopped in the runtime loader and we do not have symbols
 890      for the runtime loader. So heuristic_proc_start will be called
 891      and will put out an annoying warning.
 892      Delaying the resetting of stop_soon_quietly until after symbol loading
 893      suppresses the warning.  */
 894   solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add);
 895   stop_soon_quietly = 0;
 896 }
 897
 898
 899 /*
 900
 901    LOCAL FUNCTION
 902
 903    sharedlibrary_command -- handle command to explicitly add library
 904
 905    SYNOPSIS
 906
 907    static void sharedlibrary_command (char *args, int from_tty)
 908
 909    DESCRIPTION
 910
 911  */
 912
 913 static void
 914 sharedlibrary_command (char *args, int from_tty)
 915 {
 916   dont_repeat ();
 917   solib_add (args, from_tty, (struct target_ops *) 0, 1);
 918 }
 919
 920 void
 921 _initialize_solib (void)
 922 {
 923   add_com ("sharedlibrary", class_files, sharedlibrary_command,
 924            "Load shared object library symbols for files matching REGEXP.");
 925   add_info ("sharedlibrary", info_sharedlibrary_command,
 926             "Status of loaded shared object libraries.");
 927
 928   add_show_from_set
 929     (add_set_cmd ("auto-solib-add", class_support, var_boolean,
 930                   (char *) &auto_solib_add,
 931                   "Set autoloading of shared library symbols.\n\
 932 If \"on\", symbols from all shared object libraries will be loaded\n\
 933 automatically when the inferior begins execution, when the dynamic linker\n\
 934 informs gdb that a new library has been loaded, or when attaching to the\n\
 935 inferior.  Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
 936                   &setlist),
 937      &showlist);
 938 }