OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [pa64solib.c] - Blame information for rev 104

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Handle HP ELF shared libraries for GDB, the GNU Debugger.
2
   Copyright 1999 Free Software Foundation, Inc.
3
 
4
   This file is part of GDB.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 2 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 59 Temple Place - Suite 330,
19
   Boston, MA 02111-1307, USA.
20
 
21
   HP in their infinite stupidity choose not to use standard ELF dynamic
22
   linker interfaces.  They also choose not to make their ELF dymamic
23
   linker interfaces compatible with the SOM dynamic linker.  The
24
   net result is we can not use either of the existing somsolib.c or
25
   solib.c.  What a crock.
26
 
27
   Even more disgusting.  This file depends on functions provided only
28
   in certain PA64 libraries.  Thus this file is supposed to only be
29
   used native.  When will HP ever learn that they need to provide the
30
   same functionality in all their libraries!  */
31
 
32
#include <dlfcn.h>
33
#include <elf.h>
34
#include <elf_hp.h>
35
 
36
#include "defs.h"
37
 
38
#include "frame.h"
39
#include "bfd.h"
40
#include "libhppa.h"
41
#include "gdbcore.h"
42
#include "symtab.h"
43
#include "breakpoint.h"
44
#include "symfile.h"
45
#include "objfiles.h"
46
#include "inferior.h"
47
#include "gdb-stabs.h"
48
#include "gdb_stat.h"
49
#include "gdbcmd.h"
50
#include "assert.h"
51
#include "language.h"
52
 
53
#include <fcntl.h>
54
 
55
#ifndef O_BINARY
56
#define O_BINARY 0
57
#endif
58
 
59
/* Defined in exec.c; used to prevent dangling pointer bug.  */
60
extern struct target_ops exec_ops;
61
 
62
static CORE_ADDR
63
  bfd_lookup_symbol PARAMS ((bfd *, char *));
64
/* This lives in hppa-tdep.c. */
65
extern struct unwind_table_entry *find_unwind_entry PARAMS ((CORE_ADDR pc));
66
 
67
/* These ought to be defined in some public interface, but aren't.  They
68
   identify dynamic linker events.  */
69
#define DLD_CB_LOAD     1
70
#define DLD_CB_UNLOAD   0
71
 
72
/* A structure to keep track of all the known shared objects.  */
73
struct so_list
74
  {
75
    bfd *abfd;
76
    char *name;
77
    struct so_list *next;
78
    struct objfile *objfile;
79
    CORE_ADDR pa64_solib_desc_addr;
80
    struct load_module_desc pa64_solib_desc;
81
    struct section_table *sections;
82
    struct section_table *sections_end;
83
    boolean loaded;
84
  };
85
 
86
static struct so_list *so_list_head;
87
 
88
/* This is the cumulative size in bytes of the symbol tables of all
89
   shared objects on the so_list_head list.  (When we say size, here
90
   we mean of the information before it is brought into memory and
91
   potentially expanded by GDB.)  When adding a new shlib, this value
92
   is compared against the threshold size, held by auto_solib_add
93
   (in megabytes).  If adding symbols for the new shlib would cause
94
   the total size to exceed the threshold, then the new shlib's symbols
95
   are not loaded.  */
96
static LONGEST pa64_solib_total_st_size;
97
 
98
/* When the threshold is reached for any shlib, we refuse to add
99
   symbols for subsequent shlibs, even if those shlibs' symbols would
100
   be small enough to fit under the threshold.  (Although this may
101
   result in one, early large shlib preventing the loading of later,
102
   smalller shlibs' symbols, it allows us to issue one informational
103
   message.  The alternative, to issue a message for each shlib whose
104
   symbols aren't loaded, could be a big annoyance where the threshold
105
   is exceeded due to a very large number of shlibs.) */
106
static int pa64_solib_st_size_threshold_exceeded;
107
 
108
/* When adding fields, be sure to clear them in _initialize_pa64_solib. */
109
typedef struct
110
  {
111
    CORE_ADDR dld_flags_addr;
112
    long long dld_flags;
113
    sec_ptr dyninfo_sect;
114
    boolean have_read_dld_descriptor;
115
    boolean is_valid;
116
    CORE_ADDR load_map;
117
    CORE_ADDR load_map_addr;
118
    struct load_module_desc dld_desc;
119
  }
120
dld_cache_t;
121
 
122
static dld_cache_t dld_cache;
123
 
124
static void pa64_sharedlibrary_info_command PARAMS ((char *, int));
125
 
126
static void pa64_solib_sharedlibrary_command PARAMS ((char *, int));
127
 
128
static void * pa64_target_read_memory PARAMS ((void *, CORE_ADDR, size_t, int));
129
 
130
static boolean read_dld_descriptor PARAMS ((struct target_ops *));
131
 
132
static boolean read_dynamic_info PARAMS ((asection *, dld_cache_t *));
133
 
134
static void add_to_solist PARAMS ((boolean, char *, struct load_module_desc *,
135
                                   CORE_ADDR, struct target_ops *));
136
 
137
/* When examining the shared library for debugging information we have to
138
   look for HP debug symbols, stabs and dwarf2 debug symbols.  */
139
static char *pa64_debug_section_names[] = {
140
  ".debug_header", ".debug_gntt", ".debug_lntt", ".debug_slt", ".debug_vt",
141
  ".stabs", ".stabstr", ".debug_info", ".debug_abbrev", ".debug_aranges",
142
  ".debug_macinfo", ".debug_line", ".debug_loc", ".debug_pubnames",
143
  ".debug_str", NULL
144
};
145
 
146
/* Return a ballbark figure for the amount of memory GDB will need to
147
   allocate to read in the debug symbols from FILENAME.  */
148
static LONGEST
149
pa64_solib_sizeof_symbol_table (filename)
150
     char *filename;
