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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [solib-svr4.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Handle SVR4 shared libraries for GDB, the GNU Debugger.
2
 
3
   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
4
   2001, 2003, 2004, 2005, 2006, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
 
23
#include "elf/external.h"
24
#include "elf/common.h"
25
#include "elf/mips.h"
26
 
27
#include "symtab.h"
28
#include "bfd.h"
29
#include "symfile.h"
30
#include "objfiles.h"
31
#include "gdbcore.h"
32
#include "target.h"
33
#include "inferior.h"
34
 
35
#include "gdb_assert.h"
36
 
37
#include "solist.h"
38
#include "solib.h"
39
#include "solib-svr4.h"
40
 
41
#include "bfd-target.h"
42
#include "elf-bfd.h"
43
#include "exec.h"
44
#include "auxv.h"
45
 
46
static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
47
static int svr4_have_link_map_offsets (void);
48
 
49
/* Link map info to include in an allocated so_list entry */
50
 
51
struct lm_info
52
  {
53
    /* Pointer to copy of link map from inferior.  The type is char *
54
       rather than void *, so that we may use byte offsets to find the
55
       various fields without the need for a cast.  */
56
    gdb_byte *lm;
57
 
58
    /* Amount by which addresses in the binary should be relocated to
59
       match the inferior.  This could most often be taken directly
60
       from lm, but when prelinking is involved and the prelink base
61
       address changes, we may need a different offset, we want to
62
       warn about the difference and compute it only once.  */
63
    CORE_ADDR l_addr;
64
  };
65
 
66
/* On SVR4 systems, a list of symbols in the dynamic linker where
67
   GDB can try to place a breakpoint to monitor shared library
68
   events.
69
 
70
   If none of these symbols are found, or other errors occur, then
71
   SVR4 systems will fall back to using a symbol as the "startup
72
   mapping complete" breakpoint address.  */
73
 
74
static char *solib_break_names[] =
75
{
76
  "r_debug_state",
77
  "_r_debug_state",
78
  "_dl_debug_state",
79
  "rtld_db_dlactivity",
80
  "_rtld_debug_state",
81
 
82
  NULL
83
};
84
 
85
#define BKPT_AT_SYMBOL 1
86
 
87
#if defined (BKPT_AT_SYMBOL)
88
static char *bkpt_names[] =
89
{
90
#ifdef SOLIB_BKPT_NAME
91
  SOLIB_BKPT_NAME,              /* Prefer configured name if it exists. */
92
#endif
93
  "_start",
94
  "__start",
95
  "main",
96
  NULL
97
};
98
#endif
99
 
100
static char *main_name_list[] =
101
{
102
  "main_$main",
103
  NULL
104
};
105
 
106
/* link map access functions */
107
 
108
static CORE_ADDR
109
LM_ADDR_FROM_LINK_MAP (struct so_list *so)
110
{
111
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
112
 
113
  return extract_typed_address (so->lm_info->lm + lmo->l_addr_offset,
114
                                builtin_type_void_data_ptr);
115
}
116
 
117
static int
118
HAS_LM_DYNAMIC_FROM_LINK_MAP ()
119
{
120
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
121
 
122
  return lmo->l_ld_offset >= 0;
123
}
124
 
125
static CORE_ADDR
126
LM_DYNAMIC_FROM_LINK_MAP (struct so_list *so)
127
{
128
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
129
 
130
  return extract_typed_address (so->lm_info->lm + lmo->l_ld_offset,
131
                                builtin_type_void_data_ptr);
132
}
133
 
134
static CORE_ADDR
135
LM_ADDR_CHECK (struct so_list *so, bfd *abfd)
136
{
137
  if (so->lm_info->l_addr == (CORE_ADDR)-1)
138
    {
139
      struct bfd_section *dyninfo_sect;
140
      CORE_ADDR l_addr, l_dynaddr, dynaddr, align = 0x1000;
141
 
142
      l_addr = LM_ADDR_FROM_LINK_MAP (so);
143
 
144
      if (! abfd || ! HAS_LM_DYNAMIC_FROM_LINK_MAP ())
145
        goto set_addr;
146
 
147
      l_dynaddr = LM_DYNAMIC_FROM_LINK_MAP (so);
148
 
149
      dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic");
150
      if (dyninfo_sect == NULL)
151
        goto set_addr;
152
 
153
      dynaddr = bfd_section_vma (abfd, dyninfo_sect);
154
 
155
      if (dynaddr + l_addr != l_dynaddr)
156
        {
157
          if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
158
            {
159
              Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
160
              Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
161
              int i;
162
 
163
              align = 1;
164
 
165
              for (i = 0; i < ehdr->e_phnum; i++)
166
                if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
167
                  align = phdr[i].p_align;
168
            }
169
 
170
          /* Turn it into a mask.  */
171
          align--;
172
 
173
          /* If the changes match the alignment requirements, we
174
             assume we're using a core file that was generated by the
175
             same binary, just prelinked with a different base offset.
176
             If it doesn't match, we may have a different binary, the
177
             same binary with the dynamic table loaded at an unrelated
178
             location, or anything, really.  To avoid regressions,
179
             don't adjust the base offset in the latter case, although
180
             odds are that, if things really changed, debugging won't
181
             quite work.  */
182
          if ((l_addr & align) == ((l_dynaddr - dynaddr) & align))
183
            {
184
              l_addr = l_dynaddr - dynaddr;
185
 
186
              warning (_(".dynamic section for \"%s\" "
187
                     "is not at the expected address"), so->so_name);
188
              warning (_("difference appears to be caused by prelink, "
189
                         "adjusting expectations"));
190
            }
191
          else
192
            warning (_(".dynamic section for \"%s\" "
193
                       "is not at the expected address "
194
                       "(wrong library or version mismatch?)"), so->so_name);
195
        }
196
 
197
    set_addr:
198
      so->lm_info->l_addr = l_addr;
199
    }
200
 
201
  return so->lm_info->l_addr;
202
}
203
 
204
static CORE_ADDR
205
LM_NEXT (struct so_list *so)
206
{
207
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
208
 
209
  return extract_typed_address (so->lm_info->lm + lmo->l_next_offset,
210
                                builtin_type_void_data_ptr);
211
}
212
 
213
static CORE_ADDR
214
LM_NAME (struct so_list *so)
215
{
216
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
217
 
218
  return extract_typed_address (so->lm_info->lm + lmo->l_name_offset,
219
                                builtin_type_void_data_ptr);
220
}
221
 
222
static int
223
IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list *so)
224
{
225
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
226
 
227
  /* Assume that everything is a library if the dynamic loader was loaded
228
     late by a static executable.  */
229
  if (bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL)
230
    return 0;
231
 
232
  return extract_typed_address (so->lm_info->lm + lmo->l_prev_offset,
233
                                builtin_type_void_data_ptr) == 0;
234
}
235
 
236
static CORE_ADDR debug_base;    /* Base of dynamic linker structures */
237
 
238
/* Validity flag for debug_loader_offset.  */
239
static int debug_loader_offset_p;
240
 
241
/* Load address for the dynamic linker, inferred.  */
242
static CORE_ADDR debug_loader_offset;
243
 
244
/* Name of the dynamic linker, valid if debug_loader_offset_p.  */
245
static char *debug_loader_name;
246
 
247
/* Local function prototypes */
248
 
249
static int match_main (char *);
250
 
251
static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
252
 
