2005-02-18 Andrew Cagney <cagney@gnu.org>
[external/binutils.git] / gdb / somsolib.c
1 /* Handle HP SOM shared libraries for GDB, the GNU Debugger.
2
3    Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
4    2003, 2004 Free Software Foundation, Inc.
5
6    This file is part of GDB.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 59 Temple Place - Suite 330,
21    Boston, MA 02111-1307, USA.
22
23    Written by the Center for Software Science at the Univerity of Utah
24    and by Cygnus Support.  */
25
26
27 #include "defs.h"
28
29 #include "frame.h"
30 #include "bfd.h"
31 #include "som.h"
32 #include "libhppa.h"
33 #include "gdbcore.h"
34 #include "symtab.h"
35 #include "breakpoint.h"
36 #include "symfile.h"
37 #include "objfiles.h"
38 #include "inferior.h"
39 #include "gdb-stabs.h"
40 #include "gdb_stat.h"
41 #include "gdbcmd.h"
42 #include "language.h"
43 #include "regcache.h"
44 #include "gdb_assert.h"
45 #include "exec.h"
46 #include "hppa-tdep.h"
47
48 #include <fcntl.h>
49
50 #ifndef O_BINARY
51 #define O_BINARY 0
52 #endif
53
54 #ifndef SHL_LOAD
55 #define SHL_LOAD        4
56 #endif
57
58 #ifndef SHL_UNLOAD
59 #define SHL_UNLOAD      8
60 #endif
61
62 /* Uncomment this to turn on some debugging output.
63  */
64
65 /* #define SOLIB_DEBUG
66  */
67
68 /* This lives in hppa-tdep.c. */
69 extern struct unwind_table_entry *find_unwind_entry (CORE_ADDR pc);
70
71 /* These ought to be defined in some public interface, but aren't.  They
72    define the meaning of the various bits in the distinguished __dld_flags
73    variable that is declared in every debuggable a.out on HP-UX, and that
74    is shared between the debugger and the dynamic linker.
75  */
76 #define DLD_FLAGS_MAPPRIVATE    0x1
77 #define DLD_FLAGS_HOOKVALID     0x2
78 #define DLD_FLAGS_LISTVALID     0x4
79 #define DLD_FLAGS_BOR_ENABLE    0x8
80
81 /* TODO:
82
83    * Support for hpux8 dynamic linker.  */
84
85 /* The basic structure which describes a dynamically loaded object.  This
86    data structure is private to the dynamic linker and isn't found in
87    any HPUX include file.  */
88
89 struct som_solib_mapped_entry
90   {
91     /* The name of the library.  */
92     char *name;
93
94     /* Version of this structure (it is expected to change again in hpux10).  */
95     unsigned char struct_version;
96
97     /* Binding mode for this library.  */
98     unsigned char bind_mode;
99
100     /* Version of this library.  */
101     short library_version;
102
103     /* Start of text address,
104      * link-time text location (length of text area),
105      * end of text address.  */
106     CORE_ADDR text_addr;
107     CORE_ADDR text_link_addr;
108     CORE_ADDR text_end;
109
110     /* Start of data, start of bss and end of data.  */
111     CORE_ADDR data_start;
112     CORE_ADDR bss_start;
113     CORE_ADDR data_end;
114
115     /* Value of linkage pointer (%r19).  */
116     CORE_ADDR got_value;
117
118     /* Next entry.  */
119     struct som_solib_mapped_entry *next;
120
121     /* There are other fields, but I don't have information as to what is
122        contained in them.  */
123
124     /* For versions from HPUX-10.30 and up */
125
126     /* Address in target of offset from thread-local register of
127      * start of this thread's data.  I.e., the first thread-local
128      * variable in this shared library starts at *(tsd_start_addr)
129      * from that area pointed to by cr27 (mpsfu_hi).
130      *
131      * We do the indirection as soon as we read it, so from then
132      * on it's the offset itself.
133      */
134     CORE_ADDR tsd_start_addr;
135
136     /* Following this are longwords holding:
137
138      * ?, ?, ?, ptr to -1, ptr to-1, ptr to lib name (leaf name),
139      * ptr to __data_start, ptr to __data_end
140      */
141
142
143   };
144
145 /* A structure to keep track of all the known shared objects.  */
146 struct so_list
147   {
148     struct som_solib_mapped_entry som_solib;
149     struct objfile *objfile;
150     bfd *abfd;
151     struct section_table *sections;
152     struct section_table *sections_end;
153 /* elz: added this field to store the address in target space (in the
154    library) of the library descriptor (handle) which we read into
155    som_solib_mapped_entry structure */
156     CORE_ADDR solib_addr;
157     struct so_list *next;
158
159   };
160
161 static struct so_list *so_list_head;
162
163
164 /* This is the cumulative size in bytes of the symbol tables of all
165    shared objects on the so_list_head list.  (When we say size, here
166    we mean of the information before it is brought into memory and
167    potentially expanded by GDB.)  When adding a new shlib, this value
168    is compared against the threshold size, held by auto_solib_limit
169    (in megabytes).  If adding symbols for the new shlib would cause
170    the total size to exceed the threshold, then the new shlib's
171    symbols are not loaded.  */
172 static LONGEST som_solib_total_st_size;
173
174 /* When the threshold is reached for any shlib, we refuse to add
175    symbols for subsequent shlibs, even if those shlibs' symbols would
176    be small enough to fit under the threshold.  (Although this may
177    result in one, early large shlib preventing the loading of later,
178    smalller shlibs' symbols, it allows us to issue one informational
179    message.  The alternative, to issue a message for each shlib whose
180    symbols aren't loaded, could be a big annoyance where the threshold
181    is exceeded due to a very large number of shlibs.)
182  */
183 static int som_solib_st_size_threshold_exceeded;
184
185 /* These addresses should be filled in by som_solib_create_inferior_hook.
186    They are also used elsewhere in this module.
187  */
188 typedef struct
189   {
190     CORE_ADDR address;
191     struct unwind_table_entry *unwind;
192   }
193 addr_and_unwind_t;
194
195 /* When adding fields, be sure to clear them in _initialize_som_solib. */
196 static struct
197   {
198     int is_valid;
199     addr_and_unwind_t hook;
200     addr_and_unwind_t hook_stub;
201     addr_and_unwind_t load;
202     addr_and_unwind_t load_stub;
203     addr_and_unwind_t unload;
204     addr_and_unwind_t unload2;
205     addr_and_unwind_t unload_stub;
206   }
207 dld_cache;
208
209
210
211 static void som_sharedlibrary_info_command (char *, int);
212
213 static void som_solib_sharedlibrary_command (char *, int);
214
215 static LONGEST
216 som_solib_sizeof_symbol_table (char *filename)
217 {
218   bfd *abfd;
219   int desc;
220   char *absolute_name;
221   LONGEST st_size = (LONGEST) 0;
222   asection *sect;
223
224   /* We believe that filename was handed to us by the dynamic linker, and
225      is therefore always an absolute path.
226    */
227   desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename,
228                 O_RDONLY | O_BINARY, 0, &absolute_name);
229   if (desc < 0)
230     {
231       perror_with_name (filename);
232     }
233   filename = absolute_name;
234
235   abfd = bfd_fdopenr (filename, gnutarget, desc);
236   if (!abfd)
237     {
238       close (desc);
239       make_cleanup (xfree, filename);
240       error (_("\"%s\": can't open to read symbols: %s."), filename,
241              bfd_errmsg (bfd_get_error ()));
242     }
243
244   if (!bfd_check_format (abfd, bfd_object))     /* Reads in section info */
245     {
246       bfd_close (abfd);         /* This also closes desc */
247       make_cleanup (xfree, filename);
248       error (_("\"%s\": can't read symbols: %s."), filename,
249              bfd_errmsg (bfd_get_error ()));
250     }
251
252   /* Sum the sizes of the various sections that compose debug info. */
253
254   /* This contains non-DOC information. */
255   sect = bfd_get_section_by_name (abfd, "$DEBUG$");
256   if (sect)
257     st_size += (LONGEST) bfd_section_size (abfd, sect);
258
259   /* This contains DOC information. */
260   sect = bfd_get_section_by_name (abfd, "$PINFO$");
261   if (sect)
262     st_size += (LONGEST) bfd_section_size (abfd, sect);
263
264   bfd_close (abfd);             /* This also closes desc */
265   xfree (filename);
266
267   /* Unfortunately, just summing the sizes of various debug info
268      sections isn't a very accurate measurement of how much heap
269      space the debugger will need to hold them.  It also doesn't
270      account for space needed by linker (aka "minimal") symbols.
271
272      Anecdotal evidence suggests that just summing the sizes of
273      debug-info-related sections understates the heap space needed
274      to represent it internally by about an order of magnitude.
275
276      Since it's not exactly brain surgery we're doing here, rather
277      than attempt to more accurately measure the size of a shlib's
278      symbol table in GDB's heap, we'll just apply a 10x fudge-
279      factor to the debug info sections' size-sum.  No, this doesn't
280      account for minimal symbols in non-debuggable shlibs.  But it
281      all roughly washes out in the end.
282    */
283   return st_size * (LONGEST) 10;
284 }
285
286
287 static void
288 som_solib_add_solib_objfile (struct so_list *so, char *name, int from_tty,
289                              CORE_ADDR text_addr)
290 {
291   struct hppa_objfile_private *obj_private;
292   struct obj_section *s;
293
294   so->objfile = symbol_file_add (name, from_tty, NULL, 0, OBJF_SHARED);
295   so->abfd = so->objfile->obfd;
296
297   /* syms_from_objfile has bizarre section offset code,
298      so I do my own right here.  */
299   for (s = so->objfile->sections; s < so->objfile->sections_end; s++)
300     {
301       flagword aflag = bfd_get_section_flags(so->abfd, s->the_bfd_section);
302       if (aflag & SEC_CODE)
303         {
304           s->addr    += so->som_solib.text_addr - so->som_solib.text_link_addr;
305           s->endaddr += so->som_solib.text_addr - so->som_solib.text_link_addr;
306         }
307       else if (aflag & SEC_DATA)
308         {
309           s->addr    += so->som_solib.data_start;
310           s->endaddr += so->som_solib.data_start;
311         }
312       else
313         ;
314     }
315    
316   /* Mark this as a shared library and save private data.
317    */
318   so->objfile->flags |= OBJF_SHARED;
319
320   obj_private = (struct hppa_objfile_private *)
321                 objfile_data (so->objfile, hppa_objfile_priv_data);
322   if (obj_private == NULL)
323     {
324       obj_private = (struct hppa_objfile_private *)
325         obstack_alloc (&so->objfile->objfile_obstack,
326                        sizeof (struct hppa_objfile_private));
327       set_objfile_data (so->objfile, hppa_objfile_priv_data, obj_private);
328       obj_private->unwind_info = NULL;
329       obj_private->so_info = NULL;
330     }
331
332   obj_private->so_info = so;
333
334   if (!bfd_check_format (so->abfd, bfd_object))
335     {
336       error (_("\"%s\": not in executable format: %s."),
337              name, bfd_errmsg (bfd_get_error ()));
338     }
339 }
340
341
342 static void
343 som_solib_load_symbols (struct so_list *so, char *name, int from_tty,
344                         CORE_ADDR text_addr, struct target_ops *target)
345 {
346   struct section_table *p;
347   int status;
348   char buf[4];
349   CORE_ADDR presumed_data_start;
350
351 #ifdef SOLIB_DEBUG
352   printf ("--Adding symbols for shared library \"%s\"\n", name);
353 #endif
354
355   som_solib_add_solib_objfile (so, name, from_tty, text_addr);
356
357   /* Now we need to build a section table for this library since
358      we might be debugging a core file from a dynamically linked
359      executable in which the libraries were not privately mapped.  */
360   if (build_section_table (so->abfd,
361                            &so->sections,
362                            &so->sections_end))
363     {
364       error (_("Unable to build section table for shared library\n."));
365       return;
366     }
367
368   /* Relocate all the sections based on where they got loaded.  */
369   for (p = so->sections; p < so->sections_end; p++)
370     {
371       if (p->the_bfd_section->flags & SEC_CODE)
372         {
373           p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT (so->objfile));
374           p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT (so->objfile));
375         }
376       else if (p->the_bfd_section->flags & SEC_DATA)
377         {
378           p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA (so->objfile));
379           p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA (so->objfile));
380         }
381     }
382
383   /* Now see if we need to map in the text and data for this shared
384      library (for example debugging a core file which does not use
385      private shared libraries.). 
386
387      Carefully peek at the first text address in the library.  If the
388      read succeeds, then the libraries were privately mapped and were
389      included in the core dump file.
390
391      If the peek failed, then the libraries were not privately mapped
392      and are not in the core file, we'll have to read them in ourselves.  */
393   status = target_read_memory (text_addr, buf, 4);
394   if (status != 0)
395     {
396       int old, new;
397
398       new = so->sections_end - so->sections;
399       
400       old = target_resize_to_sections (target, new);
401       
402       /* Copy over the old data before it gets clobbered.  */
403       memcpy ((char *) (target->to_sections + old),
404               so->sections,
405               ((sizeof (struct section_table)) * new));
406     }
407 }
408
409
410 /* FIXME: cagney/2003-02-01: This just isn't right.  Given an address
411    within the target's address space, this converts the value into an
412    address within the host's (i.e., GDB's) address space.  Given that
413    the host/target address spaces are separate, this can't be right.  */
414
415 static void *
416 hpux_address_to_host_pointer_hack (CORE_ADDR addr)
417 {
418   void *ptr;
419
420   gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr));
421   ADDRESS_TO_POINTER (builtin_type_void_data_ptr, &ptr, addr);
422   return ptr;
423 }
424
425 /* Add symbols from shared libraries into the symtab list, unless the
426    size threshold specified by auto_solib_limit (in megabytes) would
427    be exceeded.  */
428
429 void
430 som_solib_add (char *arg_string, int from_tty, struct target_ops *target, int readsyms)
431 {
432   struct minimal_symbol *msymbol;
433   struct so_list *so_list_tail;
434   CORE_ADDR addr;
435   asection *shlib_info;
436   int status;
437   unsigned int dld_flags;
438   char buf[4], *re_err;
439   int threshold_warning_given = 0;
440
441   /* First validate our arguments.  */
442   re_err = re_comp (arg_string ? arg_string : ".");
443   if (re_err != NULL)
444     {
445       error (_("Invalid regexp: %s"), re_err);
446     }
447
448   /* If we're debugging a core file, or have attached to a running
449      process, then som_solib_create_inferior_hook will not have been
450      called.
451
452      We need to first determine if we're dealing with a dynamically
453      linked executable.  If not, then return without an error or warning.
454
455      We also need to examine __dld_flags to determine if the shared library
456      list is valid and to determine if the libraries have been privately
457      mapped.  */
458   if (symfile_objfile == NULL)
459     return;
460
461   /* First see if the objfile was dynamically linked.  */
462   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
463   if (!shlib_info)
464     return;
465
466   /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
467   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
468     return;
469
470   msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
471   if (msymbol == NULL)
472     error (_("Unable to find __dld_flags symbol in object file."));
473
474   addr = SYMBOL_VALUE_ADDRESS (msymbol);
475   /* Read the current contents.  */
476   status = target_read_memory (addr, buf, 4);
477   if (status != 0)
478     error (_("Unable to read __dld_flags."));
479   dld_flags = extract_unsigned_integer (buf, 4);
480
481   /* __dld_list may not be valid.  If not, then we punt, warning the user if
482      we were called as a result of the add-symfile command.
483    */
484   if ((dld_flags & DLD_FLAGS_LISTVALID) == 0)
485     {
486       if (from_tty)
487         error (_("__dld_list is not valid according to __dld_flags."));
488       return;
489     }
490
491   /* If the libraries were not mapped private, warn the user.  */
492   if ((dld_flags & DLD_FLAGS_MAPPRIVATE) == 0)
493     warning (_("\
494 The shared libraries were not privately mapped; setting a breakpoint\n\
495 in a shared library will not work until you rerun the program."));
496
497   msymbol = lookup_minimal_symbol ("__dld_list", NULL, NULL);
498   if (!msymbol)
499     {
500       /* Older crt0.o files (hpux8) don't have __dld_list as a symbol,
501          but the data is still available if you know where to look.  */
502       msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
503       if (!msymbol)
504         error (_("Unable to find dynamic library list."));
505       addr = SYMBOL_VALUE_ADDRESS (msymbol) - 8;
506     }
507   else
508     addr = SYMBOL_VALUE_ADDRESS (msymbol);
509
510   status = target_read_memory (addr, buf, 4);
511   if (status != 0)
512     error (_("Unable to find dynamic library list."));
513
514   addr = extract_unsigned_integer (buf, 4);
515
516   /* If addr is zero, then we're using an old dynamic loader which
517      doesn't maintain __dld_list.  We'll have to use a completely
518      different approach to get shared library information.  */
519   if (addr == 0)
520     goto old_dld;
521
522   /* Using the information in __dld_list is the preferred method
523      to get at shared library information.  It doesn't depend on
524      any functions in /opt/langtools/lib/end.o and has a chance of working
525      with hpux10 when it is released.  */
526   status = target_read_memory (addr, buf, 4);
527   if (status != 0)
528     error (_("Unable to find dynamic library list."));
529
530   /* addr now holds the address of the first entry in the dynamic
531      library list.  */
532   addr = extract_unsigned_integer (buf, 4);
533
534   /* Now that we have a pointer to the dynamic library list, walk
535      through it and add the symbols for each library.  */
536
537   so_list_tail = so_list_head;
538   /* Find the end of the list of shared objects.  */
539   while (so_list_tail && so_list_tail->next)
540     so_list_tail = so_list_tail->next;
541
542 #ifdef SOLIB_DEBUG
543   printf ("--About to read shared library list data\n");
544 #endif
545
546   /* "addr" will always point to the base of the
547    * current data entry describing the current
548    * shared library.
549    */
550   while (1)
551     {
552       CORE_ADDR name_addr, text_addr;
553       unsigned int name_len;
554       char *name;
555       struct so_list *new_so;
556       struct so_list *so_list = so_list_head;
557       struct stat statbuf;
558       LONGEST st_size;
559       int is_main_program;
560
561       if (addr == 0)
562         break;
563
564       /* Get a pointer to the name of this library.  */
565       status = target_read_memory (addr, buf, 4);
566       if (status != 0)
567         goto err;
568
569       name_addr = extract_unsigned_integer (buf, 4);
570       name_len = 0;
571       while (1)
572         {
573           target_read_memory (name_addr + name_len, buf, 1);
574           if (status != 0)
575             goto err;
576
577           name_len++;
578           if (*buf == '\0')
579             break;
580         }
581       name = alloca (name_len);
582       status = target_read_memory (name_addr, name, name_len);
583       if (status != 0)
584         goto err;
585
586       /* See if we've already loaded something with this name.  */
587       while (so_list)
588         {
589           if (!strcmp (so_list->som_solib.name, name))
590             break;
591           so_list = so_list->next;
592         }
593
594       /* See if the file exists.  If not, give a warning, but don't
595          die.  */
596       status = stat (name, &statbuf);
597       if (status == -1)
598         {
599           warning (_("Can't find file %s referenced in dld_list."), name);
600
601           status = target_read_memory (addr + 36, buf, 4);
602           if (status != 0)
603             goto err;
604
605           addr = (CORE_ADDR) extract_unsigned_integer (buf, 4);
606           continue;
607         }
608
609       /* If we've already loaded this one or it's the main program, skip it.  */
610       is_main_program = (strcmp (name, symfile_objfile->name) == 0);
611       if (so_list || is_main_program)
612         {
613           /* This is the "next" pointer in the strcuture.
614            */
615           status = target_read_memory (addr + 36, buf, 4);
616           if (status != 0)
617             goto err;
618
619           addr = (CORE_ADDR) extract_unsigned_integer (buf, 4);
620
621           /* Record the main program's symbol table size. */
622           if (is_main_program && !so_list)
623             {
624               st_size = som_solib_sizeof_symbol_table (name);
625               som_solib_total_st_size += st_size;
626             }
627
628           /* Was this a shlib that we noted but didn't load the symbols for?
629              If so, were we invoked this time from the command-line, via
630              a 'sharedlibrary' or 'add-symbol-file' command?  If yes to
631              both, we'd better load the symbols this time.
632            */
633           if (from_tty && so_list && !is_main_program && (so_list->objfile == NULL))
634             som_solib_load_symbols (so_list,
635                                     name,
636                                     from_tty,
637                                     so_list->som_solib.text_addr,
638                                     target);
639
640           continue;
641         }
642
643       name = obsavestring (name, name_len - 1,
644                            &symfile_objfile->objfile_obstack);
645
646       status = target_read_memory (addr + 8, buf, 4);
647       if (status != 0)
648         goto err;
649
650       text_addr = extract_unsigned_integer (buf, 4);
651
652       new_so = (struct so_list *) xmalloc (sizeof (struct so_list));
653       memset ((char *) new_so, 0, sizeof (struct so_list));
654       if (so_list_head == NULL)
655         {
656           so_list_head = new_so;
657           so_list_tail = new_so;
658         }
659       else
660         {
661           so_list_tail->next = new_so;
662           so_list_tail = new_so;
663         }
664
665       /* Fill in all the entries in GDB's shared library list.
666        */
667
668       new_so->solib_addr = addr;
669       new_so->som_solib.name = name;
670       status = target_read_memory (addr + 4, buf, 4);
671       if (status != 0)
672         goto err;
673
674       new_so->som_solib.struct_version = extract_unsigned_integer (buf + 3, 1);
675       new_so->som_solib.bind_mode = extract_unsigned_integer (buf + 2, 1);
676       /* Following is "high water mark", highest version number
677        * seen, rather than plain version number.
678        */
679       new_so->som_solib.library_version = extract_unsigned_integer (buf, 2);
680       new_so->som_solib.text_addr = text_addr;
681
682       /* Q: What about longword at "addr + 8"?
683        * A: It's read above, out of order, into "text_addr".
684        */
685
686       status = target_read_memory (addr + 12, buf, 4);
687       if (status != 0)
688         goto err;
689
690       new_so->som_solib.text_link_addr = extract_unsigned_integer (buf, 4);
691
692       status = target_read_memory (addr + 16, buf, 4);
693       if (status != 0)
694         goto err;
695
696       new_so->som_solib.text_end = extract_unsigned_integer (buf, 4);
697
698       status = target_read_memory (addr + 20, buf, 4);
699       if (status != 0)
700         goto err;
701
702       new_so->som_solib.data_start = extract_unsigned_integer (buf, 4);
703
704       status = target_read_memory (addr + 24, buf, 4);
705       if (status != 0)
706         goto err;
707
708       new_so->som_solib.bss_start = extract_unsigned_integer (buf, 4);
709
710       status = target_read_memory (addr + 28, buf, 4);
711       if (status != 0)
712         goto err;
713
714       new_so->som_solib.data_end = extract_unsigned_integer (buf, 4);
715
716       status = target_read_memory (addr + 32, buf, 4);
717       if (status != 0)
718         goto err;
719
720       new_so->som_solib.got_value = extract_unsigned_integer (buf, 4);
721
722       status = target_read_memory (addr + 36, buf, 4);
723       if (status != 0)
724         goto err;
725
726       /* FIXME: cagney/2003-02-01: I think som_solib.next should be a
727          CORE_ADDR.  */
728       new_so->som_solib.next =
729         hpux_address_to_host_pointer_hack (extract_unsigned_integer (buf, 4));
730
731       /* Note that we don't re-set "addr" to the next pointer
732        * until after we've read the trailing data.
733        */
734
735       status = target_read_memory (addr + 40, buf, 4);
736       new_so->som_solib.tsd_start_addr = extract_unsigned_integer (buf, 4);
737       if (status != 0)
738         goto err;
739
740       /* Now indirect via that value!
741        */
742       status = target_read_memory (new_so->som_solib.tsd_start_addr, buf, 4);
743       new_so->som_solib.tsd_start_addr = extract_unsigned_integer (buf, 4);
744       if (status != 0)
745         goto err;
746 #ifdef SOLIB_DEBUG
747       printf ("\n+ library \"%s\" is described at 0x%x\n", name, addr);
748       printf ("  'version' is %d\n", new_so->som_solib.struct_version);
749       printf ("  'bind_mode' is %d\n", new_so->som_solib.bind_mode);
750       printf ("  'library_version' is %d\n", new_so->som_solib.library_version);
751       printf ("  'text_addr' is 0x%x\n", new_so->som_solib.text_addr);
752       printf ("  'text_link_addr' is 0x%x\n", new_so->som_solib.text_link_addr);
753       printf ("  'text_end' is 0x%x\n", new_so->som_solib.text_end);
754       printf ("  'data_start' is 0x%x\n", new_so->som_solib.data_start);
755       printf ("  'bss_start' is 0x%x\n", new_so->som_solib.bss_start);
756       printf ("  'data_end' is 0x%x\n", new_so->som_solib.data_end);
757       printf ("  'got_value' is %x\n", new_so->som_solib.got_value);
758       printf ("  'next' is 0x%x\n", new_so->som_solib.next);
759       printf ("  'tsd_start_addr' is 0x%x\n", new_so->som_solib.tsd_start_addr);
760 #endif
761
762       /* Go on to the next shared library descriptor.
763        */
764       addr = (CORE_ADDR) new_so->som_solib.next;
765
766
767
768       /* At this point, we have essentially hooked the shlib into the
769          "info share" command.  However, we haven't yet loaded its
770          symbol table.  We must now decide whether we ought to, i.e.,
771          whether doing so would exceed the symbol table size threshold.
772
773          If the threshold has just now been exceeded, then we'll issue
774          a warning message (which explains how to load symbols manually,
775          if the user so desires).
776
777          If the threshold has just now or previously been exceeded,
778          we'll just add the shlib to the list of object files, but won't
779          actually load its symbols.  (This is more useful than it might
780          sound, for it allows us to e.g., still load and use the shlibs'
781          unwind information for stack tracebacks.)
782        */
783
784       /* Note that we DON'T want to preclude the user from using the
785          add-symbol-file command!  Thus, we only worry about the threshold
786          when we're invoked for other reasons.
787        */
788       st_size = som_solib_sizeof_symbol_table (name);
789       som_solib_st_size_threshold_exceeded =
790         !from_tty &&
791         auto_solib_limit > 0 &&
792         readsyms &&
793         ((st_size + som_solib_total_st_size) > (auto_solib_limit * (LONGEST) (1024 * 1024)));
794
795       if (som_solib_st_size_threshold_exceeded)
796         {
797           if (!threshold_warning_given)
798             warning (_("\
799 Symbols for some libraries have not been loaded, because doing so would\n\
800 exceed the size threshold specified by auto-solib-limit.\n\
801 To manually load symbols, use the 'sharedlibrary' command.\n\
802 To raise the threshold, set auto-solib-limit to a larger value and rerun\n\
803 the program."));
804           threshold_warning_given = 1;
805
806           /* We'll still make note of this shlib, even if we don't
807              read its symbols.  This allows us to use its unwind
808              information well enough to know how to e.g., correctly
809              do a traceback from a PC within the shlib, even if we
810              can't symbolize those PCs...
811            */
812           som_solib_add_solib_objfile (new_so, name, from_tty, text_addr);
813           continue;
814         }
815
816       som_solib_total_st_size += st_size;
817
818       /* This fills in new_so->objfile, among others. */
819       som_solib_load_symbols (new_so, name, from_tty, text_addr, target);
820     }
821
822 #ifdef SOLIB_DEBUG
823   printf ("--Done reading shared library data\n");
824 #endif
825
826   /* Getting new symbols may change our opinion about what is
827      frameless.  */
828   reinit_frame_cache ();
829   return;
830
831 old_dld:
832   error (_("Debugging dynamic executables loaded via the hpux8 dld.sl is not supported."));
833
834 err:
835   error (_("Error while reading dynamic library list."));
836 }
837
838
839 /* This hook gets called just before the first instruction in the
840    inferior process is executed.
841
842    This is our opportunity to set magic flags in the inferior so
843    that GDB can be notified when a shared library is mapped in and
844    to tell the dynamic linker that a private copy of the library is
845    needed (so GDB can set breakpoints in the library).
846
847    __dld_flags is the location of the magic flags; as of this implementation
848    there are 3 flags of interest:
849
850    bit 0 when set indicates that private copies of the libraries are needed
851    bit 1 when set indicates that the callback hook routine is valid
852    bit 2 when set indicates that the dynamic linker should maintain the
853    __dld_list structure when loading/unloading libraries.
854
855    Note that shared libraries are not mapped in at this time, so we have
856    run the inferior until the libraries are mapped in.  Typically this
857    means running until the "_start" is called.  */
858
859 void
860 som_solib_create_inferior_hook (void)
861 {
862   struct minimal_symbol *msymbol;
863   unsigned int dld_flags, status, have_endo;
864   asection *shlib_info;
865   char buf[4];
866   struct objfile *objfile;
867   CORE_ADDR anaddr;
868
869   /* First, remove all the solib event breakpoints.  Their addresses
870      may have changed since the last time we ran the program.  */
871   remove_solib_event_breakpoints ();
872
873   if (symfile_objfile == NULL)
874     return;
875
876   /* First see if the objfile was dynamically linked.  */
877   shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
878   if (!shlib_info)
879     return;
880
881   /* It's got a $SHLIB_INFO$ section, make sure it's not empty.  */
882   if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
883     return;
884
885   have_endo = 0;
886   /* Slam the pid of the process into __d_pid.
887
888      We used to warn when this failed, but that warning is only useful
889      on very old HP systems (hpux9 and older).  The warnings are an
890      annoyance to users of modern systems and foul up the testsuite as
891      well.  As a result, the warnings have been disabled.  */
892   msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
893   if (msymbol == NULL)
894     goto keep_going;
895
896   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
897   store_unsigned_integer (buf, 4, PIDGET (inferior_ptid));
898   status = target_write_memory (anaddr, buf, 4);
899   if (status != 0)
900     {
901       warning (_("Unable to write __d_pid"));
902       warning (_("Suggest linking with /opt/langtools/lib/end.o."));
903       warning (_("GDB will be unable to track shl_load/shl_unload calls"));
904       goto keep_going;
905     }
906
907   /* Get the value of _DLD_HOOK (an export stub) and put it in __dld_hook;
908      This will force the dynamic linker to call __d_trap when significant
909      events occur.
910
911      Note that the above is the pre-HP-UX 9.0 behaviour.  At 9.0 and above,
912      the dld provides an export stub named "__d_trap" as well as the
913      function named "__d_trap" itself, but doesn't provide "_DLD_HOOK".
914      We'll look first for the old flavor and then the new.
915    */
916   msymbol = lookup_minimal_symbol ("_DLD_HOOK", NULL, symfile_objfile);
917   if (msymbol == NULL)
918     msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
919   if (msymbol == NULL)
920     {
921       warning (_("Unable to find _DLD_HOOK symbol in object file."));
922       warning (_("Suggest linking with /opt/langtools/lib/end.o."));
923       warning (_("GDB will be unable to track shl_load/shl_unload calls"));
924       goto keep_going;
925     }
926   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
927   dld_cache.hook.address = anaddr;
928
929   /* Grrr, this might not be an export symbol!  We have to find the
930      export stub.  */
931   ALL_OBJFILES (objfile)
932   {
933     struct unwind_table_entry *u;
934     struct minimal_symbol *msymbol2;
935
936     /* What a crock.  */
937     msymbol2 = lookup_minimal_symbol_solib_trampoline (DEPRECATED_SYMBOL_NAME (msymbol),
938                                                        objfile);
939     /* Found a symbol with the right name.  */
940     if (msymbol2)
941       {
942         struct unwind_table_entry *u;
943         /* It must be a shared library trampoline.  */
944         if (SYMBOL_TYPE (msymbol2) != mst_solib_trampoline)
945           continue;
946
947         /* It must also be an export stub.  */
948         u = find_unwind_entry (SYMBOL_VALUE (msymbol2));
949         if (!u || u->stub_unwind.stub_type != EXPORT)
950           continue;
951
952         /* OK.  Looks like the correct import stub.  */
953         anaddr = SYMBOL_VALUE (msymbol2);
954         dld_cache.hook_stub.address = anaddr;
955       }
956   }
957   store_unsigned_integer (buf, 4, anaddr);
958
959   msymbol = lookup_minimal_symbol ("__dld_hook", NULL, symfile_objfile);
960   if (msymbol == NULL)
961     {
962       warning (_("Unable to find __dld_hook symbol in object file."));
963       warning (_("Suggest linking with /opt/langtools/lib/end.o."));
964       warning (_("GDB will be unable to track shl_load/shl_unload calls"));
965       goto keep_going;
966     }
967   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
968   status = target_write_memory (anaddr, buf, 4);
969
970   /* Now set a shlib_event breakpoint at __d_trap so we can track
971      significant shared library events.  */
972   msymbol = lookup_minimal_symbol ("__d_trap", NULL, symfile_objfile);
973   if (msymbol == NULL)
974     {
975       warning (_("Unable to find __dld_d_trap symbol in object file."));
976       warning (_("Suggest linking with /opt/langtools/lib/end.o."));
977       warning (_("GDB will be unable to track shl_load/shl_unload calls"));
978       goto keep_going;
979     }
980   create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
981
982   /* We have all the support usually found in end.o, so we can track
983      shl_load and shl_unload calls.  */
984   have_endo = 1;
985
986 keep_going:
987
988   /* Get the address of __dld_flags, if no such symbol exists, then we can
989      not debug the shared code.  */
990   msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
991   if (msymbol == NULL)
992     error (_("Unable to find __dld_flags symbol in object file."));
993
994   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
995
996   /* Read the current contents.  */
997   status = target_read_memory (anaddr, buf, 4);
998   if (status != 0)
999     error (_("Unable to read __dld_flags."));
1000   dld_flags = extract_unsigned_integer (buf, 4);
1001
1002   /* Turn on the flags we care about.  */
1003   dld_flags |= DLD_FLAGS_MAPPRIVATE;
1004   if (have_endo)
1005     dld_flags |= DLD_FLAGS_HOOKVALID;
1006   store_unsigned_integer (buf, 4, dld_flags);
1007   status = target_write_memory (anaddr, buf, 4);
1008   if (status != 0)
1009     error (_("Unable to write __dld_flags."));
1010
1011   /* Now find the address of _start and set a breakpoint there. 
1012      We still need this code for two reasons:
1013
1014      * Not all sites have /opt/langtools/lib/end.o, so it's not always
1015      possible to track the dynamic linker's events.
1016
1017      * At this time no events are triggered for shared libraries
1018      loaded at startup time (what a crock).  */
1019
1020   msymbol = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
1021   if (msymbol == NULL)
1022     error (_("Unable to find _start symbol in object file."));
1023
1024   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
1025
1026   /* Make the breakpoint at "_start" a shared library event breakpoint.  */
1027   create_solib_event_breakpoint (anaddr);
1028
1029   /* Wipe out all knowledge of old shared libraries since their
1030      mapping can change from one exec to another!  */
1031   while (so_list_head)
1032     {
1033       struct so_list *temp;
1034
1035       temp = so_list_head;
1036       xfree (so_list_head);
1037       so_list_head = temp->next;
1038     }
1039   clear_symtab_users ();
1040 }
1041
1042 /* This operation removes the "hook" between GDB and the dynamic linker,
1043    which causes the dld to notify GDB of shared library events.
1044
1045    After this operation completes, the dld will no longer notify GDB of
1046    shared library events.  To resume notifications, GDB must call
1047    som_solib_create_inferior_hook.
1048
1049    This operation does not remove any knowledge of shared libraries 
1050    of which GDB may already have been notified.
1051  */
1052 void
1053 som_solib_remove_inferior_hook (int pid)
1054 {
1055   CORE_ADDR addr;
1056   struct minimal_symbol *msymbol;
1057   int status;
1058   char dld_flags_buffer[4];
1059   unsigned int dld_flags_value;
1060   struct cleanup *old_cleanups = save_inferior_ptid ();
1061
1062   /* Ensure that we're really operating on the specified process. */
1063   inferior_ptid = pid_to_ptid (pid);
1064
1065   /* We won't bother to remove the solib breakpoints from this process.
1066
1067      In fact, on PA64 the breakpoint is hard-coded into the dld callback,
1068      and thus we're not supposed to remove it.
1069
1070      Rather, we'll merely clear the dld_flags bit that enables callbacks.
1071    */
1072   msymbol = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
1073
1074   addr = SYMBOL_VALUE_ADDRESS (msymbol);
1075   status = target_read_memory (addr, dld_flags_buffer, 4);
1076
1077   dld_flags_value = extract_unsigned_integer (dld_flags_buffer, 4);
1078
1079   dld_flags_value &= ~DLD_FLAGS_HOOKVALID;
1080   store_unsigned_integer (dld_flags_buffer, 4, dld_flags_value);
1081   status = target_write_memory (addr, dld_flags_buffer, 4);
1082
1083   do_cleanups (old_cleanups);
1084 }
1085
1086
1087 /* This function creates a breakpoint on the dynamic linker hook, which
1088    is called when e.g., a shl_load or shl_unload call is made.  This
1089    breakpoint will only trigger when a shl_load call is made.
1090
1091    If filename is NULL, then loads of any dll will be caught.  Else,
1092    only loads of the file whose pathname is the string contained by
1093    filename will be caught.
1094
1095    Undefined behaviour is guaranteed if this function is called before
1096    som_solib_create_inferior_hook.
1097  */
1098 void
1099 som_solib_create_catch_load_hook (int pid, int tempflag, char *filename,
1100                                   char *cond_string)
1101 {
1102   create_solib_load_event_breakpoint ("__d_trap", tempflag, 
1103                                       filename, cond_string);
1104 }
1105
1106 /* This function creates a breakpoint on the dynamic linker hook, which
1107    is called when e.g., a shl_load or shl_unload call is made.  This
1108    breakpoint will only trigger when a shl_unload call is made.
1109
1110    If filename is NULL, then unloads of any dll will be caught.  Else,
1111    only unloads of the file whose pathname is the string contained by
1112    filename will be caught.
1113
1114    Undefined behaviour is guaranteed if this function is called before
1115    som_solib_create_inferior_hook.
1116  */
1117 void
1118 som_solib_create_catch_unload_hook (int pid, int tempflag, char *filename,
1119                                     char *cond_string)
1120 {
1121   create_solib_unload_event_breakpoint ("__d_trap", tempflag, 
1122                                         filename, cond_string);
1123 }
1124
1125 int
1126 som_solib_have_load_event (int pid)
1127 {
1128   CORE_ADDR event_kind;
1129
1130   event_kind = read_register (HPPA_ARG0_REGNUM);
1131   return (event_kind == SHL_LOAD);
1132 }
1133
1134 int
1135 som_solib_have_unload_event (int pid)
1136 {
1137   CORE_ADDR event_kind;
1138
1139   event_kind = read_register (HPPA_ARG0_REGNUM);
1140   return (event_kind == SHL_UNLOAD);
1141 }
1142
1143 static char *
1144 som_solib_library_pathname (int pid)
1145 {
1146   CORE_ADDR dll_handle_address;
1147   CORE_ADDR dll_pathname_address;
1148   struct som_solib_mapped_entry dll_descriptor;
1149   char *p;
1150   static char dll_pathname[1024];
1151
1152   /* Read the descriptor of this newly-loaded library. */
1153   dll_handle_address = read_register (HPPA_ARG1_REGNUM);
1154   read_memory (dll_handle_address, (char *) &dll_descriptor, sizeof (dll_descriptor));
1155
1156   /* We can find a pointer to the dll's pathname within the descriptor. */
1157   dll_pathname_address = (CORE_ADDR) dll_descriptor.name;
1158
1159   /* Read the pathname, one byte at a time. */
1160   p = dll_pathname;
1161   for (;;)
1162     {
1163       char b;
1164       read_memory (dll_pathname_address++, (char *) &b, 1);
1165       *p++ = b;
1166       if (b == '\0')
1167         break;
1168     }
1169
1170   return dll_pathname;
1171 }
1172
1173 char *
1174 som_solib_loaded_library_pathname (int pid)
1175 {
1176   if (!som_solib_have_load_event (pid))
1177     error (_("Must have a load event to use this query"));
1178
1179   return som_solib_library_pathname (pid);
1180 }
1181
1182 char *
1183 som_solib_unloaded_library_pathname (int pid)
1184 {
1185   if (!som_solib_have_unload_event (pid))
1186     error (_("Must have an unload event to use this query"));
1187
1188   return som_solib_library_pathname (pid);
1189 }
1190
1191 static void
1192 som_solib_desire_dynamic_linker_symbols (void)
1193 {
1194   struct objfile *objfile;
1195   struct unwind_table_entry *u;
1196   struct minimal_symbol *dld_msymbol;
1197
1198   /* Do we already know the value of these symbols?  If so, then
1199      we've no work to do.
1200
1201      (If you add clauses to this test, be sure to likewise update the
1202      test within the loop.)
1203    */
1204   if (dld_cache.is_valid)
1205     return;
1206
1207   ALL_OBJFILES (objfile)
1208   {
1209     dld_msymbol = lookup_minimal_symbol ("shl_load", NULL, objfile);
1210     if (dld_msymbol != NULL)
1211       {
1212         dld_cache.load.address = SYMBOL_VALUE (dld_msymbol);
1213         dld_cache.load.unwind = find_unwind_entry (dld_cache.load.address);
1214       }
1215
1216     dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_load",
1217                                                           objfile);
1218     if (dld_msymbol != NULL)
1219       {
1220         if (SYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
1221           {
1222             u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
1223             if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
1224               {
1225                 dld_cache.load_stub.address = SYMBOL_VALUE (dld_msymbol);
1226                 dld_cache.load_stub.unwind = u;
1227               }
1228           }
1229       }
1230
1231     dld_msymbol = lookup_minimal_symbol ("shl_unload", NULL, objfile);
1232     if (dld_msymbol != NULL)
1233       {
1234         dld_cache.unload.address = SYMBOL_VALUE (dld_msymbol);
1235         dld_cache.unload.unwind = find_unwind_entry (dld_cache.unload.address);
1236
1237         /* ??rehrauer: I'm not sure exactly what this is, but it appears
1238            that on some HPUX 10.x versions, there's two unwind regions to
1239            cover the body of "shl_unload", the second being 4 bytes past
1240            the end of the first.  This is a large hack to handle that
1241            case, but since I don't seem to have any legitimate way to
1242            look for this thing via the symbol table...
1243          */
1244         if (dld_cache.unload.unwind != NULL)
1245           {
1246             u = find_unwind_entry (dld_cache.unload.unwind->region_end + 4);
1247             if (u != NULL)
1248               {
1249                 dld_cache.unload2.address = u->region_start;
1250                 dld_cache.unload2.unwind = u;
1251               }
1252           }
1253       }
1254
1255     dld_msymbol = lookup_minimal_symbol_solib_trampoline ("shl_unload",
1256                                                           objfile);
1257     if (dld_msymbol != NULL)
1258       {
1259         if (SYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
1260           {
1261             u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
1262             if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
1263               {
1264                 dld_cache.unload_stub.address = SYMBOL_VALUE (dld_msymbol);
1265                 dld_cache.unload_stub.unwind = u;
1266               }
1267           }
1268       }
1269
1270     /* Did we find everything we were looking for?  If so, stop. */
1271     if ((dld_cache.load.address != 0)
1272         && (dld_cache.load_stub.address != 0)
1273         && (dld_cache.unload.address != 0)
1274         && (dld_cache.unload_stub.address != 0))
1275       {
1276         dld_cache.is_valid = 1;
1277         break;
1278       }
1279   }
1280
1281   dld_cache.hook.unwind = find_unwind_entry (dld_cache.hook.address);
1282   dld_cache.hook_stub.unwind = find_unwind_entry (dld_cache.hook_stub.address);
1283
1284   /* We're prepared not to find some of these symbols, which is why
1285      this function is a "desire" operation, and not a "require".
1286    */
1287 }
1288
1289 int
1290 som_solib_in_dynamic_linker (int pid, CORE_ADDR pc)
1291 {
1292   struct unwind_table_entry *u_pc;
1293
1294   /* Are we in the dld itself?
1295
1296      ??rehrauer: Large hack -- We'll assume that any address in a
1297      shared text region is the dld's text.  This would obviously
1298      fall down if the user attached to a process, whose shlibs
1299      weren't mapped to a (writeable) private region.  However, in
1300      that case the debugger probably isn't able to set the fundamental
1301      breakpoint in the dld callback anyways, so this hack should be
1302      safe.
1303    */
1304   if ((pc & (CORE_ADDR) 0xc0000000) == (CORE_ADDR) 0xc0000000)
1305     return 1;
1306
1307   /* Cache the address of some symbols that are part of the dynamic
1308      linker, if not already known.
1309    */
1310   som_solib_desire_dynamic_linker_symbols ();
1311
1312   /* Are we in the dld callback?  Or its export stub? */
1313   u_pc = find_unwind_entry (pc);
1314   if (u_pc == NULL)
1315     return 0;
1316
1317   if ((u_pc == dld_cache.hook.unwind) || (u_pc == dld_cache.hook_stub.unwind))
1318     return 1;
1319
1320   /* Or the interface of the dld (i.e., "shl_load" or friends)? */
1321   if ((u_pc == dld_cache.load.unwind)
1322       || (u_pc == dld_cache.unload.unwind)
1323       || (u_pc == dld_cache.unload2.unwind)
1324       || (u_pc == dld_cache.load_stub.unwind)
1325       || (u_pc == dld_cache.unload_stub.unwind))
1326     return 1;
1327
1328   /* Apparently this address isn't part of the dld's text. */
1329   return 0;
1330 }
1331
1332
1333 /* Return the GOT value for the shared library in which ADDR belongs.  If
1334    ADDR isn't in any known shared library, return zero.  */
1335
1336 CORE_ADDR
1337 som_solib_get_got_by_pc (CORE_ADDR addr)
1338 {
1339   struct so_list *so_list = so_list_head;
1340   CORE_ADDR got_value = 0;
1341
1342   while (so_list)
1343     {
1344       if (so_list->som_solib.text_addr <= addr
1345           && so_list->som_solib.text_end > addr)
1346         {
1347           got_value = so_list->som_solib.got_value;
1348           break;
1349         }
1350       so_list = so_list->next;
1351     }
1352   return got_value;
1353 }
1354
1355 /*  elz:
1356    Return the address of the handle of the shared library
1357    in which ADDR belongs.  If
1358    ADDR isn't in any known shared library, return zero.  */
1359 /* this function is used in hppa_fix_call_dummy in hppa-tdep.c */
1360
1361 CORE_ADDR
1362 som_solib_get_solib_by_pc (CORE_ADDR addr)
1363 {
1364   struct so_list *so_list = so_list_head;
1365
1366   while (so_list)
1367     {
1368       if (so_list->som_solib.text_addr <= addr
1369           && so_list->som_solib.text_end > addr)
1370         {
1371           break;
1372         }
1373       so_list = so_list->next;
1374     }
1375   if (so_list)
1376     return so_list->solib_addr;
1377   else
1378     return 0;
1379 }
1380
1381
1382 int
1383 som_solib_section_offsets (struct objfile *objfile,
1384                            struct section_offsets *offsets)
1385 {
1386   struct so_list *so_list = so_list_head;
1387
1388   while (so_list)
1389     {
1390       /* Oh what a pain!  We need the offsets before so_list->objfile
1391          is valid.  The BFDs will never match.  Make a best guess.  */
1392       if (strstr (objfile->name, so_list->som_solib.name))
1393         {
1394           asection *private_section;
1395
1396           /* The text offset is easy.  */
1397           offsets->offsets[SECT_OFF_TEXT (objfile)]
1398             = (so_list->som_solib.text_addr
1399                - so_list->som_solib.text_link_addr);
1400           offsets->offsets[SECT_OFF_RODATA (objfile)]
1401             = ANOFFSET (offsets, SECT_OFF_TEXT (objfile));
1402
1403           /* We should look at presumed_dp in the SOM header, but
1404              that's not easily available.  This should be OK though.  */
1405           private_section = bfd_get_section_by_name (objfile->obfd,
1406                                                      "$PRIVATE$");
1407           if (!private_section)
1408             {
1409               warning (_("Unable to find $PRIVATE$ in shared library!"));
1410               offsets->offsets[SECT_OFF_DATA (objfile)] = 0;
1411               offsets->offsets[SECT_OFF_BSS (objfile)] = 0;
1412               return 1;
1413             }
1414           offsets->offsets[SECT_OFF_DATA (objfile)]
1415             = (so_list->som_solib.data_start - private_section->vma);
1416           offsets->offsets[SECT_OFF_BSS (objfile)]
1417             = ANOFFSET (offsets, SECT_OFF_DATA (objfile));
1418           return 1;
1419         }
1420       so_list = so_list->next;
1421     }
1422   return 0;
1423 }
1424
1425 /* Dump information about all the currently loaded shared libraries.  */
1426
1427 static void
1428 som_sharedlibrary_info_command (char *ignore, int from_tty)
1429 {
1430   struct so_list *so_list = so_list_head;
1431
1432   if (exec_bfd == NULL)
1433     {
1434       printf_unfiltered ("No executable file.\n");
1435       return;
1436     }
1437
1438   if (so_list == NULL)
1439     {
1440       printf_unfiltered ("No shared libraries loaded at this time.\n");
1441       return;
1442     }
1443
1444   printf_unfiltered ("Shared Object Libraries\n");
1445   printf_unfiltered ("    %-12s%-12s%-12s%-12s%-12s%-12s\n",
1446          "  flags", "  tstart", "   tend", "  dstart", "   dend", "   dlt");
1447   while (so_list)
1448     {
1449       unsigned int flags;
1450
1451       flags = so_list->som_solib.struct_version << 24;
1452       flags |= so_list->som_solib.bind_mode << 16;
1453       flags |= so_list->som_solib.library_version;
1454       printf_unfiltered ("%s", so_list->som_solib.name);
1455       if (so_list->objfile == NULL)
1456         printf_unfiltered ("  (symbols not loaded)");
1457       printf_unfiltered ("\n");
1458       printf_unfiltered ("    %-12s", hex_string_custom (flags, 8));
1459       printf_unfiltered ("%-12s",
1460                          hex_string_custom (so_list->som_solib.text_addr, 8));
1461       printf_unfiltered ("%-12s",
1462                          hex_string_custom (so_list->som_solib.text_end, 8));
1463       printf_unfiltered ("%-12s",
1464                          hex_string_custom (so_list->som_solib.data_start, 8));
1465       printf_unfiltered ("%-12s",
1466                          hex_string_custom (so_list->som_solib.data_end, 8));
1467       printf_unfiltered ("%-12s\n",
1468                          hex_string_custom (so_list->som_solib.got_value, 8));
1469       so_list = so_list->next;
1470     }
1471 }
1472
1473 static void
1474 som_solib_sharedlibrary_command (char *args, int from_tty)
1475 {
1476   dont_repeat ();
1477   som_solib_add (args, from_tty, (struct target_ops *) 0, 1);
1478 }
1479
1480
1481
1482 char *
1483 som_solib_address (CORE_ADDR addr)
1484 {
1485   struct so_list *so = so_list_head;
1486
1487   while (so)
1488     {
1489       /* Is this address within this shlib's text range?  If so,
1490          return the shlib's name.
1491        */
1492       if ((addr >= so->som_solib.text_addr) && (addr <= so->som_solib.text_end))
1493         return so->som_solib.name;
1494
1495       /* Nope, keep looking... */
1496       so = so->next;
1497     }
1498
1499   /* No, we couldn't prove that the address is within a shlib. */
1500   return NULL;
1501 }
1502
1503
1504 void
1505 som_solib_restart (void)
1506 {
1507   struct so_list *sl = so_list_head;
1508
1509   /* Before the shlib info vanishes, use it to disable any breakpoints
1510      that may still be active in those shlibs.
1511    */
1512   disable_breakpoints_in_shlibs (0);
1513
1514   /* Discard all the shlib descriptors.
1515    */
1516   while (sl)
1517     {
1518       struct so_list *next_sl = sl->next;
1519       xfree (sl);
1520       sl = next_sl;
1521     }
1522   so_list_head = NULL;
1523
1524   som_solib_total_st_size = (LONGEST) 0;
1525   som_solib_st_size_threshold_exceeded = 0;
1526
1527   dld_cache.is_valid = 0;
1528
1529   dld_cache.hook.address = 0;
1530   dld_cache.hook.unwind = NULL;
1531
1532   dld_cache.hook_stub.address = 0;
1533   dld_cache.hook_stub.unwind = NULL;
1534
1535   dld_cache.load.address = 0;
1536   dld_cache.load.unwind = NULL;
1537
1538   dld_cache.load_stub.address = 0;
1539   dld_cache.load_stub.unwind = NULL;
1540
1541   dld_cache.unload.address = 0;
1542   dld_cache.unload.unwind = NULL;
1543
1544   dld_cache.unload2.address = 0;
1545   dld_cache.unload2.unwind = NULL;
1546
1547   dld_cache.unload_stub.address = 0;
1548   dld_cache.unload_stub.unwind = NULL;
1549 }
1550
1551
1552 void
1553 _initialize_som_solib (void)
1554 {
1555   add_com ("sharedlibrary", class_files, som_solib_sharedlibrary_command,
1556            _("Load shared object library symbols for files matching REGEXP."));
1557   add_info ("sharedlibrary", som_sharedlibrary_info_command,
1558             _("Status of loaded shared object libraries."));
1559
1560   add_setshow_boolean_cmd ("auto-solib-add", class_support,
1561                            &auto_solib_add, _("\
1562 Set autoloading of shared library symbols."), _("\
1563 Show autoloading of shared library symbols."), _("\
1564 If \"on\", symbols from all shared object libraries will be loaded\n\
1565 automatically when the inferior begins execution, when the dynamic linker\n\
1566 informs gdb that a new library has been loaded, or when attaching to the\n\
1567 inferior.  Otherwise, symbols must be loaded manually, using `sharedlibrary'."),
1568                            NULL,
1569                            NULL, /* FIXME: i18n: */
1570                            &setlist, &showlist);
1571
1572   add_setshow_zinteger_cmd ("auto-solib-limit", class_support,
1573                             &auto_solib_limit, _("\
1574 Set threshold (in Mb) for autoloading shared library symbols."), _("\
1575 Show threshold (in Mb) for autoloading shared library symbols."), _("\
1576 When shared library autoloading is enabled, new libraries will be loaded\n\
1577 only until the total size of shared library symbols exceeds this\n\
1578 threshold in megabytes.  Is ignored when using `sharedlibrary'."),
1579                             NULL,
1580                             NULL, /* FIXME: i18n: */
1581                             &setlist, &showlist);
1582
1583   /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how
1584      much data space a process can use.  We ought to be reading
1585      MAXDSIZ and setting auto_solib_limit to some large fraction of
1586      that value.  If not that, we maybe ought to be setting it smaller
1587      than the default for MAXDSIZ (that being 64Mb, I believe).
1588      However, [1] this threshold is only crudely approximated rather
1589      than actually measured, and [2] 50 Mbytes is too small for
1590      debugging gdb itself.  Thus, the arbitrary 100 figure.  */
1591   auto_solib_limit = 100;       /* Megabytes */
1592
1593   som_solib_restart ();
1594 }
1595
1596 /* Get some HPUX-specific data from a shared lib.
1597  */
1598 CORE_ADDR
1599 som_solib_thread_start_addr (struct so_list *so)
1600 {
1601   return so->som_solib.tsd_start_addr;
1602 }
1603
1604 #ifdef PA_SOM_ONLY
1605 void
1606 no_shared_libraries (char *ignored, int from_tty)
1607 {
1608 }
1609 #endif