151
{
152
  bfd *abfd;
153
  int i;
154
  int desc;
155
  char *absolute_name;
156
  LONGEST st_size = (LONGEST) 0;
157
  asection *sect;
158
 
159
  /* We believe that filename was handed to us by the dynamic linker, and
160
     is therefore always an absolute path.  */
161
  desc = openp (getenv ("PATH"), 1, filename, O_RDONLY | O_BINARY,
162
                0, &absolute_name);
163
  if (desc < 0)
164
    {
165
      perror_with_name (filename);
166
    }
167
  filename = absolute_name;
168
 
169
  abfd = bfd_fdopenr (filename, gnutarget, desc);
170
  if (!abfd)
171
    {
172
      close (desc);
173
      make_cleanup (free, filename);
174
      error ("\"%s\": can't open to read symbols: %s.", filename,
175
             bfd_errmsg (bfd_get_error ()));
176
    }
177
 
178
  if (!bfd_check_format (abfd, bfd_object))
179
    {
180
      bfd_close (abfd);
181
      make_cleanup (free, filename);
182
      error ("\"%s\": can't read symbols: %s.", filename,
183
             bfd_errmsg (bfd_get_error ()));
184
    }
185
 
186
  /* Sum the sizes of the various sections that compose debug info. */
187
  for (i = 0; pa64_debug_section_names[i] != NULL; i++)
188
    {
189
      asection *sect;
190
 
191
      sect = bfd_get_section_by_name (abfd, pa64_debug_section_names[i]);
192
      if (sect)
193
        st_size += (LONGEST)bfd_section_size (abfd, sect);
194
    }
195
 
196
  bfd_close (abfd);
197
  free (filename);
198
 
199
  /* Unfortunately, just summing the sizes of various debug info
200
     sections isn't a very accurate measurement of how much heap
201
     space the debugger will need to hold them.  It also doesn't
202
     account for space needed by linker (aka "minimal") symbols.
203
 
204
     Anecdotal evidence suggests that just summing the sizes of
205
     debug-info-related sections understates the heap space needed
206
     to represent it internally by about an order of magnitude.
207
 
208
     Since it's not exactly brain surgery we're doing here, rather
209
     than attempt to more accurately measure the size of a shlib's
210
     symbol table in GDB's heap, we'll just apply a 10x fudge-
211
     factor to the debug info sections' size-sum.  No, this doesn't
212
     account for minimal symbols in non-debuggable shlibs.  But it
213
     all roughly washes out in the end.  */
214
  return st_size * (LONGEST) 10;
215
}
216
 
217
/* Add a shared library to the objfile list and load its symbols into
218
   GDB's symbol table.  */
219
static void
220
pa64_solib_add_solib_objfile (so, name, from_tty, text_addr)
221
     struct so_list *so;
222
     char *name;
223
     int from_tty;
224
     CORE_ADDR text_addr;
225
{
226
  bfd *tmp_bfd;
227
  asection *sec;
228
  obj_private_data_t *obj_private;
229
  struct section_addr_info section_addrs;
230
 
231
  memset (&section_addrs, 0, sizeof (section_addrs));
232
  /* We need the BFD so that we can look at its sections.  We open up the
233
     file temporarily, then close it when we are done.  */
234
  tmp_bfd = bfd_openr (name, gnutarget);
235
  if (tmp_bfd == NULL)
236
    {
237
      perror_with_name (name);
238
      return;
239
    }
240
 
241
  if (!bfd_check_format (tmp_bfd, bfd_object))
242
    {
243
      bfd_close (tmp_bfd);
244
      error ("\"%s\" is not an object file: %s", name,
245
             bfd_errmsg (bfd_get_error ()));
246
    }
247
 
248
 
249
  /* Undo some braindamage from symfile.c.
250
 
251
     First, symfile.c will subtract the VMA of the first .text section
252
     in the shared library that it finds.  Undo that.  */
253
  sec = bfd_get_section_by_name (tmp_bfd, ".text");
254
  text_addr += bfd_section_vma (tmp_bfd, sec);
255
 
256
  /* Now find the true lowest section in the shared library.  */
257
  sec = NULL;
258
  bfd_map_over_sections (tmp_bfd, find_lowest_section, (PTR) &sec);
259
 
260
  if (sec)
261
    {
262
      /* Subtract out the VMA of the lowest section.  */
263
      text_addr -= bfd_section_vma (tmp_bfd, sec);
264
 
265
      /* ??? Add back in the filepos of that lowest section. */
266
      text_addr += sec->filepos;
267
    }
268
 
269
  /* We are done with the temporary bfd.  Get rid of it and make sure
270
     nobody else can us it.  */
271
  bfd_close (tmp_bfd);
272
  tmp_bfd = NULL;
273
 
274
  /* Now let the generic code load up symbols for this library.  */
275
  section_addrs.text_addr = text_addr;
276
  so->objfile = symbol_file_add (name, from_tty, &section_addrs, 0, OBJF_SHARED);
277
  so->abfd = so->objfile->obfd;
278
 
279
  /* Mark this as a shared library and save private data.  */
280
  so->objfile->flags |= OBJF_SHARED;
281
 
282
  if (so->objfile->obj_private == NULL)
283
    {
284
      obj_private = (obj_private_data_t *)
285
        obstack_alloc (&so->objfile->psymbol_obstack,
286
                       sizeof (obj_private_data_t));
287
      obj_private->unwind_info = NULL;
288
      obj_private->so_info = NULL;
289
      so->objfile->obj_private = (PTR) obj_private;
290
    }
291
 
292
  obj_private = (obj_private_data_t *) so->objfile->obj_private;
293
  obj_private->so_info = so;
294
  obj_private->dp = so->pa64_solib_desc.linkage_ptr;
295
}
296
 
297
/* Load debugging information for a shared library.  TARGET may be
298
   NULL if we are not attaching to a process or reading a core file.  */
299
 
300
static void
301
pa64_solib_load_symbols (so, name, from_tty, text_addr, target)
302
     struct so_list *so;
303
     char *name;
304
     int from_tty;
305
     CORE_ADDR text_addr;
306
     struct target_ops *target;
