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