253
/*
254
 
255
   LOCAL FUNCTION
256
 
257
   bfd_lookup_symbol -- lookup the value for a specific symbol
258
 
259
   SYNOPSIS
260
 
261
   CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
262
 
263
   DESCRIPTION
264
 
265
   An expensive way to lookup the value of a single symbol for
266
   bfd's that are only temporary anyway.  This is used by the
267
   shared library support to find the address of the debugger
268
   notification routine in the shared library.
269
 
270
   The returned symbol may be in a code or data section; functions
271
   will normally be in a code section, but may be in a data section
272
   if this architecture uses function descriptors.
273
 
274
   Note that 0 is specifically allowed as an error return (no
275
   such symbol).
276
 */
277
 
278
static CORE_ADDR
279
bfd_lookup_symbol (bfd *abfd, char *symname)
280
{
281
  long storage_needed;
282
  asymbol *sym;
283
  asymbol **symbol_table;
284
  unsigned int number_of_symbols;
285
  unsigned int i;
286
  struct cleanup *back_to;
287
  CORE_ADDR symaddr = 0;
288
 
289
  storage_needed = bfd_get_symtab_upper_bound (abfd);
290
 
291
  if (storage_needed > 0)
292
    {
293
      symbol_table = (asymbol **) xmalloc (storage_needed);
294
      back_to = make_cleanup (xfree, symbol_table);
295
      number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
296
 
297
      for (i = 0; i < number_of_symbols; i++)
298
        {
299
          sym = *symbol_table++;
300
          if (strcmp (sym->name, symname) == 0
301
              && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
302
            {
303
              /* BFD symbols are section relative.  */
304
              symaddr = sym->value + sym->section->vma;
305
              break;
306
            }
307
        }
308
      do_cleanups (back_to);
309
    }
310
 
311
  if (symaddr)
312
    return symaddr;
313
 
314
  /* On FreeBSD, the dynamic linker is stripped by default.  So we'll
315
     have to check the dynamic string table too.  */
316
 
317
  storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
318
 
319
  if (storage_needed > 0)
320
    {
321
      symbol_table = (asymbol **) xmalloc (storage_needed);
322
      back_to = make_cleanup (xfree, symbol_table);
323
      number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
324
 
325
      for (i = 0; i < number_of_symbols; i++)
326
        {
327
          sym = *symbol_table++;
328
 
329
          if (strcmp (sym->name, symname) == 0
330
              && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
331
            {
332
              /* BFD symbols are section relative.  */
333
              symaddr = sym->value + sym->section->vma;
334
              break;
335
            }
336
        }
337
      do_cleanups (back_to);
338
    }
339
 
340
  return symaddr;
341
}
342
 
343
/* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
344
   returned and the corresponding PTR is set.  */
345
 
346
static int
347
scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
348
{
349
  int arch_size, step, sect_size;
350
  long dyn_tag;
351
  CORE_ADDR dyn_ptr, dyn_addr;
352
  gdb_byte *bufend, *bufstart, *buf;
353
  Elf32_External_Dyn *x_dynp_32;
354
  Elf64_External_Dyn *x_dynp_64;
355
  struct bfd_section *sect;
356
 
357
  if (abfd == NULL)
358
    return 0;
359
  arch_size = bfd_get_arch_size (abfd);
360
  if (arch_size == -1)
361
   return 0;
362
 
363
  /* Find the start address of the .dynamic section.  */
364
  sect = bfd_get_section_by_name (abfd, ".dynamic");
365
  if (sect == NULL)
366
    return 0;
367
  dyn_addr = bfd_section_vma (abfd, sect);
368
 
369
  /* Read in .dynamic from the BFD.  We will get the actual value
370
     from memory later.  */
371
  sect_size = bfd_section_size (abfd, sect);
372
  buf = bufstart = alloca (sect_size);
373
  if (!bfd_get_section_contents (abfd, sect,
374
                                 buf, 0, sect_size))
375
    return 0;
376
 
377
  /* Iterate over BUF and scan for DYNTAG.  If found, set PTR and return.  */
378
  step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
379
                           : sizeof (Elf64_External_Dyn);
380
  for (bufend = buf + sect_size;
381
       buf < bufend;
382
       buf += step)
383
  {
384
    if (arch_size == 32)
385
      {
386
        x_dynp_32 = (Elf32_External_Dyn *) buf;
387
        dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
388
        dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
389
      }
390
    else
391
      {
392
        x_dynp_64 = (Elf64_External_Dyn *) buf;
393
        dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
394
        dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
395
      }
396
     if (dyn_tag == DT_NULL)
397
       return 0;
398
     if (dyn_tag == dyntag)
399
       {
400
         /* If requested, try to read the runtime value of this .dynamic
401
            entry.  */
402
         if (ptr)
403
           {
404
             gdb_byte ptr_buf[8];
405
             CORE_ADDR ptr_addr;
406
 
407
             ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
408
             if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
409
               dyn_ptr = extract_typed_address (ptr_buf,
410
                                                builtin_type_void_data_ptr);
411
             *ptr = dyn_ptr;
412
           }
413
         return 1;
414
       }
415
  }
416
 
417
  return 0;
418
}
419
 
420
 
421
/*
422
 
423
   LOCAL FUNCTION
424
 
425
   elf_locate_base -- locate the base address of dynamic linker structs
426
   for SVR4 elf targets.
427
 
428
   SYNOPSIS
429
 
430
   CORE_ADDR elf_locate_base (void)
431
 
432
   DESCRIPTION
433
 
434
   For SVR4 elf targets the address of the dynamic linker's runtime
435
   structure is contained within the dynamic info section in the
436
   executable file.  The dynamic section is also mapped into the
437
   inferior address space.  Because the runtime loader fills in the
438
   real address before starting the inferior, we have to read in the
439
   dynamic info section from the inferior address space.
440
   If there are any errors while trying to find the address, we
441
   silently return 0, otherwise the found address is returned.
442
 
443
 */
444
 
445
static CORE_ADDR
446
elf_locate_base (void)
447
{
448
  struct minimal_symbol *msymbol;
449
  CORE_ADDR dyn_ptr;
450
 
451
  /* Look for DT_MIPS_RLD_MAP first.  MIPS executables use this
452
     instead of DT_DEBUG, although they sometimes contain an unused
453
     DT_DEBUG.  */
454
  if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr))
455
    {
456
      gdb_byte *pbuf;
457
      int pbuf_size = TYPE_LENGTH (builtin_type_void_data_ptr);
458
      pbuf = alloca (pbuf_size);
459
      /* DT_MIPS_RLD_MAP contains a pointer to the address
460
         of the dynamic link structure.  */
461
      if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
462
        return 0;
463
      return extract_typed_address (pbuf, builtin_type_void_data_ptr);
464
    }
465
 
466
  /* Find DT_DEBUG.  */
467
  if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr))
468
    return dyn_ptr;
469
 
470
  /* This may be a static executable.  Look for the symbol
471
     conventionally named _r_debug, as a last resort.  */
472
  msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);
473
  if (msymbol != NULL)
474
    return SYMBOL_VALUE_ADDRESS (msymbol);
475
 
476
  /* DT_DEBUG entry not found.  */
477
  return 0;
478
}
479
 