307
{
308
  struct section_table *p;
309
  asection *sec;
310
  int status;
311
  char buf[4];
312
  CORE_ADDR presumed_data_start;
313
 
314
  if (text_addr == 0)
315
    text_addr = so->pa64_solib_desc.text_base;
316
 
317
  pa64_solib_add_solib_objfile (so, name, from_tty, text_addr);
318
 
319
  /* Now we need to build a section table for this library since
320
     we might be debugging a core file from a dynamically linked
321
     executable in which the libraries were not privately mapped.  */
322
  if (build_section_table (so->abfd,
323
                           &so->sections,
324
                           &so->sections_end))
325
    {
326
      error ("Unable to build section table for shared library\n.");
327
      return;
328
    }
329
 
330
  ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT)
331
    = so->pa64_solib_desc.text_base;
332
  ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA)
333
    = so->pa64_solib_desc.data_base;
334
 
335
  /* Relocate all the sections based on where they got loaded.  */
336
  for (p = so->sections; p < so->sections_end; p++)
337
    {
338
      if (p->the_bfd_section->flags & SEC_CODE)
339
        {
340
          p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT);
341
          p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_TEXT);
342
        }
343
      else if (p->the_bfd_section->flags & SEC_DATA)
344
        {
345
          p->addr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA);
346
          p->endaddr += ANOFFSET (so->objfile->section_offsets, SECT_OFF_DATA);
347
        }
348
    }
349
 
350
  /* Now see if we need to map in the text and data for this shared
351
     library (for example debugging a core file which does not use
352
     private shared libraries.).
353
 
354
     Carefully peek at the first text address in the library.  If the
355
     read succeeds, then the libraries were privately mapped and were
356
     included in the core dump file.
357
 
358
     If the peek failed, then the libraries were not privately mapped
359
     and are not in the core file, we'll have to read them in ourselves.  */
360
  status = target_read_memory (text_addr, buf, 4);
361
  if (status != 0)
362
    {
363
      int new, old;
364
 
365
      new = so->sections_end - so->sections;
366
 
367
      old = target_resize_to_sections (target, new);
368
 
369
      /* Copy over the old data before it gets clobbered.  */
370
      memcpy ((char *) (target->to_sections + old),
371
              so->sections,
372
              ((sizeof (struct section_table)) * new));
373
    }
374
}
375
 
376
 
377
/* Add symbols from shared libraries into the symtab list, unless the
378
   size threshold (specified by auto_solib_add, in megabytes) would
379
   be exceeded.  */
380
 
381
void
382
pa64_solib_add (arg_string, from_tty, target)
383
     char *arg_string;
384
     int from_tty;
385
     struct target_ops *target;
386
{
387
  struct minimal_symbol *msymbol;
388
  CORE_ADDR addr;
389
  asection *shlib_info;
390
  int status;
391
  unsigned int dld_flags;
392
  char buf[4], *re_err;
393
  int threshold_warning_given = 0;
394
  int dll_index;
395
  struct load_module_desc dll_desc;
396
  char *dll_path;
397
 
398
  /* First validate our arguments.  */
399
  if ((re_err = re_comp (arg_string ? arg_string : ".")) != NULL)
400
    {
401
      error ("Invalid regexp: %s", re_err);
402
    }
403
 
404
  /* If we're debugging a core file, or have attached to a running
405
     process, then pa64_solib_create_inferior_hook will not have been
406
     called.
407
 
408
     We need to first determine if we're dealing with a dynamically
409
     linked executable.  If not, then return without an error or warning.
410
 
411
     We also need to examine __dld_flags to determine if the shared library
412
     list is valid and to determine if the libraries have been privately
413
     mapped.  */
414
  if (symfile_objfile == NULL)
415
    return;
416
 
417
  /* First see if the objfile was dynamically linked.  */
418
  shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic");
419
  if (!shlib_info)
420
    return;
421
 
422
  /* It's got a .dynamic section, make sure it's not empty.  */
423
  if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
424
    return;
425
 
426
  /* Read in the load map pointer if we have not done so already.  */
427
  if (! dld_cache.have_read_dld_descriptor)
428
    if (! read_dld_descriptor (target))
429
      return;
430
 
431
  /* If the libraries were not mapped private, warn the user.  */
432
  if ((dld_cache.dld_flags & DT_HP_DEBUG_PRIVATE) == 0)
433
    warning ("The shared libraries were not privately mapped; setting a\nbreakpoint in a shared library will not work until you rerun the program.\n");
434
 
435
  /* For each shaerd library, add it to the shared library list.  */
436
  for (dll_index = 1; ; dll_index++)
437
    {
438
      /* Read in the load module descriptor.  */
439
      if (dlgetmodinfo (dll_index, &dll_desc, sizeof (dll_desc),
440
                        pa64_target_read_memory, 0, dld_cache.load_map)
441
          == 0)
442
        return;
443
 
444
      /* Get the name of the shared library.  */
445
      dll_path = (char *)dlgetname (&dll_desc, sizeof (dll_desc),
446
                            pa64_target_read_memory,
447
                            0, dld_cache.load_map);
448
 
449
      if (!dll_path)
450
        error ("pa64_solib_add, unable to read shared library path.");
451
 
452
      add_to_solist (from_tty, dll_path, &dll_desc, 0, target);
453
    }
454
}
455
 
456
 
457
/* This hook gets called just before the first instruction in the
458
   inferior process is executed.
459
 
460
   This is our opportunity to set magic flags in the inferior so
461
   that GDB can be notified when a shared library is mapped in and
462
   to tell the dynamic linker that a private copy of the library is
463
   needed (so GDB can set breakpoints in the library).
464
 
465
   We need to set two flag bits in this routine.
466
 
467
     DT_HP_DEBUG_PRIVATE to indicate that shared libraries should be
468
     mapped private.
469
 
470
     DT_HP_DEBUG_CALLBACK to indicate that we want the dynamic linker to
471
     call the breakpoint routine for significant events.  */
472
 
