gdb/irix5-nat.c

   1 /* Native support for the SGI Iris running IRIX version 5, for GDB.
   2    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994
   3    Free Software Foundation, Inc.
   4    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
   5    and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
   6    Implemented for Irix 4.x by Garrett A. Wollman.
   7    Modified for Irix 5.x by Ian Lance Taylor.
   8
   9 This file is part of GDB.
  10
  11 This program is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2 of the License, or
  14 (at your option) any later version.
  15
  16 This program is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with this program; if not, write to the Free Software
  23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  24
  25 #include "defs.h"
  26 #include "inferior.h"
  27 #include "gdbcore.h"
  28 #include "target.h"
  29
  30 #include <sys/time.h>
  31 #include <sys/procfs.h>
  32 #include <setjmp.h>             /* For JB_XXX.  */
  33
  34 /* Size of elements in jmpbuf */
  35
  36 #define JB_ELEMENT_SIZE 4
  37
  38 /*
  39  * See the comment in m68k-tdep.c regarding the utility of these functions.
  40  *
  41  * These definitions are from the MIPS SVR4 ABI, so they may work for
  42  * any MIPS SVR4 target.
  43  */
  44
  45 void
  46 supply_gregset (gregsetp)
  47      gregset_t *gregsetp;
  48 {
  49   register int regi;
  50   register greg_t *regp = &(*gregsetp)[0];
  51
  52   for(regi = 0; regi <= CTX_RA; regi++)
  53     supply_register (regi, (char *)(regp + regi));
  54
  55   supply_register (PC_REGNUM, (char *)(regp + CTX_EPC));
  56   supply_register (HI_REGNUM, (char *)(regp + CTX_MDHI));
  57   supply_register (LO_REGNUM, (char *)(regp + CTX_MDLO));
  58   supply_register (CAUSE_REGNUM, (char *)(regp + CTX_CAUSE));
  59 }
  60
  61 void
  62 fill_gregset (gregsetp, regno)
  63      gregset_t *gregsetp;
  64      int regno;
  65 {
  66   int regi;
  67   register greg_t *regp = &(*gregsetp)[0];
  68
  69   for (regi = 0; regi <= CTX_RA; regi++)
  70     if ((regno == -1) || (regno == regi))
  71       *(regp + regi) = *(greg_t *) &registers[REGISTER_BYTE (regi)];
  72
  73   if ((regno == -1) || (regno == PC_REGNUM))
  74     *(regp + CTX_EPC) = *(greg_t *) &registers[REGISTER_BYTE (PC_REGNUM)];
  75
  76   if ((regno == -1) || (regno == CAUSE_REGNUM))
  77     *(regp + CTX_CAUSE) = *(greg_t *) &registers[REGISTER_BYTE (PS_REGNUM)];
  78
  79   if ((regno == -1) || (regno == HI_REGNUM))
  80     *(regp + CTX_MDHI) = *(greg_t *) &registers[REGISTER_BYTE (HI_REGNUM)];
  81
  82   if ((regno == -1) || (regno == LO_REGNUM))
  83     *(regp + CTX_MDLO) = *(greg_t *) &registers[REGISTER_BYTE (LO_REGNUM)];
  84 }
  85
  86 /*
  87  * Now we do the same thing for floating-point registers.
  88  * We don't bother to condition on FP0_REGNUM since any
  89  * reasonable MIPS configuration has an R3010 in it.
  90  *
  91  * Again, see the comments in m68k-tdep.c.
  92  */
  93
  94 void
  95 supply_fpregset (fpregsetp)
  96      fpregset_t *fpregsetp;
  97 {
  98   register int regi;
  99
 100   for (regi = 0; regi < 32; regi++)
 101     supply_register (FP0_REGNUM + regi,
 102                      (char *)&fpregsetp->fp_r.fp_regs[regi]);
 103
 104   supply_register (FCRCS_REGNUM, (char *)&fpregsetp->fp_csr);
 105
 106   /* FIXME: how can we supply FCRIR_REGNUM?  SGI doesn't tell us. */
 107 }
 108
 109 void
 110 fill_fpregset (fpregsetp, regno)
 111      fpregset_t *fpregsetp;
 112      int regno;
 113 {
 114   int regi;
 115   char *from, *to;
 116
 117   for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
 118     {
 119       if ((regno == -1) || (regno == regi))
 120         {
 121           from = (char *) &registers[REGISTER_BYTE (regi)];
 122           to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
 123           memcpy(to, from, REGISTER_RAW_SIZE (regi));
 124         }
 125     }
 126
 127   if ((regno == -1) || (regno == FCRCS_REGNUM))
 128     fpregsetp->fp_csr = *(unsigned *) &registers[REGISTER_BYTE(FCRCS_REGNUM)];
 129 }
 130
 131
 132 /* Figure out where the longjmp will land.
 133    We expect the first arg to be a pointer to the jmp_buf structure from which
 134    we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
 135    This routine returns true on success. */
 136
 137 int
 138 get_longjmp_target (pc)
 139      CORE_ADDR *pc;
 140 {
 141   char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
 142   CORE_ADDR jb_addr;
 143
 144   jb_addr = read_register (A0_REGNUM);
 145
 146   if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
 147                           TARGET_PTR_BIT / TARGET_CHAR_BIT))
 148     return 0;
 149
 150   *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 151
 152   return 1;
 153 }
 154
 155 void
 156 fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
 157      char *core_reg_sect;
 158      unsigned core_reg_size;
 159      int which;                 /* Unused */
 160      unsigned int reg_addr;     /* Unused */
 161 {
 162   if (core_reg_size != REGISTER_BYTES)
 163     {
 164       warning ("wrong size gregset struct in core file");
 165       return;
 166     }
 167
 168   memcpy ((char *)registers, core_reg_sect, core_reg_size);
 169 }
 170 \f
 171 /* Irix 5 uses what appears to be a unique form of shared library
 172    support.  This is a copy of solib.c modified for Irix 5.  */
 173
 174 #include <sys/types.h>
 175 #include <signal.h>
 176 #include <string.h>
 177 #include <sys/param.h>
 178 #include <fcntl.h>
 179
 180 /* <obj.h> includes <sym.h> and <symconst.h>, which causes conflicts
 181    with our versions of those files included by tm-mips.h.  Prevent
 182    <obj.h> from including them with some appropriate defines.  */
 183 #define __SYM_H__
 184 #define __SYMCONST_H__
 185 #include <obj.h>
 186
 187 #include "symtab.h"
 188 #include "bfd.h"
 189 #include "symfile.h"
 190 #include "objfiles.h"
 191 #include "command.h"
 192 #include "frame.h"
 193 #include "regex.h"
 194 #include "inferior.h"
 195 #include "language.h"
 196
 197 /* The symbol which starts off the list of shared libraries.  */
 198 #define DEBUG_BASE "__rld_obj_head"
 199
 200 /* How to get the loaded address of a shared library.  */
 201 #define LM_ADDR(so) ((so)->lm.o_praw)
 202
 203 char shadow_contents[BREAKPOINT_MAX];   /* Stash old bkpt addr contents */
 204
 205 struct so_list {
 206   struct so_list *next;                 /* next structure in linked list */
 207   struct obj_list ll;
 208   struct obj lm;                        /* copy of link map from inferior */
 209   struct obj_list *lladdr;              /* addr in inferior lm was read from */
 210   CORE_ADDR lmend;                      /* upper addr bound of mapped object */
 211   char symbols_loaded;                  /* flag: symbols read in yet? */
 212   char from_tty;                        /* flag: print msgs? */
 213   struct objfile *objfile;              /* objfile for loaded lib */
 214   struct section_table *sections;
 215   struct section_table *sections_end;
 216   struct section_table *textsection;
 217   bfd *abfd;
 218 };
 219
 220 static struct so_list *so_list_head;    /* List of known shared objects */
 221 static CORE_ADDR debug_base;            /* Base of dynamic linker structures */
 222 static CORE_ADDR breakpoint_addr;       /* Address where end bkpt is set */
 223
 224 /* Local function prototypes */
 225
 226 static void
 227 sharedlibrary_command PARAMS ((char *, int));
 228
 229 static int
 230 enable_break PARAMS ((void));
 231
 232 static int
 233 disable_break PARAMS ((void));
 234
 235 static void
 236 info_sharedlibrary_command PARAMS ((char *, int));
 237
 238 static int
 239 symbol_add_stub PARAMS ((char *));
 240
 241 static struct so_list *
 242 find_solib PARAMS ((struct so_list *));
 243
 244 static struct obj_list *
 245 first_link_map_member PARAMS ((void));
 246
 247 static CORE_ADDR
 248 locate_base PARAMS ((void));
 249
 250 static void
 251 solib_map_sections PARAMS ((struct so_list *));
 252
 253 /*
 254
 255 LOCAL FUNCTION
 256
 257         solib_map_sections -- open bfd and build sections for shared lib
 258
 259 SYNOPSIS
 260
 261         static void solib_map_sections (struct so_list *so)
 262
 263 DESCRIPTION
 264
 265         Given a pointer to one of the shared objects in our list
 266         of mapped objects, use the recorded name to open a bfd
 267         descriptor for the object, build a section table, and then
 268         relocate all the section addresses by the base address at
 269         which the shared object was mapped.
 270
 271 FIXMES
 272
 273         In most (all?) cases the shared object file name recorded in the
 274         dynamic linkage tables will be a fully qualified pathname.  For
 275         cases where it isn't, do we really mimic the systems search
 276         mechanism correctly in the below code (particularly the tilde
 277         expansion stuff?).
 278  */
 279
 280 static void
 281 solib_map_sections (so)
 282      struct so_list *so;
 283 {
 284   char *filename;
 285   char *scratch_pathname;
 286   int scratch_chan;
 287   struct section_table *p;
 288   struct cleanup *old_chain;
 289   bfd *abfd;
 290   CORE_ADDR offset;
 291
 292   filename = tilde_expand (so -> lm.o_path);
 293   old_chain = make_cleanup (free, filename);
 294
 295   scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
 296                         &scratch_pathname);
 297   if (scratch_chan < 0)
 298     {
 299       scratch_chan = openp (getenv ("LD_LIBRARY_PATH"), 1, filename,
 300                             O_RDONLY, 0, &scratch_pathname);
 301     }
 302   if (scratch_chan < 0)
 303     {
 304       perror_with_name (filename);
 305     }
 306   /* Leave scratch_pathname allocated.  abfd->name will point to it.  */
 307
 308   abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
 309   if (!abfd)
 310     {
 311       close (scratch_chan);
 312       error ("Could not open `%s' as an executable file: %s",
 313              scratch_pathname, bfd_errmsg (bfd_get_error ()));
 314     }
 315   /* Leave bfd open, core_xfer_memory and "info files" need it.  */
 316   so -> abfd = abfd;
 317   abfd -> cacheable = true;
 318
 319   if (!bfd_check_format (abfd, bfd_object))
 320     {
 321       error ("\"%s\": not in executable format: %s.",
 322              scratch_pathname, bfd_errmsg (bfd_get_error ()));
 323     }
 324   if (build_section_table (abfd, &so -> sections, &so -> sections_end))
 325     {
 326       error ("Can't find the file sections in `%s': %s",
 327              bfd_get_filename (exec_bfd), bfd_errmsg (bfd_get_error ()));
 328     }
 329
 330   /* Irix 5 shared objects are pre-linked to particular addresses
 331      although the dynamic linker may have to relocate them if the
 332      address ranges of the libraries used by the main program clash.
 333      The offset is the difference between the address where the object
 334      is mapped and the binding address of the shared library.  */
 335   offset = (CORE_ADDR) LM_ADDR (so) - so -> lm.o_base_address;
 336
 337   for (p = so -> sections; p < so -> sections_end; p++)
 338     {
 339       /* Relocate the section binding addresses as recorded in the shared
 340          object's file by the offset to get the address to which the
 341          object was actually mapped.  */
 342       p -> addr += offset;
 343       p -> endaddr += offset;
 344       so -> lmend = (CORE_ADDR) max (p -> endaddr, so -> lmend);
 345       if (STREQ (p -> the_bfd_section -> name, ".text"))
 346         {
 347           so -> textsection = p;
 348         }
 349     }
 350
 351   /* Free the file names, close the file now.  */
 352   do_cleanups (old_chain);
 353 }
 354
 355 /*
 356
 357 LOCAL FUNCTION
 358
 359         locate_base -- locate the base address of dynamic linker structs
 360
 361 SYNOPSIS
 362
 363         CORE_ADDR locate_base (void)
 364
 365 DESCRIPTION
 366
 367         For both the SunOS and SVR4 shared library implementations, if the
 368         inferior executable has been linked dynamically, there is a single
 369         address somewhere in the inferior's data space which is the key to
 370         locating all of the dynamic linker's runtime structures.  This
 371         address is the value of the symbol defined by the macro DEBUG_BASE.
 372         The job of this function is to find and return that address, or to
 373         return 0 if there is no such address (the executable is statically
 374         linked for example).
 375
 376         For SunOS, the job is almost trivial, since the dynamic linker and
 377         all of it's structures are statically linked to the executable at
 378         link time.  Thus the symbol for the address we are looking for has
 379         already been added to the minimal symbol table for the executable's
 380         objfile at the time the symbol file's symbols were read, and all we
 381         have to do is look it up there.  Note that we explicitly do NOT want
 382         to find the copies in the shared library.
 383
 384         The SVR4 version is much more complicated because the dynamic linker
 385         and it's structures are located in the shared C library, which gets
 386         run as the executable's "interpreter" by the kernel.  We have to go
 387         to a lot more work to discover the address of DEBUG_BASE.  Because
 388         of this complexity, we cache the value we find and return that value
 389         on subsequent invocations.  Note there is no copy in the executable
 390         symbol tables.
 391
 392         Irix 5 is basically like SunOS.
 393
 394         Note that we can assume nothing about the process state at the time
 395         we need to find this address.  We may be stopped on the first instruc-
 396         tion of the interpreter (C shared library), the first instruction of
 397         the executable itself, or somewhere else entirely (if we attached
 398         to the process for example).
 399
 400  */
 401
 402 static CORE_ADDR
 403 locate_base ()
 404 {
 405   struct minimal_symbol *msymbol;
 406   CORE_ADDR address = 0;
 407
 408   msymbol = lookup_minimal_symbol (DEBUG_BASE, NULL, symfile_objfile);
 409   if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
 410     {
 411       address = SYMBOL_VALUE_ADDRESS (msymbol);
 412     }
 413   return (address);
 414 }
 415
 416 /*
 417
 418 LOCAL FUNCTION
 419
 420         first_link_map_member -- locate first member in dynamic linker's map
 421
 422 SYNOPSIS
 423
 424         static struct link_map *first_link_map_member (void)
 425
 426 DESCRIPTION
 427
 428         Read in a copy of the first member in the inferior's dynamic
 429         link map from the inferior's dynamic linker structures, and return
 430         a pointer to the copy in our address space.
 431 */
 432
 433 static struct obj_list *
 434 first_link_map_member ()
 435 {
 436   struct obj_list *lm;
 437   struct obj_list s;
 438
 439   read_memory (debug_base, (char *) &lm, sizeof (struct obj_list *));
 440
 441   if (lm == NULL)
 442     return NULL;
 443
 444   /* The first entry in the list is the object file we are debugging,
 445      so skip it.  */
 446   read_memory ((CORE_ADDR) lm, (char *) &s, sizeof (struct obj_list));
 447
 448   return s.next;
 449 }
 450
 451 /*
 452
 453 LOCAL FUNCTION
 454
 455         find_solib -- step through list of shared objects
 456
 457 SYNOPSIS
 458
 459         struct so_list *find_solib (struct so_list *so_list_ptr)
 460
 461 DESCRIPTION
 462
 463         This module contains the routine which finds the names of any
 464         loaded "images" in the current process. The argument in must be
 465         NULL on the first call, and then the returned value must be passed
 466         in on subsequent calls. This provides the capability to "step" down
 467         the list of loaded objects. On the last object, a NULL value is
 468         returned.
 469  */
 470
 471 static struct so_list *
 472 find_solib (so_list_ptr)
 473      struct so_list *so_list_ptr;       /* Last lm or NULL for first one */
 474 {
 475   struct so_list *so_list_next = NULL;
 476   struct obj_list *lm = NULL;
 477   struct so_list *new;
 478
 479   if (so_list_ptr == NULL)
 480     {
 481       /* We are setting up for a new scan through the loaded images. */
 482       if ((so_list_next = so_list_head) == NULL)
 483         {
 484           /* We have not already read in the dynamic linking structures
 485              from the inferior, lookup the address of the base structure. */
 486           debug_base = locate_base ();
 487           if (debug_base != 0)
 488             {
 489               /* Read the base structure in and find the address of the first
 490                  link map list member. */
 491               lm = first_link_map_member ();
 492             }
 493         }
 494     }
 495   else
 496     {
 497       /* We have been called before, and are in the process of walking
 498          the shared library list.  Advance to the next shared object. */
 499       if ((lm = so_list_ptr->ll.next) == NULL)
 500         {
 501           /* We have hit the end of the list, so check to see if any were
 502              added, but be quiet if we can't read from the target any more. */
 503           int status = target_read_memory ((CORE_ADDR) so_list_ptr -> lladdr,
 504                                            (char *) &(so_list_ptr -> ll),
 505                                            sizeof (struct obj_list));
 506           if (status == 0)
 507             {
 508               lm = so_list_ptr->ll.next;
 509             }
 510           else
 511             {
 512               lm = NULL;
 513             }
 514         }
 515       so_list_next = so_list_ptr -> next;
 516     }
 517   if ((so_list_next == NULL) && (lm != NULL))
 518     {
 519       int errcode;
 520       char *buffer;
 521
 522       /* Get next link map structure from inferior image and build a local
 523          abbreviated load_map structure */
 524       new = (struct so_list *) xmalloc (sizeof (struct so_list));
 525       memset ((char *) new, 0, sizeof (struct so_list));
 526       new -> lladdr = lm;
 527       /* Add the new node as the next node in the list, or as the root
 528          node if this is the first one. */
 529       if (so_list_ptr != NULL)
 530         {
 531           so_list_ptr -> next = new;
 532         }
 533       else
 534         {
 535           so_list_head = new;
 536         }
 537       so_list_next = new;
 538       read_memory ((CORE_ADDR) lm, (char *) &(new -> ll),
 539                    sizeof (struct obj_list));
 540       read_memory ((CORE_ADDR) new->ll.data, (char *) &(new -> lm),
 541                    sizeof (struct obj));
 542       target_read_string ((CORE_ADDR)new->lm.o_path, &buffer,
 543                           INT_MAX, &errcode);
 544       if (errcode != 0)
 545         memory_error (errcode, (CORE_ADDR)new->lm.o_path);
 546       new->lm.o_path = buffer;
 547       solib_map_sections (new);
 548     }
 549   return (so_list_next);
 550 }
 551
 552 /* A small stub to get us past the arg-passing pinhole of catch_errors.  */
 553
 554 static int
 555 symbol_add_stub (arg)
 556      char *arg;
 557 {
 558   register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
 559
 560   so -> objfile = symbol_file_add (so -> lm.o_path, so -> from_tty,
 561                                    (unsigned int) so -> textsection -> addr,
 562                                    0, 0, 0);
 563   return (1);
 564 }
 565
 566 /*
 567
 568 GLOBAL FUNCTION
 569
 570         solib_add -- add a shared library file to the symtab and section list
 571
 572 SYNOPSIS
 573
 574         void solib_add (char *arg_string, int from_tty,
 575                         struct target_ops *target)
 576
 577 DESCRIPTION
 578
 579 */
 580
 581 void
 582 solib_add (arg_string, from_tty, target)
 583      char *arg_string;
 584      int from_tty;
 585      struct target_ops *target;
 586 {
 587   register struct so_list *so = NULL;           /* link map state variable */
 588
 589   /* Last shared library that we read.  */
 590   struct so_list *so_last = NULL;
 591
 592   char *re_err;
 593   int count;
 594   int old;
 595
 596   if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
 597     {
 598       error ("Invalid regexp: %s", re_err);
 599     }
 600
 601   /* Add the shared library sections to the section table of the
 602      specified target, if any.  */
 603   if (target)
 604     {
 605       /* Count how many new section_table entries there are.  */
 606       so = NULL;
 607       count = 0;
 608       while ((so = find_solib (so)) != NULL)
 609         {
 610           if (so -> lm.o_path[0])
 611             {
 612               count += so -> sections_end - so -> sections;
 613             }
 614         }
 615
 616       if (count)
 617         {
 618           /* Reallocate the target's section table including the new size.  */
 619           if (target -> to_sections)
 620             {
 621               old = target -> to_sections_end - target -> to_sections;
 622               target -> to_sections = (struct section_table *)
 623                 xrealloc ((char *)target -> to_sections,
 624                          (sizeof (struct section_table)) * (count + old));
 625             }
 626           else
 627             {
 628               old = 0;
 629               target -> to_sections = (struct section_table *)
 630                 xmalloc ((sizeof (struct section_table)) * count);
 631             }
 632           target -> to_sections_end = target -> to_sections + (count + old);
 633
 634           /* Add these section table entries to the target's table.  */
 635           while ((so = find_solib (so)) != NULL)
 636             {
 637               if (so -> lm.o_path[0])
 638                 {
 639                   count = so -> sections_end - so -> sections;
 640                   memcpy ((char *) (target -> to_sections + old),
 641                           so -> sections,
 642                           (sizeof (struct section_table)) * count);
 643                   old += count;
 644                 }
 645             }
 646         }
 647     }
 648
 649   /* Now add the symbol files.  */
 650   while ((so = find_solib (so)) != NULL)
 651     {
 652       if (so -> lm.o_path[0] && re_exec (so -> lm.o_path))
 653         {
 654           so -> from_tty = from_tty;
 655           if (so -> symbols_loaded)
 656             {
 657               if (from_tty)
 658                 {
 659                   printf_unfiltered ("Symbols already loaded for %s\n", so -> lm.o_path);
 660                 }
 661             }
 662           else if (catch_errors
 663                    (symbol_add_stub, (char *) so,
 664                     "Error while reading shared library symbols:\n",
 665                     RETURN_MASK_ALL))
 666             {
 667               so_last = so;
 668               so -> symbols_loaded = 1;
 669             }
 670         }
 671     }
 672
 673   /* Getting new symbols may change our opinion about what is
 674      frameless.  */
 675   if (so_last)
 676     reinit_frame_cache ();
 677 }
 678
 679 /*
 680
 681 LOCAL FUNCTION
 682
 683         info_sharedlibrary_command -- code for "info sharedlibrary"
 684
 685 SYNOPSIS
 686
 687         static void info_sharedlibrary_command ()
 688
 689 DESCRIPTION
 690
 691         Walk through the shared library list and print information
 692         about each attached library.
 693 */
 694
 695 static void
 696 info_sharedlibrary_command (ignore, from_tty)
 697      char *ignore;
 698      int from_tty;
 699 {
 700   register struct so_list *so = NULL;   /* link map state variable */
 701   int header_done = 0;
 702
 703   if (exec_bfd == NULL)
 704     {
 705       printf_unfiltered ("No exec file.\n");
 706       return;
 707     }
 708   while ((so = find_solib (so)) != NULL)
 709     {
 710       if (so -> lm.o_path[0])
 711         {
 712           if (!header_done)
 713             {
 714               printf_unfiltered("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read",
 715                      "Shared Object Library");
 716               header_done++;
 717             }
 718           printf_unfiltered ("%-12s",
 719                   local_hex_string_custom ((unsigned long) LM_ADDR (so),
 720                                            "08l"));
 721           printf_unfiltered ("%-12s",
 722                   local_hex_string_custom ((unsigned long) so -> lmend,
 723                                            "08l"));
 724           printf_unfiltered ("%-12s", so -> symbols_loaded ? "Yes" : "No");
 725           printf_unfiltered ("%s\n",  so -> lm.o_path);
 726         }
 727     }
 728   if (so_list_head == NULL)
 729     {
 730       printf_unfiltered ("No shared libraries loaded at this time.\n");
 731     }
 732 }
 733
 734 /*
 735
 736 GLOBAL FUNCTION
 737
 738         solib_address -- check to see if an address is in a shared lib
 739
 740 SYNOPSIS
 741
 742         int solib_address (CORE_ADDR address)
 743
 744 DESCRIPTION
 745
 746         Provides a hook for other gdb routines to discover whether or
 747         not a particular address is within the mapped address space of
 748         a shared library.  Any address between the base mapping address
 749         and the first address beyond the end of the last mapping, is
 750         considered to be within the shared library address space, for
 751         our purposes.
 752
 753         For example, this routine is called at one point to disable
 754         breakpoints which are in shared libraries that are not currently
 755         mapped in.
 756  */
 757
 758 int
 759 solib_address (address)
 760      CORE_ADDR address;
 761 {
 762   register struct so_list *so = 0;      /* link map state variable */
 763
 764   while ((so = find_solib (so)) != NULL)
 765     {
 766       if (so -> lm.o_path[0])
 767         {
 768           if ((address >= (CORE_ADDR) LM_ADDR (so)) &&
 769               (address < (CORE_ADDR) so -> lmend))
 770             {
 771               return (1);
 772             }
 773         }
 774     }
 775   return (0);
 776 }
 777
 778 /* Called by free_all_symtabs */
 779
 780 void
 781 clear_solib()
 782 {
 783   struct so_list *next;
 784   char *bfd_filename;
 785
 786   while (so_list_head)
 787     {
 788       if (so_list_head -> sections)
 789         {
 790           free ((PTR)so_list_head -> sections);
 791         }
 792       if (so_list_head -> abfd)
 793         {
 794           bfd_filename = bfd_get_filename (so_list_head -> abfd);
 795           if (!bfd_close (so_list_head -> abfd))
 796             warning ("cannot close \"%s\": %s",
 797                      bfd_filename, bfd_errmsg (bfd_get_error ()));
 798         }
 799       else
 800         /* This happens for the executable on SVR4.  */
 801         bfd_filename = NULL;
 802
 803       next = so_list_head -> next;
 804       if (bfd_filename)
 805         free ((PTR)bfd_filename);
 806       free (so_list_head->lm.o_path);
 807       free ((PTR)so_list_head);
 808       so_list_head = next;
 809     }
 810   debug_base = 0;
 811 }
 812
 813 /*
 814
 815 LOCAL FUNCTION
 816
 817         disable_break -- remove the "mapping changed" breakpoint
 818
 819 SYNOPSIS
 820
 821         static int disable_break ()
 822
 823 DESCRIPTION
 824
 825         Removes the breakpoint that gets hit when the dynamic linker
 826         completes a mapping change.
 827
 828 */
 829
 830 static int
 831 disable_break ()
 832 {
 833   int status = 1;
 834
 835
 836   /* Note that breakpoint address and original contents are in our address
 837      space, so we just need to write the original contents back. */
 838
 839   if (memory_remove_breakpoint (breakpoint_addr, shadow_contents) != 0)
 840     {
 841       status = 0;
 842     }
 843
 844   /* For the SVR4 version, we always know the breakpoint address.  For the
 845      SunOS version we don't know it until the above code is executed.
 846      Grumble if we are stopped anywhere besides the breakpoint address. */
 847
 848   if (stop_pc != breakpoint_addr)
 849     {
 850       warning ("stopped at unknown breakpoint while handling shared libraries");
 851     }
 852
 853   return (status);
 854 }
 855
 856 /*
 857
 858 LOCAL FUNCTION
 859
 860         enable_break -- arrange for dynamic linker to hit breakpoint
 861
 862 SYNOPSIS
 863
 864         int enable_break (void)
 865
 866 DESCRIPTION
 867
 868         This functions inserts a breakpoint at the entry point of the
 869         main executable, where all shared libraries are mapped in.
 870 */
 871
 872 static int
 873 enable_break ()
 874 {
 875   if (symfile_objfile != NULL
 876       && target_insert_breakpoint (symfile_objfile->ei.entry_point,
 877                                    shadow_contents) == 0)
 878     {
 879       breakpoint_addr = symfile_objfile->ei.entry_point;
 880       return 1;
 881     }
 882
 883   return 0;
 884 }
 885
 886 /*
 887
 888 GLOBAL FUNCTION
 889
 890         solib_create_inferior_hook -- shared library startup support
 891
 892 SYNOPSIS
 893
 894         void solib_create_inferior_hook()
 895
 896 DESCRIPTION
 897
 898         When gdb starts up the inferior, it nurses it along (through the
 899         shell) until it is ready to execute it's first instruction.  At this
 900         point, this function gets called via expansion of the macro
 901         SOLIB_CREATE_INFERIOR_HOOK.
 902
 903         For SunOS executables, this first instruction is typically the
 904         one at "_start", or a similar text label, regardless of whether
 905         the executable is statically or dynamically linked.  The runtime
 906         startup code takes care of dynamically linking in any shared
 907         libraries, once gdb allows the inferior to continue.
 908
 909         For SVR4 executables, this first instruction is either the first
 910         instruction in the dynamic linker (for dynamically linked
 911         executables) or the instruction at "start" for statically linked
 912         executables.  For dynamically linked executables, the system
 913         first exec's /lib/libc.so.N, which contains the dynamic linker,
 914         and starts it running.  The dynamic linker maps in any needed
 915         shared libraries, maps in the actual user executable, and then
 916         jumps to "start" in the user executable.
 917
 918         For both SunOS shared libraries, and SVR4 shared libraries, we
 919         can arrange to cooperate with the dynamic linker to discover the
 920         names of shared libraries that are dynamically linked, and the
 921         base addresses to which they are linked.
 922
 923         This function is responsible for discovering those names and
 924         addresses, and saving sufficient information about them to allow
 925         their symbols to be read at a later time.
 926
 927 FIXME
 928
 929         Between enable_break() and disable_break(), this code does not
 930         properly handle hitting breakpoints which the user might have
 931         set in the startup code or in the dynamic linker itself.  Proper
 932         handling will probably have to wait until the implementation is
 933         changed to use the "breakpoint handler function" method.
 934
 935         Also, what if child has exit()ed?  Must exit loop somehow.
 936   */
 937
 938 void
 939 solib_create_inferior_hook()
 940 {
 941   if (!enable_break ())
 942     {
 943       warning ("shared library handler failed to enable breakpoint");
 944       return;
 945     }
 946
 947   /* Now run the target.  It will eventually hit the breakpoint, at
 948      which point all of the libraries will have been mapped in and we
 949      can go groveling around in the dynamic linker structures to find
 950      out what we need to know about them. */
 951
 952   clear_proceed_status ();
 953   stop_soon_quietly = 1;
 954   stop_signal = 0;
 955   do
 956     {
 957       target_resume (-1, 0, stop_signal);
 958       wait_for_inferior ();
 959     }
 960   while (stop_signal != SIGTRAP);
 961
 962   /* We are now either at the "mapping complete" breakpoint (or somewhere
 963      else, a condition we aren't prepared to deal with anyway), so adjust
 964      the PC as necessary after a breakpoint, disable the breakpoint, and
 965      add any shared libraries that were mapped in. */
 966
 967   if (DECR_PC_AFTER_BREAK)
 968     {
 969       stop_pc -= DECR_PC_AFTER_BREAK;
 970       write_register (PC_REGNUM, stop_pc);
 971     }
 972
 973   if (!disable_break ())
 974     {
 975       warning ("shared library handler failed to disable breakpoint");
 976     }
 977
 978   /*  solib_add will call reinit_frame_cache.
 979       But we are stopped in the startup code and we might not have symbols
 980       for the startup code, so heuristic_proc_start could be called
 981       and will put out an annoying warning.
 982       Delaying the resetting of stop_soon_quietly until after symbol loading
 983       suppresses the warning.  */
 984   solib_add ((char *) 0, 0, (struct target_ops *) 0);
 985   stop_soon_quietly = 0;
 986 }
 987
 988 /*
 989
 990 LOCAL FUNCTION
 991
 992         sharedlibrary_command -- handle command to explicitly add library
 993
 994 SYNOPSIS
 995
 996         static void sharedlibrary_command (char *args, int from_tty)
 997
 998 DESCRIPTION
 999
1000 */
1001
1002 static void
1003 sharedlibrary_command (args, from_tty)
1004 char *args;
1005 int from_tty;
1006 {
1007   dont_repeat ();
1008   solib_add (args, from_tty, (struct target_ops *) 0);
1009 }
1010
1011 void
1012 _initialize_solib()
1013 {
1014
1015   add_com ("sharedlibrary", class_files, sharedlibrary_command,
1016            "Load shared object library symbols for files matching REGEXP.");
1017   add_info ("sharedlibrary", info_sharedlibrary_command,
1018             "Status of loaded shared object libraries.");
1019 }