480
/*
481
 
482
   LOCAL FUNCTION
483
 
484
   locate_base -- locate the base address of dynamic linker structs
485
 
486
   SYNOPSIS
487
 
488
   CORE_ADDR locate_base (void)
489
 
490
   DESCRIPTION
491
 
492
   For both the SunOS and SVR4 shared library implementations, if the
493
   inferior executable has been linked dynamically, there is a single
494
   address somewhere in the inferior's data space which is the key to
495
   locating all of the dynamic linker's runtime structures.  This
496
   address is the value of the debug base symbol.  The job of this
497
   function is to find and return that address, or to return 0 if there
498
   is no such address (the executable is statically linked for example).
499
 
500
   For SunOS, the job is almost trivial, since the dynamic linker and
501
   all of it's structures are statically linked to the executable at
502
   link time.  Thus the symbol for the address we are looking for has
503
   already been added to the minimal symbol table for the executable's
504
   objfile at the time the symbol file's symbols were read, and all we
505
   have to do is look it up there.  Note that we explicitly do NOT want
506
   to find the copies in the shared library.
507
 
508
   The SVR4 version is a bit more complicated because the address
509
   is contained somewhere in the dynamic info section.  We have to go
510
   to a lot more work to discover the address of the debug base symbol.
511
   Because of this complexity, we cache the value we find and return that
512
   value on subsequent invocations.  Note there is no copy in the
513
   executable symbol tables.
514
 
515
 */
516
 
517
static CORE_ADDR
518
locate_base (void)
519
{
520
  /* Check to see if we have a currently valid address, and if so, avoid
521
     doing all this work again and just return the cached address.  If
522
     we have no cached address, try to locate it in the dynamic info
523
     section for ELF executables.  There's no point in doing any of this
524
     though if we don't have some link map offsets to work with.  */
525
 
526
  if (debug_base == 0 && svr4_have_link_map_offsets ())
527
    {
528
      if (exec_bfd != NULL
529
          && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
530
        debug_base = elf_locate_base ();
531
    }
532
  return (debug_base);
533
}
534
 
535
/* Find the first element in the inferior's dynamic link map, and
536
   return its address in the inferior.
537
 
538
   FIXME: Perhaps we should validate the info somehow, perhaps by
539
   checking r_version for a known version number, or r_state for
540
   RT_CONSISTENT.  */
541
 
542
static CORE_ADDR
543
solib_svr4_r_map (void)
544
{
545
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
546
 
547
  return read_memory_typed_address (debug_base + lmo->r_map_offset,
548
                                    builtin_type_void_data_ptr);
549
}
550
 
551
/* Find r_brk from the inferior's debug base.  */
552
 
553
static CORE_ADDR
554
solib_svr4_r_brk (void)
555
{
556
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
557
 
558
  return read_memory_typed_address (debug_base + lmo->r_brk_offset,
559
                                    builtin_type_void_data_ptr);
560
}
561
 
562
/* Find the link map for the dynamic linker (if it is not in the
563
   normal list of loaded shared objects).  */
564
 
565
static CORE_ADDR
566
solib_svr4_r_ldsomap (void)
567
{
568
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
569
  ULONGEST version;
570
 
571
  /* Check version, and return zero if `struct r_debug' doesn't have
572
     the r_ldsomap member.  */
573
  version = read_memory_unsigned_integer (debug_base + lmo->r_version_offset,
574
                                          lmo->r_version_size);
575
  if (version < 2 || lmo->r_ldsomap_offset == -1)
576
    return 0;
577
 
578
  return read_memory_typed_address (debug_base + lmo->r_ldsomap_offset,
579
                                    builtin_type_void_data_ptr);
580
}
581
 
582
/*
583
 
584
  LOCAL FUNCTION
585
 
586
  open_symbol_file_object
587
 
588
  SYNOPSIS
589
 
590
  void open_symbol_file_object (void *from_tty)
591
 
592
  DESCRIPTION
593
 
594
  If no open symbol file, attempt to locate and open the main symbol
595
  file.  On SVR4 systems, this is the first link map entry.  If its
596
  name is here, we can open it.  Useful when attaching to a process
597
  without first loading its symbol file.
598
 
599
  If FROM_TTYP dereferences to a non-zero integer, allow messages to
600
  be printed.  This parameter is a pointer rather than an int because
601
  open_symbol_file_object() is called via catch_errors() and
602
  catch_errors() requires a pointer argument. */
603
 
604
static int
605
open_symbol_file_object (void *from_ttyp)
606
{
607
  CORE_ADDR lm, l_name;
608
  char *filename;
609
  int errcode;
610
  int from_tty = *(int *)from_ttyp;
611
  struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
612
  int l_name_size = TYPE_LENGTH (builtin_type_void_data_ptr);
613
  gdb_byte *l_name_buf = xmalloc (l_name_size);
614
  struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);
615
 
616
  if (symfile_objfile)
617
    if (!query ("Attempt to reload symbols from process? "))
618
      return 0;
619
 
620
  /* Always locate the debug struct, in case it has moved.  */
621
  debug_base = 0;
622
  if (locate_base () == 0)
623
    return 0;    /* failed somehow... */
624
 
625
  /* First link map member should be the executable.  */
626
  lm = solib_svr4_r_map ();
627
  if (lm == 0)
628
    return 0;    /* failed somehow... */
629
 
630
  /* Read address of name from target memory to GDB.  */
631
  read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size);
632
 
633
  /* Convert the address to host format.  */
634
  l_name = extract_typed_address (l_name_buf, builtin_type_void_data_ptr);
635
 
636
  /* Free l_name_buf.  */
637
  do_cleanups (cleanups);
638
 
639
  if (l_name == 0)
640
    return 0;            /* No filename.  */
641
 
642
  /* Now fetch the filename from target memory.  */
643
  target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
644
  make_cleanup (xfree, filename);
645
 
646
  if (errcode)
647
    {
648
      warning (_("failed to read exec filename from attached file: %s"),
649
               safe_strerror (errcode));
650
      return 0;
651
    }
652
 
653
  /* Have a pathname: read the symbol file.  */
654
  symbol_file_add_main (filename, from_tty);
655
 
656
  return 1;
657
}
658
 
659
/* If no shared library information is available from the dynamic
660
   linker, build a fallback list from other sources.  */
661
 
662
static struct so_list *
663
svr4_default_sos (void)
664
{
665
  struct so_list *head = NULL;
666
  struct so_list **link_ptr = &head;
667
 
668
  if (debug_loader_offset_p)
669
    {
670
      struct so_list *new = XZALLOC (struct so_list);
671
 
672
      new->lm_info = xmalloc (sizeof (struct lm_info));
673
 
674
      /* Nothing will ever check the cached copy of the link
675
         map if we set l_addr.  */
676
      new->lm_info->l_addr = debug_loader_offset;
677
      new->lm_info->lm = NULL;
678
 
679
      strncpy (new->so_name, debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1);
680
      new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
681
      strcpy (new->so_original_name, new->so_name);
682
 
683
      *link_ptr = new;
684
      link_ptr = &new->next;
685
    }
686
 
687
  return head;
688
}
689
 
690
/* LOCAL FUNCTION
691
 
692
   current_sos -- build a list of currently loaded shared objects
693
 
694
   SYNOPSIS
695
 
696
   struct so_list *current_sos ()
697
 
698
   DESCRIPTION
699
 
700
   Build a list of `struct so_list' objects describing the shared
701
   objects currently loaded in the inferior.  This list does not
702
   include an entry for the main executable file.
703
 
704
   Note that we only gather information directly available from the
705
   inferior --- we don't examine any of the shared library files
706
   themselves.  The declaration of `struct so_list' says which fields
707
   we provide values for.  */
708
 