473
void
474
pa64_solib_create_inferior_hook ()
475
{
476
  struct minimal_symbol *msymbol;
477
  unsigned int dld_flags, status;
478
  asection *shlib_info, *interp_sect;
479
  char buf[4];
480
  struct objfile *objfile;
481
  CORE_ADDR anaddr;
482
 
483
  /* First, remove all the solib event breakpoints.  Their addresses
484
     may have changed since the last time we ran the program.  */
485
  remove_solib_event_breakpoints ();
486
 
487
  if (symfile_objfile == NULL)
488
    return;
489
 
490
  /* First see if the objfile was dynamically linked.  */
491
  shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, ".dynamic");
492
  if (!shlib_info)
493
    return;
494
 
495
  /* It's got a .dynamic section, make sure it's not empty.  */
496
  if (bfd_section_size (symfile_objfile->obfd, shlib_info) == 0)
497
    return;
498
 
499
  /* Read in the .dynamic section.  */
500
  if (! read_dynamic_info (shlib_info, &dld_cache))
501
    error ("Unable to read the .dynamic section.");
502
 
503
  /* Turn on the flags we care about.  */
504
  dld_cache.dld_flags |= DT_HP_DEBUG_PRIVATE;
505
  dld_cache.dld_flags |= DT_HP_DEBUG_CALLBACK;
506
  status = target_write_memory (dld_cache.dld_flags_addr,
507
                                (char *) &dld_cache.dld_flags,
508
                                sizeof (dld_cache.dld_flags));
509
  if (status != 0)
510
    error ("Unable to modify dynamic linker flags.");
511
 
512
  /* Now we have to create a shared library breakpoint in the dynamic
513
     linker.  This can be somewhat tricky since the symbol is inside
514
     the dynamic linker (for which we do not have symbols or a base
515
     load address!   Luckily I wrote this code for solib.c years ago.  */
516
  interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
517
  if (interp_sect)
518
    {
519
      unsigned int interp_sect_size;
520
      char *buf;
521
      CORE_ADDR load_addr;
522
      bfd *tmp_bfd;
523
      CORE_ADDR sym_addr = 0;
524
 
525
      /* Read the contents of the .interp section into a local buffer;
526
         the contents specify the dynamic linker this program uses.  */
527
      interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
528
      buf = alloca (interp_sect_size);
529
      bfd_get_section_contents (exec_bfd, interp_sect,
530
                                buf, 0, interp_sect_size);
531
 
532
      /* Now we need to figure out where the dynamic linker was
533
         loaded so that we can load its symbols and place a breakpoint
534
         in the dynamic linker itself.
535
 
536
         This address is stored on the stack.  However, I've been unable
537
         to find any magic formula to find it for Solaris (appears to
538
         be trivial on GNU/Linux).  Therefore, we have to try an alternate
539
         mechanism to find the dynamic linker's base address.  */
540
      tmp_bfd = bfd_openr (buf, gnutarget);
541
      if (tmp_bfd == NULL)
542
        goto get_out;
543
 
544
      /* Make sure the dynamic linker's really a useful object.  */
545
      if (!bfd_check_format (tmp_bfd, bfd_object))
546
        {
547
          warning ("Unable to grok dynamic linker %s as an object file", buf);
548
          bfd_close (tmp_bfd);
549
          goto get_out;
550
        }
551
 
552
      /* We find the dynamic linker's base address by examining the
553
         current pc (which point at the entry point for the dynamic
554
         linker) and subtracting the offset of the entry point.
555
 
556
         Also note the breakpoint is the second instruction in the
557
         routine.  */
558
      load_addr = read_pc () - tmp_bfd->start_address;
559
      sym_addr = bfd_lookup_symbol (tmp_bfd, "__dld_break");
560
      sym_addr = load_addr + sym_addr + 4;
561
 
562
      /* Create the shared library breakpoint.  */
563
      {
564
        struct breakpoint *b
565
          = create_solib_event_breakpoint (sym_addr);
566
 
567
        /* The breakpoint is actually hard-coded into the dynamic linker,
568
           so we don't need to actually insert a breakpoint instruction
569
           there.  In fact, the dynamic linker's code is immutable, even to
570
           ttrace, so we shouldn't even try to do that.  For cases like
571
           this, we have "permanent" breakpoints.  */
572
        make_breakpoint_permanent (b);
573
      }
574
 
575
      /* We're done with the temporary bfd.  */
576
      bfd_close (tmp_bfd);
577
    }
578
 
579
get_out:
580
  /* Wipe out all knowledge of old shared libraries since their
581
     mapping can change from one exec to another!  */
582
  while (so_list_head)
583
    {
584
      struct so_list *temp;
585
 
586
      temp = so_list_head;
587
      free (so_list_head);
588
      so_list_head = temp->next;
589
    }
590
  clear_symtab_users ();
591
}
592
 
593
/* This operation removes the "hook" between GDB and the dynamic linker,
594
   which causes the dld to notify GDB of shared library events.
595
 
596
   After this operation completes, the dld will no longer notify GDB of
597
   shared library events.  To resume notifications, GDB must call
598
   pa64_solib_create_inferior_hook.
599
 
600
   This operation does not remove any knowledge of shared libraries which
601
   GDB may already have been notified of.  */
602
 
603
void
604
pa64_solib_remove_inferior_hook (pid)
605
     int pid;
606
{
607
  /* Turn off the DT_HP_DEBUG_CALLBACK bit in the dynamic linker flags.  */
608
  dld_cache.dld_flags &= ~DT_HP_DEBUG_CALLBACK;
609
  target_write_memory (dld_cache.dld_flags_addr,
610
                       (char *)&dld_cache.dld_flags,
611
                       sizeof (dld_cache.dld_flags));
612
}
613
 
614
/* This function creates a breakpoint on the dynamic linker hook, which
615
   is called when e.g., a shl_load or shl_unload call is made.  This
616
   breakpoint will only trigger when a shl_load call is made.
617
 
618
   If filename is NULL, then loads of any dll will be caught.  Else,
619
   only loads of the file whose pathname is the string contained by
620
   filename will be caught.
621
 
622
   Undefined behaviour is guaranteed if this function is called before
623
   pa64_solib_create_inferior_hook.  */
624
 
625
void
626
pa64_solib_create_catch_load_hook (pid, tempflag, filename, cond_string)
627
     int pid;
628
     int tempflag;
629
     char *filename;
630
     char *cond_string;
631
{
632
  create_solib_load_event_breakpoint ("", tempflag, filename, cond_string);
633
}
634
 
635
/* This function creates a breakpoint on the dynamic linker hook, which
636
   is called when e.g., a shl_load or shl_unload call is made.  This
637
   breakpoint will only trigger when a shl_unload call is made.
638
 
639
   If filename is NULL, then unloads of any dll will be caught.  Else,
640
   only unloads of the file whose pathname is the string contained by
641
   filename will be caught.
642
 
643
   Undefined behaviour is guaranteed if this function is called before
644
   pa64_solib_create_inferior_hook.  */
645
 
646
void
647
pa64_solib_create_catch_unload_hook (pid, tempflag, filename, cond_string)
648
     int pid;
649
     int tempflag;
650
     char *filename;
651
     char *cond_string;
652
{
653
  create_solib_unload_event_breakpoint ("", tempflag, filename, cond_string);
654
}
655
 
656
/* Return nonzero if the dynamic linker has reproted that a library
657
   has been loaded.  */
658
 
659
int
660
pa64_solib_have_load_event (pid)
661
     int pid;
662
{
663
  CORE_ADDR event_kind;
664
 
665
  event_kind = read_register (ARG0_REGNUM);
666
  return (event_kind == DLD_CB_LOAD);
667
}
668
 
669
/* Return nonzero if the dynamic linker has reproted that a library
670
   has been unloaded.  */
671
int
672
pa64_solib_have_unload_event (pid)
673
     int pid;
674
{
675
  CORE_ADDR event_kind;
676
 
677
  event_kind = read_register (ARG0_REGNUM);
678
  return (event_kind == DLD_CB_UNLOAD);
679
}
680
 
681
/* Return a pointer to a string indicating the pathname of the most
682
   recently loaded library.
683
 
684
   The caller is reposible for copying the string before the inferior is
685
   restarted.  */
686
 
687
char *
688
pa64_solib_loaded_library_pathname (pid)
689
     int pid;
690
{
691
  static char dll_path[MAXPATHLEN];
692
  CORE_ADDR  dll_path_addr = read_register (ARG3_REGNUM);
693
  read_memory_string (dll_path_addr, dll_path, MAXPATHLEN);
694
  return dll_path;
695
}
696
 
697
/* Return a pointer to a string indicating the pathname of the most
698
   recently unloaded library.
699
 
700
   The caller is reposible for copying the string before the inferior is
701
   restarted.  */
702
 
703
char *
704
pa64_solib_unloaded_library_pathname (pid)
705
     int pid;
706
{
707
  static char dll_path[MAXPATHLEN];
708
  CORE_ADDR dll_path_addr = read_register (ARG3_REGNUM);
709
  read_memory_string (dll_path_addr, dll_path, MAXPATHLEN);
710
  return dll_path;
711
}
712
 
713
/* Return nonzero if PC is an address inside the dynamic linker.  */
714
 
715
int
716
pa64_solib_in_dynamic_linker (pid, pc)
717
     int pid;
718
     CORE_ADDR pc;
719
{
720
  asection *shlib_info;
721
 
722
  if (symfile_objfile == NULL)
723
    return 0;
724
 
725
  if (!dld_cache.have_read_dld_descriptor)
726
    if (!read_dld_descriptor (&current_target))
727
      return 0;
728
 
729
  return (pc >= dld_cache.dld_desc.text_base
730
          && pc < dld_cache.dld_desc.text_base + dld_cache.dld_desc.text_size);
731
}
732
 
733
 
734
/* Return the GOT value for the shared library in which ADDR belongs.  If
735
   ADDR isn't in any known shared library, return zero.  */
736
 
737
CORE_ADDR
738
pa64_solib_get_got_by_pc (addr)
739
     CORE_ADDR addr;
740
{
741
  struct so_list *so_list = so_list_head;
742
  CORE_ADDR got_value = 0;
743
 
744
  while (so_list)
745
    {
746
      if (so_list->pa64_solib_desc.text_base <= addr
747
          && ((so_list->pa64_solib_desc.text_base
748
               + so_list->pa64_solib_desc.text_size)
749
              > addr))
750
        {
751
          got_value = so_list->pa64_solib_desc.linkage_ptr;
752
          break;
753
        }
754
      so_list = so_list->next;
755
    }
756
  return got_value;
757
}
758
 
759
/* Return the address of the handle of the shared library in which ADDR
760
   belongs.  If ADDR isn't in any known shared library, return zero.
761
 
762
   This function is used in hppa_fix_call_dummy in hppa-tdep.c.  */
763
 
764
CORE_ADDR
765
pa64_solib_get_solib_by_pc (addr)
766
     CORE_ADDR addr;
767
{
768
  struct so_list *so_list = so_list_head;
769
  CORE_ADDR retval = 0;
770
 
771
  while (so_list)
772
    {
773
      if (so_list->pa64_solib_desc.text_base <= addr
774
          && ((so_list->pa64_solib_desc.text_base
775
               + so_list->pa64_solib_desc.text_size)
776
              > addr))
777
        {
778
          retval = so_list->pa64_solib_desc_addr;
779
          break;
780
        }
781
      so_list = so_list->next;
782
    }
783
  return retval;
784
}
785
 
786
/* Dump information about all the currently loaded shared libraries.  */
787
 
788
static void
789
pa64_sharedlibrary_info_command (ignore, from_tty)
790
     char *ignore;
791
     int from_tty;