709
static struct so_list *
710
svr4_current_sos (void)
711
{
712
  CORE_ADDR lm;
713
  struct so_list *head = 0;
714
  struct so_list **link_ptr = &head;
715
  CORE_ADDR ldsomap = 0;
716
 
717
  /* Always locate the debug struct, in case it has moved.  */
718
  debug_base = 0;
719
  locate_base ();
720
 
721
  /* If we can't find the dynamic linker's base structure, this
722
     must not be a dynamically linked executable.  Hmm.  */
723
  if (! debug_base)
724
    return svr4_default_sos ();
725
 
726
  /* Walk the inferior's link map list, and build our list of
727
     `struct so_list' nodes.  */
728
  lm = solib_svr4_r_map ();
729
 
730
  while (lm)
731
    {
732
      struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
733
      struct so_list *new = XZALLOC (struct so_list);
734
      struct cleanup *old_chain = make_cleanup (xfree, new);
735
 
736
      new->lm_info = xmalloc (sizeof (struct lm_info));
737
      make_cleanup (xfree, new->lm_info);
738
 
739
      new->lm_info->l_addr = (CORE_ADDR)-1;
740
      new->lm_info->lm = xzalloc (lmo->link_map_size);
741
      make_cleanup (xfree, new->lm_info->lm);
742
 
743
      read_memory (lm, new->lm_info->lm, lmo->link_map_size);
744
 
745
      lm = LM_NEXT (new);
746
 
747
      /* For SVR4 versions, the first entry in the link map is for the
748
         inferior executable, so we must ignore it.  For some versions of
749
         SVR4, it has no name.  For others (Solaris 2.3 for example), it
750
         does have a name, so we can no longer use a missing name to
751
         decide when to ignore it. */
752
      if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap == 0)
753
        free_so (new);
754
      else
755
        {
756
          int errcode;
757
          char *buffer;
758
 
759
          /* Extract this shared object's name.  */
760
          target_read_string (LM_NAME (new), &buffer,
761
                              SO_NAME_MAX_PATH_SIZE - 1, &errcode);
762
          if (errcode != 0)
763
            warning (_("Can't read pathname for load map: %s."),
764
                     safe_strerror (errcode));
765
          else
766
            {
767
              strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
768
              new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
769
              strcpy (new->so_original_name, new->so_name);
770
            }
771
          xfree (buffer);
772
 
773
          /* If this entry has no name, or its name matches the name
774
             for the main executable, don't include it in the list.  */
775
          if (! new->so_name[0]
776
              || match_main (new->so_name))
777
            free_so (new);
778
          else
779
            {
780
              new->next = 0;
781
              *link_ptr = new;
782
              link_ptr = &new->next;
783
            }
784
        }
785
 
786
      /* On Solaris, the dynamic linker is not in the normal list of
787
         shared objects, so make sure we pick it up too.  Having
788
         symbol information for the dynamic linker is quite crucial
789
         for skipping dynamic linker resolver code.  */
790
      if (lm == 0 && ldsomap == 0)
791
        lm = ldsomap = solib_svr4_r_ldsomap ();
792
 
793
      discard_cleanups (old_chain);
794
    }
795
 
796
  if (head == NULL)
797
    return svr4_default_sos ();
798
 
799
  return head;
800
}
801
 
802
/* Get the address of the link_map for a given OBJFILE.  Loop through
803
   the link maps, and return the address of the one corresponding to
804
   the given objfile.  Note that this function takes into account that
805
   objfile can be the main executable, not just a shared library.  The
806
   main executable has always an empty name field in the linkmap.  */
807
 
808
CORE_ADDR
809
svr4_fetch_objfile_link_map (struct objfile *objfile)
810
{
811
  CORE_ADDR lm;
812
 
813
  if (locate_base () == 0)
814
    return 0;   /* failed somehow... */
815
 
816
  /* Position ourselves on the first link map.  */
817
  lm = solib_svr4_r_map ();
818
  while (lm)
819
    {
820
      /* Get info on the layout of the r_debug and link_map structures. */
821
      struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
822
      int errcode;
823
      char *buffer;
824
      struct lm_info objfile_lm_info;
825
      struct cleanup *old_chain;
826
      CORE_ADDR name_address;
827
      int l_name_size = TYPE_LENGTH (builtin_type_void_data_ptr);
828
      gdb_byte *l_name_buf = xmalloc (l_name_size);
829
      old_chain = make_cleanup (xfree, l_name_buf);
830
 
831
      /* Set up the buffer to contain the portion of the link_map
832
         structure that gdb cares about.  Note that this is not the
833
         whole link_map structure.  */
834
      objfile_lm_info.lm = xzalloc (lmo->link_map_size);
835
      make_cleanup (xfree, objfile_lm_info.lm);
836
 
837
      /* Read the link map into our internal structure.  */
838
      read_memory (lm, objfile_lm_info.lm, lmo->link_map_size);
839
 
840
      /* Read address of name from target memory to GDB.  */
841
      read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size);
842
 
843
      /* Extract this object's name.  */
844
      name_address = extract_typed_address (l_name_buf,
845
                                            builtin_type_void_data_ptr);
846
      target_read_string (name_address, &buffer,
847
                          SO_NAME_MAX_PATH_SIZE - 1, &errcode);
848
      make_cleanup (xfree, buffer);
849
      if (errcode != 0)
850
        warning (_("Can't read pathname for load map: %s."),
851
                 safe_strerror (errcode));
852
      else
853
        {
854
          /* Is this the linkmap for the file we want?  */
855
          /* If the file is not a shared library and has no name,
856
             we are sure it is the main executable, so we return that.  */
857
 
858
          if (buffer
859
              && ((strcmp (buffer, objfile->name) == 0)
860
                  || (!(objfile->flags & OBJF_SHARED)
861
                      && (strcmp (buffer, "") == 0))))
862
            {
863
              do_cleanups (old_chain);
864
              return lm;
865
            }
866
        }
867
      /* Not the file we wanted, continue checking.  */
868
      lm = extract_typed_address (objfile_lm_info.lm + lmo->l_next_offset,
869
                                  builtin_type_void_data_ptr);
870
      do_cleanups (old_chain);
871
    }
872
  return 0;
873
}
874
 
875
/* On some systems, the only way to recognize the link map entry for
876
   the main executable file is by looking at its name.  Return
877
   non-zero iff SONAME matches one of the known main executable names.  */
878
 
879
static int
880
match_main (char *soname)
881
{
882
  char **mainp;
883
 
884
  for (mainp = main_name_list; *mainp != NULL; mainp++)
885
    {
886
      if (strcmp (soname, *mainp) == 0)
887
        return (1);
888
    }
889
 
890
  return (0);
891
}
892
 
893
/* Return 1 if PC lies in the dynamic symbol resolution code of the
894
   SVR4 run time loader.  */
895
static CORE_ADDR interp_text_sect_low;
896
static CORE_ADDR interp_text_sect_high;
897
static CORE_ADDR interp_plt_sect_low;
898
static CORE_ADDR interp_plt_sect_high;
899
 
900
int
901
svr4_in_dynsym_resolve_code (CORE_ADDR pc)
902
{
903
  return ((pc >= interp_text_sect_low && pc < interp_text_sect_high)
904
          || (pc >= interp_plt_sect_low && pc < interp_plt_sect_high)
905
          || in_plt_section (pc, NULL));
906
}
907
 
908
/* Given an executable's ABFD and target, compute the entry-point
909
   address.  */
910
 