792
{
793
  struct so_list *so_list = so_list_head;
794
 
795
  if (exec_bfd == NULL)
796
    {
797
      printf_unfiltered ("No executable file.\n");
798
      return;
799
    }
800
 
801
  if (so_list == NULL)
802
    {
803
      printf_unfiltered ("No shared libraries loaded at this time.\n");
804
      return;
805
    }
806
 
807
  printf_unfiltered ("Shared Object Libraries\n");
808
  printf_unfiltered ("   %-19s%-19s%-19s%-19s\n",
809
                     "  text start", "   text end",
810
                     "  data start", "   data end");
811
  while (so_list)
812
    {
813
      unsigned int flags;
814
 
815
      printf_unfiltered ("%s", so_list->name);
816
      if (so_list->objfile == NULL)
817
        printf_unfiltered ("  (symbols not loaded)");
818
      if (so_list->loaded == 0)
819
        printf_unfiltered ("  (shared library unloaded)");
820
      printf_unfiltered ("  %-18s",
821
        local_hex_string_custom (so_list->pa64_solib_desc.linkage_ptr,
822
                                 "016l"));
823
      printf_unfiltered ("\n");
824
      printf_unfiltered ("%-18s",
825
        local_hex_string_custom (so_list->pa64_solib_desc.text_base,
826
                                 "016l"));
827
      printf_unfiltered (" %-18s",
828
        local_hex_string_custom ((so_list->pa64_solib_desc.text_base
829
                                  + so_list->pa64_solib_desc.text_size),
830
                                 "016l"));
831
      printf_unfiltered (" %-18s",
832
        local_hex_string_custom (so_list->pa64_solib_desc.data_base,
833
                                 "016l"));
834
      printf_unfiltered (" %-18s\n",
835
        local_hex_string_custom ((so_list->pa64_solib_desc.data_base
836
                                  + so_list->pa64_solib_desc.data_size),
837
                                 "016l"));
838
      so_list = so_list->next;
839
    }
840
}
841
 
842
/* Load up one or more shared libraries as directed by the user.  */
843
 
844
static void
845
pa64_solib_sharedlibrary_command (args, from_tty)
846
     char *args;
847
     int from_tty;
848
{
849
  dont_repeat ();
850
  pa64_solib_add (args, from_tty, (struct target_ops *) 0);
851
}
852
 
853
/* Return the name of the shared library containing ADDR or NULL if ADDR
854
   is not contained in any known shared library.  */
855
 
856
char *
857
pa64_solib_address (addr)
858
     CORE_ADDR addr;
859
{
860
  struct so_list *so = so_list_head;
861
 
862
  while (so)
863
    {
864
      /* Is this address within this shlib's text range?  If so,
865
         return the shlib's name.  */
866
      if (addr >= so->pa64_solib_desc.text_base
867
          && addr < (so->pa64_solib_desc.text_base
868
                     | so->pa64_solib_desc.text_size))
869
        return so->name;
870
 
871
      /* Nope, keep looking... */
872
      so = so->next;
873
    }
874
 
875
  /* No, we couldn't prove that the address is within a shlib. */
876
  return NULL;
877
}
878
 
879
/* We are killing the inferior and restarting the program.  */
880
 
881
void
882
pa64_solib_restart ()
883
{
884
  struct so_list *sl = so_list_head;
885
 
886
  /* Before the shlib info vanishes, use it to disable any breakpoints
887
     that may still be active in those shlibs.  */
888
  disable_breakpoints_in_shlibs (0);
889
 
890
  /* Discard all the shlib descriptors.  */
891
  while (sl)
892
    {
893
      struct so_list *next_sl = sl->next;
894
      free (sl);
895
      sl = next_sl;
896
    }
897
  so_list_head = NULL;
898
 
899
  pa64_solib_total_st_size = (LONGEST) 0;
900
  pa64_solib_st_size_threshold_exceeded = 0;
901
 
902
  dld_cache.is_valid = 0;
903
  dld_cache.have_read_dld_descriptor = 0;
904
  dld_cache.dld_flags_addr = 0;
905
  dld_cache.load_map = 0;
906
  dld_cache.load_map_addr = 0;
907
  dld_cache.dld_desc.data_base = 0;
908
  dld_cache.dld_flags = 0;
909
  dld_cache.dyninfo_sect = 0;
910
}
911
 
912
void
913
_initialize_pa64_solib ()
914
{
915
  add_com ("sharedlibrary", class_files, pa64_solib_sharedlibrary_command,
916
           "Load shared object library symbols for files matching REGEXP.");
917
  add_info ("sharedlibrary", pa64_sharedlibrary_info_command,
918
            "Status of loaded shared object libraries.");
919
  add_show_from_set
920
    (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
921
                  (char *) &auto_solib_add,
922
                  "Set autoloading size threshold (in megabytes) of shared library symbols.\n\
923
If nonzero, symbols from all shared object libraries will be loaded\n\
924
automatically when the inferior begins execution or when the dynamic linker\n\
925
informs gdb that a new library has been loaded, until the symbol table\n\
926
of the program and libraries exceeds this threshold.\n\
927
Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
928
                  &setlist),
929
     &showlist);
930
 
931
  /* ??rehrauer: On HP-UX, the kernel parameter MAXDSIZ limits how much
932
     data space a process can use.  We ought to be reading MAXDSIZ and
933
     setting auto_solib_add to some large fraction of that value.  If
934
     not that, we maybe ought to be setting it smaller than the default
935
     for MAXDSIZ (that being 64Mb, I believe).  However, [1] this threshold
936
     is only crudely approximated rather than actually measured, and [2]
937
     50 Mbytes is too small for debugging gdb itself.  Thus, the arbitrary
938
     100 figure.
939
   */
940
  auto_solib_add = 100;         /* Megabytes */
941
 
942
  pa64_solib_restart ();
943
}
944
 
945
/* Get some HPUX-specific data from a shared lib.  */
946
CORE_ADDR
947
so_lib_thread_start_addr (so)
948
     struct so_list *so;
949
{
950
  return so->pa64_solib_desc.tls_start_addr;
951
}
952
 
953
/* Read the dynamic linker's internal shared library descriptor.
954
 
955
   This must happen after dld starts running, so we can't do it in
956
   read_dynamic_info.  Record the fact that we have loaded the
957
   descriptor.  If the library is archive bound, then return zero, else
958
   return nonzero.  */
959
 
960
static boolean
961
read_dld_descriptor (target)
962
     struct target_ops *target;
963
{
964
  char *dll_path;
965
  asection *dyninfo_sect;
966
 
967
  /* If necessary call read_dynamic_info to extract the contents of the
968
     .dynamic section from the shared library.  */
969
  if (!dld_cache.is_valid)
970
    {
971
      if (symfile_objfile == NULL)
972
        error ("No object file symbols.");
973
 
974
      dyninfo_sect = bfd_get_section_by_name (symfile_objfile->obfd,
975
                                              ".dynamic");
976
      if (!dyninfo_sect)
977
        {
978
          return 0;
979
        }
980
 
981
      if (!read_dynamic_info (dyninfo_sect, &dld_cache))
982
        error ("Unable to read in .dynamic section information.");
983
    }
984
 
985
  /* Read the load map pointer.  */
986
  if (target_read_memory (dld_cache.load_map_addr,
987
                          (char*) &dld_cache.load_map,
988
                          sizeof(dld_cache.load_map))
989
      != 0)
990
    {
991
      error ("Error while reading in load map pointer.");
992
    }
993
 
994
  /* Read in the dld load module descriptor */
995
  if (dlgetmodinfo (-1,
996
                    &dld_cache.dld_desc,
997
                    sizeof(dld_cache.dld_desc),
998
                    pa64_target_read_memory,
999
                    0,
1000
                    dld_cache.load_map)
1001
      == 0)
1002
    {
1003
      error ("Error trying to get information about dynamic linker.");
1004
    }
1005
 
1006
  /* Indicate that we have loaded the dld descriptor.  */
1007
  dld_cache.have_read_dld_descriptor = 1;
1008
 
1009
  /* Add dld.sl to the list of known shared libraries so that we can
1010
     do unwind, etc.
1011
 
1012
     ?!? This may not be correct.  Consider of dld.sl contains symbols
1013
     which are also referenced/defined by the user program or some user
1014
     shared library.  We need to make absolutely sure that we do not
1015
     pollute the namespace from GDB's point of view.  */
1016
  dll_path = dlgetname (&dld_cache.dld_desc,
1017
                        sizeof(dld_cache.dld_desc),
1018
                        pa64_target_read_memory,
1019
                        0,
1020
                        dld_cache.load_map);
1021
  add_to_solist(0, dll_path,  &dld_cache.dld_desc, 0, target);
1022
 
1023
  return 1;
1024
}
1025
 
1026
/* Read the .dynamic section and extract the information of interest,
1027
   which is stored in dld_cache.  The routine elf_locate_base in solib.c
1028
   was used as a model for this.  */
1029
 
1030
static boolean
1031
read_dynamic_info (dyninfo_sect, dld_cache_p)
1032
     asection *dyninfo_sect;
1033
     dld_cache_t *dld_cache_p;
1034
{
1035
  char *buf;
1036
  char *bufend;
1037
  CORE_ADDR dyninfo_addr;
1038
  int dyninfo_sect_size;
1039
  CORE_ADDR entry_addr;
1040
 
1041
  /* Read in .dynamic section, silently ignore errors.  */
1042
  dyninfo_addr = bfd_section_vma (symfile_objfile->obfd, dyninfo_sect);
1043
  dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
1044
  buf = alloca (dyninfo_sect_size);
1045
  if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
1046
    return 0;
1047
 
1048
  /* Scan the .dynamic section and record the items of interest.
1049
     In particular, DT_HP_DLD_FLAGS */
1050
  for (bufend = buf + dyninfo_sect_size, entry_addr = dyninfo_addr;
1051
       buf < bufend;
1052
       buf += sizeof (Elf64_Dyn), entry_addr += sizeof (Elf64_Dyn))
1053
    {
1054
      Elf64_Dyn *x_dynp = (Elf64_Dyn*)buf;
1055
      Elf64_Sxword dyn_tag;
1056
      CORE_ADDR dyn_ptr;
1057
      char pbuf[TARGET_PTR_BIT / HOST_CHAR_BIT];
1058
 
1059
      dyn_tag = bfd_h_get_64 (symfile_objfile->obfd,
1060
                              (bfd_byte*) &x_dynp->d_tag);
1061
 
1062
      /* We can't use a switch here because dyn_tag is 64 bits and HP's
1063
         lame comiler does not handle 64bit items in switch statements.  */
1064
      if (dyn_tag == DT_NULL)
1065
        break;
1066
      else if (dyn_tag == DT_HP_DLD_FLAGS)
1067
        {
1068
          /* Set dld_flags_addr and dld_flags in *dld_cache_p */
1069
          dld_cache_p->dld_flags_addr = entry_addr + offsetof(Elf64_Dyn, d_un);
1070
          if (target_read_memory (dld_cache_p->dld_flags_addr,
1071
                                  (char*) &dld_cache_p->dld_flags,
1072
                                  sizeof(dld_cache_p->dld_flags))
1073
              != 0)
1074
            {
1075
              error ("Error while reading in .dynamic section of the program.");
1076
            }
1077
        }
1078
      else if (dyn_tag == DT_HP_LOAD_MAP)
1079
        {
1080
          /* Dld will place the address of the load map at load_map_addr
1081
             after it starts running.  */
1082
          if (target_read_memory (entry_addr + offsetof(Elf64_Dyn,
1083
                                                        d_un.d_ptr),
1084
                                  (char*) &dld_cache_p->load_map_addr,
1085
                                  sizeof(dld_cache_p->load_map_addr))
1086
              != 0)
1087
            {
1088
              error ("Error while reading in .dynamic section of the program.");
1089
            }
1090
        }
1091
      else
1092
        {
1093
          /* tag is not of interest */
1094
        }
1095
    }
1096
 
1097
  /* Record other information and set is_valid to 1. */
1098
  dld_cache_p->dyninfo_sect = dyninfo_sect;
1099
 
1100
  /* Verify that we read in required info.  These fields are re-set to zero
1101
     in pa64_solib_restart.  */
1102
 
1103
  if (dld_cache_p->dld_flags_addr != 0 && dld_cache_p->load_map_addr != 0)
1104
    dld_cache_p->is_valid = 1;
1105
  else
1106
    return 0;
1107
 
1108
  return 1;
1109
}
1110
 