911
static CORE_ADDR
912
exec_entry_point (struct bfd *abfd, struct target_ops *targ)
913
{
914
  /* KevinB wrote ... for most targets, the address returned by
915
     bfd_get_start_address() is the entry point for the start
916
     function.  But, for some targets, bfd_get_start_address() returns
917
     the address of a function descriptor from which the entry point
918
     address may be extracted.  This address is extracted by
919
     gdbarch_convert_from_func_ptr_addr().  The method
920
     gdbarch_convert_from_func_ptr_addr() is the merely the identify
921
     function for targets which don't use function descriptors.  */
922
  return gdbarch_convert_from_func_ptr_addr (current_gdbarch,
923
                                             bfd_get_start_address (abfd),
924
                                             targ);
925
}
926
 
927
/*
928
 
929
   LOCAL FUNCTION
930
 
931
   enable_break -- arrange for dynamic linker to hit breakpoint
932
 
933
   SYNOPSIS
934
 
935
   int enable_break (void)
936
 
937
   DESCRIPTION
938
 
939
   Both the SunOS and the SVR4 dynamic linkers have, as part of their
940
   debugger interface, support for arranging for the inferior to hit
941
   a breakpoint after mapping in the shared libraries.  This function
942
   enables that breakpoint.
943
 
944
   For SunOS, there is a special flag location (in_debugger) which we
945
   set to 1.  When the dynamic linker sees this flag set, it will set
946
   a breakpoint at a location known only to itself, after saving the
947
   original contents of that place and the breakpoint address itself,
948
   in it's own internal structures.  When we resume the inferior, it
949
   will eventually take a SIGTRAP when it runs into the breakpoint.
950
   We handle this (in a different place) by restoring the contents of
951
   the breakpointed location (which is only known after it stops),
952
   chasing around to locate the shared libraries that have been
953
   loaded, then resuming.
954
 
955
   For SVR4, the debugger interface structure contains a member (r_brk)
956
   which is statically initialized at the time the shared library is
957
   built, to the offset of a function (_r_debug_state) which is guaran-
958
   teed to be called once before mapping in a library, and again when
959
   the mapping is complete.  At the time we are examining this member,
960
   it contains only the unrelocated offset of the function, so we have
961
   to do our own relocation.  Later, when the dynamic linker actually
962
   runs, it relocates r_brk to be the actual address of _r_debug_state().
963
 
964
   The debugger interface structure also contains an enumeration which
965
   is set to either RT_ADD or RT_DELETE prior to changing the mapping,
966
   depending upon whether or not the library is being mapped or unmapped,
967
   and then set to RT_CONSISTENT after the library is mapped/unmapped.
968
 */
969
 
970
static int
971
enable_break (void)
972
{
973
#ifdef BKPT_AT_SYMBOL
974
 
975
  struct minimal_symbol *msymbol;
976
  char **bkpt_namep;
977
  asection *interp_sect;
978
  CORE_ADDR sym_addr;
979
 
980
  /* First, remove all the solib event breakpoints.  Their addresses
981
     may have changed since the last time we ran the program.  */
982
  remove_solib_event_breakpoints ();
983
 
984
  interp_text_sect_low = interp_text_sect_high = 0;
985
  interp_plt_sect_low = interp_plt_sect_high = 0;
986
 
987
  /* If we already have a shared library list in the target, and
988
     r_debug contains r_brk, set the breakpoint there - this should
989
     mean r_brk has already been relocated.  Assume the dynamic linker
990
     is the object containing r_brk.  */
991
 
992
  solib_add (NULL, 0, &current_target, auto_solib_add);
993
  sym_addr = 0;
994
  if (debug_base && solib_svr4_r_map () != 0)
995
    sym_addr = solib_svr4_r_brk ();
996
 
997
  if (sym_addr != 0)
998
    {
999
      struct obj_section *os;
1000
 
1001
      sym_addr = gdbarch_addr_bits_remove
1002
        (current_gdbarch, gdbarch_convert_from_func_ptr_addr (current_gdbarch,
1003
                                                              sym_addr,
1004
                                                              &current_target));
1005
 
1006
      os = find_pc_section (sym_addr);
1007
      if (os != NULL)
1008
        {
1009
          /* Record the relocated start and end address of the dynamic linker
1010
             text and plt section for svr4_in_dynsym_resolve_code.  */
1011
          bfd *tmp_bfd;
1012
          CORE_ADDR load_addr;
1013
 
1014
          tmp_bfd = os->objfile->obfd;
1015
          load_addr = ANOFFSET (os->objfile->section_offsets,
1016
                                os->objfile->sect_index_text);
1017
 
1018
          interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
1019
          if (interp_sect)
1020
            {
1021
              interp_text_sect_low =
1022
                bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1023
              interp_text_sect_high =
1024
                interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
1025
            }
1026
          interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
1027
          if (interp_sect)
1028
            {
1029
              interp_plt_sect_low =
1030
                bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1031
              interp_plt_sect_high =
1032
                interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
1033
            }
1034
 
1035
          create_solib_event_breakpoint (sym_addr);
1036
          return 1;
1037
        }
1038
    }
1039
 
1040
  /* Find the .interp section; if not found, warn the user and drop
1041
     into the old breakpoint at symbol code.  */
1042
  interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
1043
  if (interp_sect)
1044
    {
1045
      unsigned int interp_sect_size;
1046
      char *buf;
1047
      CORE_ADDR load_addr = 0;
1048
      int load_addr_found = 0;
1049
      int loader_found_in_list = 0;
1050
      struct so_list *so;
1051
      bfd *tmp_bfd = NULL;
1052
      struct target_ops *tmp_bfd_target;
1053
      int tmp_fd = -1;
1054
      char *tmp_pathname = NULL;
1055
 
1056
      /* Read the contents of the .interp section into a local buffer;
1057
         the contents specify the dynamic linker this program uses.  */
1058
      sym_addr = 0;
1059
      interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
1060
      buf = alloca (interp_sect_size);
1061
      bfd_get_section_contents (exec_bfd, interp_sect,
1062
                                buf, 0, interp_sect_size);
1063
 
1064
      /* Now we need to figure out where the dynamic linker was
1065
         loaded so that we can load its symbols and place a breakpoint
1066
         in the dynamic linker itself.
1067
 
1068
         This address is stored on the stack.  However, I've been unable
1069
         to find any magic formula to find it for Solaris (appears to
1070
         be trivial on GNU/Linux).  Therefore, we have to try an alternate
1071
         mechanism to find the dynamic linker's base address.  */
1072
 
1073
      tmp_fd = solib_open (buf, &tmp_pathname);
1074
      if (tmp_fd >= 0)
1075
        tmp_bfd = bfd_fopen (tmp_pathname, gnutarget, FOPEN_RB, tmp_fd);
1076
 
1077
      if (tmp_bfd == NULL)
1078
        goto bkpt_at_symbol;
1079
 
1080
      /* Make sure the dynamic linker's really a useful object.  */
1081
      if (!bfd_check_format (tmp_bfd, bfd_object))
1082
        {
1083
          warning (_("Unable to grok dynamic linker %s as an object file"), buf);
1084
          bfd_close (tmp_bfd);
1085
          goto bkpt_at_symbol;
1086
        }
1087
 
1088
      /* Now convert the TMP_BFD into a target.  That way target, as
1089
         well as BFD operations can be used.  Note that closing the
1090
         target will also close the underlying bfd.  */
1091
      tmp_bfd_target = target_bfd_reopen (tmp_bfd);
1092
 
1093
      /* On a running target, we can get the dynamic linker's base
1094
         address from the shared library table.  */
1095
      so = master_so_list ();
1096
      while (so)
1097
        {
1098
          if (strcmp (buf, so->so_original_name) == 0)
1099
            {
1100
              load_addr_found = 1;
1101
              loader_found_in_list = 1;
1102
              load_addr = LM_ADDR_CHECK (so, tmp_bfd);
1103
              break;
1104
            }
1105
          so = so->next;
1106
        }
1107
 
1108
      /* If we were not able to find the base address of the loader
1109
         from our so_list, then try using the AT_BASE auxilliary entry.  */
1110
      if (!load_addr_found)
1111
        if (target_auxv_search (&current_target, AT_BASE, &load_addr) > 0)
1112
          load_addr_found = 1;
1113
 
1114
      /* Otherwise we find the dynamic linker's base address by examining
1115
         the current pc (which should point at the entry point for the
1116
         dynamic linker) and subtracting the offset of the entry point.
1117
 
1118
         This is more fragile than the previous approaches, but is a good
1119
         fallback method because it has actually been working well in
1120
         most cases.  */
1121
      if (!load_addr_found)
1122
        load_addr = (read_pc ()
1123
                     - exec_entry_point (tmp_bfd, tmp_bfd_target));
1124
 
1125
      if (!loader_found_in_list)
1126
        {
1127
          debug_loader_name = xstrdup (buf);
1128
          debug_loader_offset_p = 1;
1129
          debug_loader_offset = load_addr;
1130
          solib_add (NULL, 0, &current_target, auto_solib_add);
1131
        }
1132
 
1133
      /* Record the relocated start and end address of the dynamic linker
1134
         text and plt section for svr4_in_dynsym_resolve_code.  */
1135
      interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
1136
      if (interp_sect)
1137
        {
1138
          interp_text_sect_low =
1139
            bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1140
          interp_text_sect_high =
1141
            interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
1142
        }
1143
      interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
1144
      if (interp_sect)
1145
        {
1146
          interp_plt_sect_low =
1147
            bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1148
          interp_plt_sect_high =
1149
            interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
1150
        }
1151
 
1152
      /* Now try to set a breakpoint in the dynamic linker.  */
1153
      for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
1154
        {
1155
          sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep);
1156
          if (sym_addr != 0)
1157
            break;
1158
        }
1159
 
1160
      if (sym_addr != 0)
1161
        /* Convert 'sym_addr' from a function pointer to an address.
1162
           Because we pass tmp_bfd_target instead of the current
1163
           target, this will always produce an unrelocated value.  */
1164
        sym_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
1165
                                                       sym_addr,
1166
                                                       tmp_bfd_target);
1167
 
1168
      /* We're done with both the temporary bfd and target.  Remember,
1169
         closing the target closes the underlying bfd.  */
1170
      target_close (tmp_bfd_target, 0);
1171
 
1172
      if (sym_addr != 0)
1173
        {
1174
          create_solib_event_breakpoint (load_addr + sym_addr);
1175
          return 1;
1176
        }
1177
 
1178
      /* For whatever reason we couldn't set a breakpoint in the dynamic
1179
         linker.  Warn and drop into the old code.  */
1180
    bkpt_at_symbol:
1181
      xfree (tmp_pathname);
1182
      warning (_("Unable to find dynamic linker breakpoint function.\n"
1183
               "GDB will be unable to debug shared library initializers\n"
1184
               "and track explicitly loaded dynamic code."));
1185
    }
1186
 
1187
  /* Scan through the lists of symbols, trying to look up the symbol and
1188
     set a breakpoint there.  Terminate loop when we/if we succeed.  */
1189
 
1190
  for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
1191
    {
1192
      msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
1193
      if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
1194
        {
1195
          create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
1196
          return 1;
1197
        }
1198
    }
1199
 
1200
  for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
1201
    {
1202
      msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
1203
      if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
1204
        {
1205
          create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
1206
          return 1;
1207
        }
1208
    }
1209
#endif /* BKPT_AT_SYMBOL */
1210
 
1211
  return 0;
1212
}
1213
 
1214
/*
1215
 
1216
   LOCAL FUNCTION
1217
 
1218
   special_symbol_handling -- additional shared library symbol handling
1219
 
1220
   SYNOPSIS
1221
 
1222
   void special_symbol_handling ()
1223
 
1224
   DESCRIPTION
1225
 
1226
   Once the symbols from a shared object have been loaded in the usual
1227
   way, we are called to do any system specific symbol handling that
1228
   is needed.
1229
 
1230
   For SunOS4, this consisted of grunging around in the dynamic
1231
   linkers structures to find symbol definitions for "common" symbols
1232
   and adding them to the minimal symbol table for the runtime common
1233
   objfile.
1234
 
1235
   However, for SVR4, there's nothing to do.
1236
 
1237
 */
1238
 
1239
static void
1240
svr4_special_symbol_handling (void)
1241
{
1242
}
1243
 
1244
/* Relocate the main executable.  This function should be called upon
1245
   stopping the inferior process at the entry point to the program.
1246
   The entry point from BFD is compared to the PC and if they are
1247
   different, the main executable is relocated by the proper amount.
1248
 
1249
   As written it will only attempt to relocate executables which
1250
   lack interpreter sections.  It seems likely that only dynamic
1251
   linker executables will get relocated, though it should work
1252
   properly for a position-independent static executable as well.  */
1253
 
1254
static void
1255
svr4_relocate_main_executable (void)
1256
{
1257
  asection *interp_sect;
1258
  CORE_ADDR pc = read_pc ();
1259
 
1260
  /* Decide if the objfile needs to be relocated.  As indicated above,
1261
     we will only be here when execution is stopped at the beginning
1262
     of the program.  Relocation is necessary if the address at which
1263
     we are presently stopped differs from the start address stored in
1264
     the executable AND there's no interpreter section.  The condition
1265
     regarding the interpreter section is very important because if
1266
     there *is* an interpreter section, execution will begin there
1267
     instead.  When there is an interpreter section, the start address
1268
     is (presumably) used by the interpreter at some point to start
1269
     execution of the program.
1270
 
1271
     If there is an interpreter, it is normal for it to be set to an
1272
     arbitrary address at the outset.  The job of finding it is
1273
     handled in enable_break().
1274
 
1275
     So, to summarize, relocations are necessary when there is no
1276
     interpreter section and the start address obtained from the
1277
     executable is different from the address at which GDB is
1278
     currently stopped.
1279
 
1280
     [ The astute reader will note that we also test to make sure that
1281
       the executable in question has the DYNAMIC flag set.  It is my
1282
       opinion that this test is unnecessary (undesirable even).  It
1283
       was added to avoid inadvertent relocation of an executable
1284
       whose e_type member in the ELF header is not ET_DYN.  There may
1285
       be a time in the future when it is desirable to do relocations
1286
       on other types of files as well in which case this condition
1287
       should either be removed or modified to accomodate the new file
1288
       type.  (E.g, an ET_EXEC executable which has been built to be
1289
       position-independent could safely be relocated by the OS if
1290
       desired.  It is true that this violates the ABI, but the ABI
1291
       has been known to be bent from time to time.)  - Kevin, Nov 2000. ]
1292
     */
1293
 
1294
  interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
1295
  if (interp_sect == NULL
1296
      && (bfd_get_file_flags (exec_bfd) & DYNAMIC) != 0
1297
      && (exec_entry_point (exec_bfd, &exec_ops) != pc))
1298
    {
1299
      struct cleanup *old_chain;
1300
      struct section_offsets *new_offsets;
1301
      int i, changed;
1302
      CORE_ADDR displacement;
1303
 
1304
      /* It is necessary to relocate the objfile.  The amount to
1305
         relocate by is simply the address at which we are stopped
1306
         minus the starting address from the executable.
1307
 
1308
         We relocate all of the sections by the same amount.  This
1309
         behavior is mandated by recent editions of the System V ABI.
1310
         According to the System V Application Binary Interface,
1311
         Edition 4.1, page 5-5:
1312
 
1313
           ...  Though the system chooses virtual addresses for
1314
           individual processes, it maintains the segments' relative
1315
           positions.  Because position-independent code uses relative
1316
           addressesing between segments, the difference between
1317
           virtual addresses in memory must match the difference
1318
           between virtual addresses in the file.  The difference
1319
           between the virtual address of any segment in memory and
1320
           the corresponding virtual address in the file is thus a
1321
           single constant value for any one executable or shared
1322
           object in a given process.  This difference is the base
1323
           address.  One use of the base address is to relocate the
1324
           memory image of the program during dynamic linking.
1325
 
1326
         The same language also appears in Edition 4.0 of the System V
1327
         ABI and is left unspecified in some of the earlier editions.  */
1328
 
1329
      displacement = pc - exec_entry_point (exec_bfd, &exec_ops);
1330
      changed = 0;
1331
 
1332
      new_offsets = xcalloc (symfile_objfile->num_sections,
1333
                             sizeof (struct section_offsets));
1334
      old_chain = make_cleanup (xfree, new_offsets);
1335
 
1336
      for (i = 0; i < symfile_objfile->num_sections; i++)
1337
        {
1338
          if (displacement != ANOFFSET (symfile_objfile->section_offsets, i))
1339
            changed = 1;
1340
          new_offsets->offsets[i] = displacement;
1341
        }
1342
 
1343
      if (changed)
1344
        objfile_relocate (symfile_objfile, new_offsets);
1345
 
1346
      do_cleanups (old_chain);
1347
    }
1348
}
1349
 