1111
/* Wrapper for target_read_memory to make dlgetmodinfo happy.  */
1112
 
1113
static void *
1114
pa64_target_read_memory (buffer, ptr, bufsiz, ident)
1115
     void *buffer;
1116
     CORE_ADDR ptr;
1117
     size_t bufsiz;
1118
     int ident;
1119
{
1120
  if (target_read_memory (ptr, buffer, bufsiz) != 0)
1121
    return 0;
1122
  return buffer;
1123
}
1124
 
1125
/* Called from handle_dynlink_load_event and pa64_solib_add to add
1126
   a shared library to so_list_head list and possibly to read in the
1127
   debug information for the library.
1128
 
1129
   If load_module_desc_p is NULL, then the load module descriptor must
1130
   be read from the inferior process at the address load_module_desc_addr.  */
1131
 
1132
static void
1133
add_to_solist (from_tty, dll_path, load_module_desc_p,
1134
               load_module_desc_addr, target)
1135
     boolean from_tty;
1136
     char *dll_path;
1137
     struct load_module_desc *load_module_desc_p;
1138
     CORE_ADDR load_module_desc_addr;
1139
     struct target_ops *target;
1140
{
1141
  struct so_list *new_so, *so_list_tail;
1142
  int pa64_solib_st_size_threshhold_exceeded;
1143
  LONGEST st_size;
1144
 
1145
  if (symfile_objfile == NULL)
1146
    return;
1147
 
1148
  so_list_tail = so_list_head;
1149
  /* Find the end of the list of shared objects.  */
1150
  while (so_list_tail && so_list_tail->next)
1151
    {
1152
      if (strcmp (so_list_tail->name, dll_path) == 0)
1153
        return;
1154
      so_list_tail = so_list_tail->next;
1155
    }
1156
 
1157
  if (so_list_tail && strcmp (so_list_tail->name, dll_path) == 0)
1158
    return;
1159
 
1160
  /* Add the shared library to the so_list_head list */
1161
  new_so = (struct so_list *) xmalloc (sizeof (struct so_list));
1162
  memset ((char *)new_so, 0, sizeof (struct so_list));
1163
  if (so_list_head == NULL)
1164
    {
1165
      so_list_head = new_so;
1166
      so_list_tail = new_so;
1167
    }
1168
  else
1169
    {
1170
      so_list_tail->next = new_so;
1171
      so_list_tail = new_so;
1172
    }
1173
 
1174
  /* Initialize the new_so */
1175
  if (load_module_desc_p)
1176
    {
1177
      new_so->pa64_solib_desc = *load_module_desc_p;
1178
    }
1179
  else
1180
    {
1181
      if (target_read_memory (load_module_desc_addr,
1182
                              (char*) &new_so->pa64_solib_desc,
1183
                              sizeof(struct load_module_desc))
1184
          != 0)
1185
      {
1186
        error ("Error while reading in dynamic library %s", dll_path);
1187
      }
1188
    }
1189
 
1190
  new_so->pa64_solib_desc_addr = load_module_desc_addr;
1191
  new_so->loaded = 1;
1192
  new_so->name = obsavestring (dll_path, strlen(dll_path),
1193
                               &symfile_objfile->symbol_obstack);
1194
 
1195
  /* If we are not going to load the library, tell the user if we
1196
     haven't already and return.  */
1197
 
1198
  st_size = pa64_solib_sizeof_symbol_table (dll_path);
1199
  pa64_solib_st_size_threshhold_exceeded =
1200
       !from_tty
1201
    && (  (st_size + pa64_solib_total_st_size)
1202
        > (auto_solib_add * (LONGEST)1000000));
1203
  if (pa64_solib_st_size_threshhold_exceeded)
1204
    {
1205
      pa64_solib_add_solib_objfile (new_so, dll_path, from_tty, 1);
1206
      return;
1207
    }
1208
 
1209
  /* Now read in debug info. */
1210
  pa64_solib_total_st_size += st_size;
1211
 
1212
  /* This fills in new_so->objfile, among others. */
1213
  pa64_solib_load_symbols (new_so,
1214
                           dll_path,
1215
                           from_tty,
1216
                           0);
1217
  return;
1218
}
1219
 
1220
 
1221
/*
1222
   LOCAL FUNCTION
1223
 
1224
   bfd_lookup_symbol -- lookup the value for a specific symbol
1225
 
1226
   SYNOPSIS
1227
 
1228
   CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
1229
 
1230
   DESCRIPTION
1231
 
1232
   An expensive way to lookup the value of a single symbol for
1233
   bfd's that are only temporary anyway.  This is used by the
1234
   shared library support to find the address of the debugger
1235
   interface structures in the shared library.
1236
 
1237
   Note that 0 is specifically allowed as an error return (no
1238
   such symbol).
1239
 */
1240
 
1241
static CORE_ADDR
1242
bfd_lookup_symbol (abfd, symname)
1243
     bfd *abfd;
1244
     char *symname;
1245
{
1246
  unsigned int storage_needed;
1247
  asymbol *sym;
1248
  asymbol **symbol_table;
1249
  unsigned int number_of_symbols;
1250
  unsigned int i;
1251
  struct cleanup *back_to;
1252
  CORE_ADDR symaddr = 0;
1253
 
1254
  storage_needed = bfd_get_symtab_upper_bound (abfd);
1255
 
1256
  if (storage_needed > 0)
1257
    {
1258
      symbol_table = (asymbol **) xmalloc (storage_needed);
1259
      back_to = make_cleanup (free, (PTR) symbol_table);
1260
      number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
1261
 
1262
      for (i = 0; i < number_of_symbols; i++)
1263
        {
1264
          sym = *symbol_table++;
1265
          if (STREQ (sym->name, symname))
1266
            {
1267
              /* Bfd symbols are section relative. */
1268
              symaddr = sym->value + sym->section->vma;
1269
              break;
1270
            }
1271
        }
1272
      do_cleanups (back_to);
1273
    }
1274
  return (symaddr);
1275
}
1276
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.