1350
/*
1351
 
1352
   GLOBAL FUNCTION
1353
 
1354
   svr4_solib_create_inferior_hook -- shared library startup support
1355
 
1356
   SYNOPSIS
1357
 
1358
   void svr4_solib_create_inferior_hook ()
1359
 
1360
   DESCRIPTION
1361
 
1362
   When gdb starts up the inferior, it nurses it along (through the
1363
   shell) until it is ready to execute it's first instruction.  At this
1364
   point, this function gets called via expansion of the macro
1365
   SOLIB_CREATE_INFERIOR_HOOK.
1366
 
1367
   For SunOS executables, this first instruction is typically the
1368
   one at "_start", or a similar text label, regardless of whether
1369
   the executable is statically or dynamically linked.  The runtime
1370
   startup code takes care of dynamically linking in any shared
1371
   libraries, once gdb allows the inferior to continue.
1372
 
1373
   For SVR4 executables, this first instruction is either the first
1374
   instruction in the dynamic linker (for dynamically linked
1375
   executables) or the instruction at "start" for statically linked
1376
   executables.  For dynamically linked executables, the system
1377
   first exec's /lib/libc.so.N, which contains the dynamic linker,
1378
   and starts it running.  The dynamic linker maps in any needed
1379
   shared libraries, maps in the actual user executable, and then
1380
   jumps to "start" in the user executable.
1381
 
1382
   For both SunOS shared libraries, and SVR4 shared libraries, we
1383
   can arrange to cooperate with the dynamic linker to discover the
1384
   names of shared libraries that are dynamically linked, and the
1385
   base addresses to which they are linked.
1386
 
1387
   This function is responsible for discovering those names and
1388
   addresses, and saving sufficient information about them to allow
1389
   their symbols to be read at a later time.
1390
 
1391
   FIXME
1392
 
1393
   Between enable_break() and disable_break(), this code does not
1394
   properly handle hitting breakpoints which the user might have
1395
   set in the startup code or in the dynamic linker itself.  Proper
1396
   handling will probably have to wait until the implementation is
1397
   changed to use the "breakpoint handler function" method.
1398
 
1399
   Also, what if child has exit()ed?  Must exit loop somehow.
1400
 */
1401
 
1402
static void
1403
svr4_solib_create_inferior_hook (void)
1404
{
1405
  /* Relocate the main executable if necessary.  */
1406
  svr4_relocate_main_executable ();
1407
 
1408
  if (!svr4_have_link_map_offsets ())
1409
    return;
1410
 
1411
  if (!enable_break ())
1412
    return;
1413
 
1414
#if defined(_SCO_DS)
1415
  /* SCO needs the loop below, other systems should be using the
1416
     special shared library breakpoints and the shared library breakpoint
1417
     service routine.
1418
 
1419
     Now run the target.  It will eventually hit the breakpoint, at
1420
     which point all of the libraries will have been mapped in and we
1421
     can go groveling around in the dynamic linker structures to find
1422
     out what we need to know about them. */
1423
 
1424
  clear_proceed_status ();
1425
  stop_soon = STOP_QUIETLY;
1426
  stop_signal = TARGET_SIGNAL_0;
1427
  do
1428
    {
1429
      target_resume (pid_to_ptid (-1), 0, stop_signal);
1430
      wait_for_inferior (0);
1431
    }
1432
  while (stop_signal != TARGET_SIGNAL_TRAP);
1433
  stop_soon = NO_STOP_QUIETLY;
1434
#endif /* defined(_SCO_DS) */
1435
}
1436
 
1437
static void
1438
svr4_clear_solib (void)
1439
{
1440
  debug_base = 0;
1441
  debug_loader_offset_p = 0;
1442
  debug_loader_offset = 0;
1443
  xfree (debug_loader_name);
1444
  debug_loader_name = NULL;
1445
}
1446
 
1447
static void
1448
svr4_free_so (struct so_list *so)
1449
{
1450
  xfree (so->lm_info->lm);
1451
  xfree (so->lm_info);
1452
}
1453
 
1454
 
1455
/* Clear any bits of ADDR that wouldn't fit in a target-format
1456
   data pointer.  "Data pointer" here refers to whatever sort of
1457
   address the dynamic linker uses to manage its sections.  At the
1458
   moment, we don't support shared libraries on any processors where
1459
   code and data pointers are different sizes.
1460
 
1461
   This isn't really the right solution.  What we really need here is
1462
   a way to do arithmetic on CORE_ADDR values that respects the
1463
   natural pointer/address correspondence.  (For example, on the MIPS,
1464
   converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
1465
   sign-extend the value.  There, simply truncating the bits above
1466
   gdbarch_ptr_bit, as we do below, is no good.)  This should probably
1467
   be a new gdbarch method or something.  */
1468
static CORE_ADDR
1469
svr4_truncate_ptr (CORE_ADDR addr)
1470
{
1471
  if (gdbarch_ptr_bit (current_gdbarch) == sizeof (CORE_ADDR) * 8)
1472
    /* We don't need to truncate anything, and the bit twiddling below
1473
       will fail due to overflow problems.  */
1474
    return addr;
1475
  else
1476
    return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (current_gdbarch)) - 1);
1477
}
1478
 
1479
 
1480
static void
1481
svr4_relocate_section_addresses (struct so_list *so,
1482
                                 struct section_table *sec)
1483
{
1484
  sec->addr    = svr4_truncate_ptr (sec->addr    + LM_ADDR_CHECK (so,
1485
                                                                  sec->bfd));
1486
  sec->endaddr = svr4_truncate_ptr (sec->endaddr + LM_ADDR_CHECK (so,
1487
                                                                  sec->bfd));
1488
}
1489
 
1490
 
1491
/* Architecture-specific operations.  */
1492
 
1493
/* Per-architecture data key.  */
1494
static struct gdbarch_data *solib_svr4_data;
1495
 
1496
struct solib_svr4_ops
1497
{
1498
  /* Return a description of the layout of `struct link_map'.  */
1499
  struct link_map_offsets *(*fetch_link_map_offsets)(void);
1500
};
1501
 
1502
/* Return a default for the architecture-specific operations.  */
1503
 
1504
static void *
1505
solib_svr4_init (struct obstack *obstack)
1506
{
1507
  struct solib_svr4_ops *ops;
1508
 
1509
  ops = OBSTACK_ZALLOC (obstack, struct solib_svr4_ops);
1510
  ops->fetch_link_map_offsets = NULL;
1511
  return ops;
1512
}
1513
 
1514
/* Set the architecture-specific `struct link_map_offsets' fetcher for
1515
   GDBARCH to FLMO.  Also, install SVR4 solib_ops into GDBARCH.  */
1516
 
1517
void
1518
set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch,
1519
                                       struct link_map_offsets *(*flmo) (void))
1520
{
1521
  struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data);
1522
 
1523
  ops->fetch_link_map_offsets = flmo;
1524
 
1525
  set_solib_ops (gdbarch, &svr4_so_ops);
1526
}
1527
 
1528
/* Fetch a link_map_offsets structure using the architecture-specific
1529
   `struct link_map_offsets' fetcher.  */
1530
 
1531
static struct link_map_offsets *
1532
svr4_fetch_link_map_offsets (void)
1533
{
1534
  struct solib_svr4_ops *ops = gdbarch_data (current_gdbarch, solib_svr4_data);
1535
 
1536
  gdb_assert (ops->fetch_link_map_offsets);
1537
  return ops->fetch_link_map_offsets ();
1538
}
1539
 
1540
/* Return 1 if a link map offset fetcher has been defined, 0 otherwise.  */
1541
 
1542
static int
1543
svr4_have_link_map_offsets (void)
1544
{
1545
  struct solib_svr4_ops *ops = gdbarch_data (current_gdbarch, solib_svr4_data);
1546
  return (ops->fetch_link_map_offsets != NULL);
1547
}
1548
 
1549
 
1550
/* Most OS'es that have SVR4-style ELF dynamic libraries define a
1551
   `struct r_debug' and a `struct link_map' that are binary compatible
1552
   with the origional SVR4 implementation.  */
1553
 
1554
/* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1555
   for an ILP32 SVR4 system.  */
1556
 
1557
struct link_map_offsets *
1558
svr4_ilp32_fetch_link_map_offsets (void)
1559
{
1560
  static struct link_map_offsets lmo;
1561
  static struct link_map_offsets *lmp = NULL;
1562
 
1563
  if (lmp == NULL)
1564
    {
1565
      lmp = &lmo;
1566
 
1567
      lmo.r_version_offset = 0;
1568
      lmo.r_version_size = 4;
1569
      lmo.r_map_offset = 4;
1570
      lmo.r_brk_offset = 8;
1571
      lmo.r_ldsomap_offset = 20;
1572
 
1573
      /* Everything we need is in the first 20 bytes.  */
1574
      lmo.link_map_size = 20;
1575
      lmo.l_addr_offset = 0;
1576
      lmo.l_name_offset = 4;
1577
      lmo.l_ld_offset = 8;
1578
      lmo.l_next_offset = 12;
1579
      lmo.l_prev_offset = 16;
1580
    }
1581
 
1582
  return lmp;
1583
}
1584
 
1585
/* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1586
   for an LP64 SVR4 system.  */
1587
 
1588
struct link_map_offsets *
1589
svr4_lp64_fetch_link_map_offsets (void)
1590
{
1591
  static struct link_map_offsets lmo;
1592
  static struct link_map_offsets *lmp = NULL;
1593
 
1594
  if (lmp == NULL)
1595
    {
1596
      lmp = &lmo;
1597
 
1598
      lmo.r_version_offset = 0;
1599
      lmo.r_version_size = 4;
1600
      lmo.r_map_offset = 8;
1601
      lmo.r_brk_offset = 16;
1602
      lmo.r_ldsomap_offset = 40;
1603
 
1604
      /* Everything we need is in the first 40 bytes.  */
1605
      lmo.link_map_size = 40;
1606
      lmo.l_addr_offset = 0;
1607
      lmo.l_name_offset = 8;
1608
      lmo.l_ld_offset = 16;
1609
      lmo.l_next_offset = 24;
1610
      lmo.l_prev_offset = 32;
1611
    }
1612
 
1613
  return lmp;
1614
}
1615
 
1616
 
1617
struct target_so_ops svr4_so_ops;
1618
 
1619
/* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
1620
   different rule for symbol lookup.  The lookup begins here in the DSO, not in
1621
   the main executable.  */
1622
 
1623
static struct symbol *
1624
elf_lookup_lib_symbol (const struct objfile *objfile,
1625
                       const char *name,
1626
                       const char *linkage_name,
1627
                       const domain_enum domain, struct symtab **symtab)
1628
{
1629
  if (objfile->obfd == NULL
1630
     || scan_dyntag (DT_SYMBOLIC, objfile->obfd, NULL) != 1)
1631
    return NULL;
1632
 
1633
  return lookup_global_symbol_from_objfile
1634
                (objfile, name, linkage_name, domain, symtab);
1635
}
1636
 
1637
static int
1638
svr4_same (struct so_list *gdb, struct so_list *inferior)
1639
{
1640
  if (! strcmp (gdb->so_original_name, inferior->so_original_name))
1641
    return 1;
1642
 
1643
  /* On Solaris, when starting inferior we think that dynamic linker is
1644
     /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
1645
     contains /lib/ld.so.1.  Sometimes one file is a link to another, but
1646
     sometimes they have identical content, but are not linked to each
1647
     other.  We don't restrict this check for Solaris, but the chances
1648
     of running into this situation elsewhere are very low.  */
1649
  if (strcmp (gdb->so_original_name, "/usr/lib/ld.so.1") == 0
1650
      && strcmp (inferior->so_original_name, "/lib/ld.so.1") == 0)
1651
    return 1;
1652
 
1653
  return 0;
1654
}
1655
 
1656
extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */
1657
 
1658
void
1659
_initialize_svr4_solib (void)
1660
{
1661
  solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init);
1662
 
1663
  svr4_so_ops.relocate_section_addresses = svr4_relocate_section_addresses;
1664
  svr4_so_ops.free_so = svr4_free_so;
1665
  svr4_so_ops.clear_solib = svr4_clear_solib;
1666
  svr4_so_ops.solib_create_inferior_hook = svr4_solib_create_inferior_hook;
1667
  svr4_so_ops.special_symbol_handling = svr4_special_symbol_handling;
1668
  svr4_so_ops.current_sos = svr4_current_sos;
1669
  svr4_so_ops.open_symbol_file_object = open_symbol_file_object;
1670
  svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code;
1671
  svr4_so_ops.lookup_lib_global_symbol = elf_lookup_lib_symbol;
1672
  svr4_so_ops.same = svr4_same;
1673
}

powered by: WebSVN 2.1.0

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