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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [solib-osf.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Handle OSF/1, Digital UNIX, and Tru64 shared libraries
2
   for GDB, the GNU Debugger.
3
   Copyright (C) 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2007, 2008,
4
   2009, 2010 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
/* When handling shared libraries, GDB has to find out the pathnames
22
   of all shared libraries that are currently loaded (to read in their
23
   symbols) and where the shared libraries are loaded in memory
24
   (to relocate them properly from their prelinked addresses to the
25
   current load address).
26
 
27
   Under OSF/1 there are two possibilities to get at this information:
28
 
29
   1) Peek around in the runtime loader structures.
30
   These are not documented, and they are not defined in the system
31
   header files. The definitions below were obtained by experimentation,
32
   but they seem stable enough.
33
 
34
   2) Use the libxproc.a library, which contains the equivalent ldr_*
35
   routines.  The library is documented in Tru64 5.x, but as of 5.1, it
36
   only allows a process to examine itself.  On earlier versions, it
37
   may require that the GDB executable be dynamically linked and that
38
   NAT_CLIBS include -lxproc -Wl,-expect_unresolved,ldr_process_context
39
   for GDB and all applications that are using libgdb.
40
 
41
   We will use the peeking approach until libxproc.a works for other
42
   processes.  */
43
 
44
#include "defs.h"
45
 
46
#include <sys/types.h>
47
#include <signal.h>
48
#include "gdb_string.h"
49
 
50
#include "bfd.h"
51
#include "symtab.h"
52
#include "symfile.h"
53
#include "objfiles.h"
54
#include "target.h"
55
#include "inferior.h"
56
#include "gdbthread.h"
57
#include "solist.h"
58
#include "solib.h"
59
 
60
#ifdef USE_LDR_ROUTINES
61
# include <loader.h>
62
#endif
63
 
64
#ifndef USE_LDR_ROUTINES
65
/* Definition of runtime loader structures, found by experimentation.  */
66
#define RLD_CONTEXT_ADDRESS     0x3ffc0000000
67
 
68
/* Per-module information structure referenced by ldr_context_t.head.  */
69
 
70
typedef struct
71
  {
72
    CORE_ADDR next;
73
    CORE_ADDR previous;
74
    CORE_ADDR unknown1;
75
    CORE_ADDR module_name;
76
    CORE_ADDR modinfo_addr;     /* used by next_link_map_member() to detect
77
                                   the end of the shared module list */
78
    long module_id;
79
    CORE_ADDR unknown2;
80
    CORE_ADDR unknown3;
81
    long region_count;
82
    CORE_ADDR regioninfo_addr;
83
  }
84
ldr_module_info_t;
85
 
86
/* Per-region structure referenced by ldr_module_info_t.regioninfo_addr.  */
87
 
88
typedef struct
89
  {
90
    long unknown1;
91
    CORE_ADDR regionname_addr;
92
    long protection;
93
    CORE_ADDR vaddr;
94
    CORE_ADDR mapaddr;
95
    long size;
96
    long unknown2[5];
97
  }
98
ldr_region_info_t;
99
 
100
/* Structure at RLD_CONTEXT_ADDRESS specifying the start and finish addresses
101
   of the shared module list.  */
102
 
103
typedef struct
104
  {
105
    CORE_ADDR unknown1;
106
    CORE_ADDR unknown2;
107
    CORE_ADDR head;
108
    CORE_ADDR tail;
109
  }
110
ldr_context_t;
111
#endif   /* !USE_LDR_ROUTINES */
112
 
113
/* Per-section information, stored in struct lm_info.secs.  */
114
 
115
struct lm_sec
116
  {
117
    CORE_ADDR offset;           /* difference between default and actual
118
                                   virtual addresses of section .name */
119
    CORE_ADDR nameaddr;         /* address in inferior of section name */
120
    const char *name;           /* name of section, null if not fetched */
121
  };
122
 
123
/* Per-module information, stored in struct so_list.lm_info.  */
124
 
125
struct lm_info
126
  {
127
    int isloader;               /* whether the module is /sbin/loader */
128
    int nsecs;                  /* length of .secs */
129
    struct lm_sec secs[1];      /* variable-length array of sections, sorted
130
                                   by name */
131
  };
132
 
133
/* Context for iterating through the inferior's shared module list.  */
134
 
135
struct read_map_ctxt
136
  {
137
#ifdef USE_LDR_ROUTINES
138
    ldr_process_t proc;
139
    ldr_module_t next;
140
#else
141
    CORE_ADDR next;             /* next element in module list */
142
    CORE_ADDR tail;             /* last element in module list */
143
#endif
144
  };
145
 
146
/* Forward declaration for this module's autoinit function.  */
147
 
148
extern void _initialize_osf_solib (void);
149
 
150
#ifdef USE_LDR_ROUTINES
151
# if 0
152
/* This routine is intended to be called by ldr_* routines to read memory from
153
   the current target.  Usage:
154
 
155
     ldr_process = ldr_core_process ();
156
     ldr_set_core_reader (ldr_read_memory);
157
     ldr_xdetach (ldr_process);
158
     ldr_xattach (ldr_process);
159
 
160
   ldr_core_process() and ldr_read_memory() are neither documented nor
161
   declared in system header files.  They work with OSF/1 2.x, and they might
162
   work with later versions as well.  */
163
 
164
static int
165
ldr_read_memory (CORE_ADDR memaddr, char *myaddr, int len, int readstring)
166
{
167
  int result;
168
  char *buffer;
169
 
170
  if (readstring)
171
    {
172
      target_read_string (memaddr, &buffer, len, &result);
173
      if (result == 0)
174
        strcpy (myaddr, buffer);
175
      xfree (buffer);
176
    }
177
  else
178
    result = target_read_memory (memaddr, myaddr, len);
179
 
180
  if (result != 0)
181
    result = -result;
182
  return result;
183
}
184
# endif   /* 0 */
185
#endif   /* USE_LDR_ROUTINES */
186
 
187
/* Comparison for qsort() and bsearch(): return -1, 0, or 1 according to
188
   whether lm_sec *P1's name is lexically less than, equal to, or greater
189
   than that of *P2.  */
190
 
191
static int
192
lm_sec_cmp (const void *p1, const void *p2)
193
{
194
  const struct lm_sec *lms1 = p1, *lms2 = p2;
195
  return strcmp (lms1->name, lms2->name);
196
}
197
 
198
/* Sort LMI->secs so that osf_relocate_section_addresses() can binary-search
199
   it.  */
200
 
201
static void
202
lm_secs_sort (struct lm_info *lmi)
203
{
204
  qsort (lmi->secs, lmi->nsecs, sizeof *lmi->secs, lm_sec_cmp);
205
}
206
 
207
/* Populate name fields of LMI->secs.  */
208
 
209
static void
210
fetch_sec_names (struct lm_info *lmi)
211
{
212
#ifndef USE_LDR_ROUTINES
213
  int i, errcode;
214
  struct lm_sec *lms;
215
  char *name;
216
 
217
  for (i = 0; i < lmi->nsecs; i++)
218
    {
219
      lms = lmi->secs + i;
220
      target_read_string (lms->nameaddr, &name, PATH_MAX, &errcode);
221
      if (errcode != 0)
222
        {
223
          warning (_("unable to read shared sec name at 0x%lx"), lms->nameaddr);
224
          name = xstrdup ("");
225
        }
226
      lms->name = name;
227
    }
228
  lm_secs_sort (lmi);
229
#endif
230
}
231
 
232
/* target_so_ops callback.  Adjust SEC's addresses after it's been mapped into
233
   the process.  */
234
 
235
static void
236
osf_relocate_section_addresses (struct so_list *so,
237
                                struct target_section *sec)
238
{
239
  struct lm_info *lmi;
240
  struct lm_sec lms_key, *lms;
241
 
242
  /* Fetch SO's section names if we haven't done so already.  */
243
  lmi = so->lm_info;
244
  if (lmi->nsecs && !lmi->secs[0].name)
245
    fetch_sec_names (lmi);
246
 
247
  /* Binary-search for offset information corresponding to SEC.  */
248
  lms_key.name = sec->the_bfd_section->name;
249
  lms = bsearch (&lms_key, lmi->secs, lmi->nsecs, sizeof *lms, lm_sec_cmp);
250
  if (lms)
251
    {
252
      sec->addr += lms->offset;
253
      sec->endaddr += lms->offset;
254
    }
255
}
256
 
257
/* target_so_ops callback.  Free parts of SO allocated by this file.  */
258
 
259
static void
260
osf_free_so (struct so_list *so)
261
{
262
  int i;
263
  const char *name;
264
 
265
  for (i = 0; i < so->lm_info->nsecs; i++)
266
    {
267
      name = so->lm_info->secs[i].name;
268
      if (name)
269
        xfree ((void *) name);
270
    }
271
  xfree (so->lm_info);
272
}
273
 
274
/* target_so_ops callback.  Discard information accumulated by this file and
275
   not freed by osf_free_so().  */
276
 
277
static void
278
osf_clear_solib (void)
279
{
280
  return;
281
}
282
 
283
/* target_so_ops callback.  Prepare to handle shared libraries after the
284
   inferior process has been created but before it's executed any
285
   instructions.
286
 
287
   For a statically bound executable, the inferior's first instruction is the
288
   one at "_start", or a similar text label. No further processing is needed
289
   in that case.
290
 
291
   For a dynamically bound executable, this first instruction is somewhere
292
   in the rld, and the actual user executable is not yet mapped in.
293
   We continue the inferior again, rld then maps in the actual user
294
   executable and any needed shared libraries and then sends
295
   itself a SIGTRAP.
296
 
297
   At that point we discover the names of all shared libraries and
298
   read their symbols in.
299
 
300
   FIXME
301
 
302
   This code does not properly handle hitting breakpoints which the
303
   user might have set in the rld itself.  Proper handling would have
304
   to check if the SIGTRAP happened due to a kill call.
305
 
306
   Also, what if child has exit()ed?  Must exit loop somehow.  */
307
 
308
static void
309
osf_solib_create_inferior_hook (int from_tty)
310
{
311
  struct inferior *inf;
312
  struct thread_info *tp;
313
 
314
  inf = current_inferior ();
315
 
316
  /* If we are attaching to the inferior, the shared libraries
317
     have already been mapped, so nothing more to do.  */
318
  if (inf->attach_flag)
319
    return;
320
 
321
  /* Nothing to do for statically bound executables.  */
322
 
323
  if (symfile_objfile == NULL
324
      || symfile_objfile->obfd == NULL
325
      || ((bfd_get_file_flags (symfile_objfile->obfd) & DYNAMIC) == 0))
326
    return;
327
 
328
  /* Now run the target.  It will eventually get a SIGTRAP, at
329
     which point all of the libraries will have been mapped in and we
330
     can go groveling around in the rld structures to find
331
     out what we need to know about them.
332
 
333
     If debugging from a core file, we cannot resume the execution
334
     of the inferior.  But this is actually not an issue, because
335
     shared libraries have already been mapped anyways, which means
336
     we have nothing more to do.  */
337
  if (!target_can_run (&current_target))
338
    return;
339
 
340
  tp = inferior_thread ();
341
  clear_proceed_status ();
342
  inf->stop_soon = STOP_QUIETLY;
343
  tp->stop_signal = TARGET_SIGNAL_0;
344
  do
345
    {
346
      target_resume (minus_one_ptid, 0, tp->stop_signal);
347
      wait_for_inferior (0);
348
    }
349
  while (tp->stop_signal != TARGET_SIGNAL_TRAP);
350
 
351
  /*  solib_add will call reinit_frame_cache.
352
     But we are stopped in the runtime loader and we do not have symbols
353
     for the runtime loader. So heuristic_proc_start will be called
354
     and will put out an annoying warning.
355
     Delaying the resetting of stop_soon until after symbol loading
356
     suppresses the warning.  */
357
  solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add);
358
  inf->stop_soon = NO_STOP_QUIETLY;
359
}
360
 
361
/* target_so_ops callback.  Do additional symbol handling, lookup, etc. after
362
   symbols for a shared object have been loaded.  */
363
 
364
static void
365
osf_special_symbol_handling (void)
366
{
367
  return;
368
}
369
 
370
/* Initialize CTXT in preparation for iterating through the inferior's module
371
   list using read_map().  Return success.  */
372
 
373
static int
374
open_map (struct read_map_ctxt *ctxt)
375
{
376
#ifdef USE_LDR_ROUTINES
377
  /* Note: As originally written, ldr_my_process() was used to obtain
378
     the value for ctxt->proc.  This is incorrect, however, since
379
     ldr_my_process() retrieves the "unique identifier" associated
380
     with the current process (i.e. GDB) and not the one being
381
     debugged.  Presumably, the pid of the process being debugged is
382
     compatible with the "unique identifier" used by the ldr_
383
     routines, so we use that.  */
384
  ctxt->proc = ptid_get_pid (inferior_ptid);
385
  if (ldr_xattach (ctxt->proc) != 0)
386
    return 0;
387
  ctxt->next = LDR_NULL_MODULE;
388
#else
389
  CORE_ADDR ldr_context_addr, prev, next;
390
  ldr_context_t ldr_context;
391
 
392
  if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS,
393
                          (char *) &ldr_context_addr,
394
                          sizeof (CORE_ADDR)) != 0)
395
    return 0;
396
  if (target_read_memory (ldr_context_addr,
397
                          (char *) &ldr_context,
398
                          sizeof (ldr_context_t)) != 0)
399
    return 0;
400
  ctxt->next = ldr_context.head;
401
  ctxt->tail = ldr_context.tail;
402
#endif
403
  return 1;
404
}
405
 
406
/* Initialize SO to have module NAME, /sbin/loader indicator ISLOADR, and
407
   space for NSECS sections.  */
408
 
409
static void
410
init_so (struct so_list *so, char *name, int isloader, int nsecs)
411
{
412
  int namelen, i;
413
 
414
  /* solib.c requires various fields to be initialized to 0.  */
415
  memset (so, 0, sizeof *so);
416
 
417
  /* Copy the name.  */
418
  namelen = strlen (name);
419
  if (namelen >= SO_NAME_MAX_PATH_SIZE)
420
    namelen = SO_NAME_MAX_PATH_SIZE - 1;
421
 
422
  memcpy (so->so_original_name, name, namelen);
423
  so->so_original_name[namelen] = '\0';
424
  memcpy (so->so_name, so->so_original_name, namelen + 1);
425
 
426
  /* Allocate section space.  */
427
  so->lm_info = xmalloc (sizeof (struct lm_info)
428
                         + (nsecs - 1) * sizeof (struct lm_sec));
429
  so->lm_info->isloader = isloader;
430
  so->lm_info->nsecs = nsecs;
431
  for (i = 0; i < nsecs; i++)
432
    so->lm_info->secs[i].name = NULL;
433
}
434
 
435
/* Initialize SO's section SECIDX with name address NAMEADDR, name string
436
   NAME, default virtual address VADDR, and actual virtual address
437
   MAPADDR.  */
438
 
439
static void
440
init_sec (struct so_list *so, int secidx, CORE_ADDR nameaddr,
441
          const char *name, CORE_ADDR vaddr, CORE_ADDR mapaddr)
442
{
443
  struct lm_sec *lms;
444
 
445
  lms = so->lm_info->secs + secidx;
446
  lms->nameaddr = nameaddr;
447
  lms->name = name;
448
  lms->offset = mapaddr - vaddr;
449
}
450
 
451
/* If there are more elements starting at CTXT in inferior's module list,
452
   store the next element in SO, advance CTXT to the next element, and return
453
   1, else return 0.  */
454
 
455
static int
456
read_map (struct read_map_ctxt *ctxt, struct so_list *so)
457
{
458
  ldr_module_info_t minf;
459
  ldr_region_info_t rinf;
460
 
461
#ifdef USE_LDR_ROUTINES
462
  size_t size;
463
  ldr_region_t i;
464
 
465
  /* Retrieve the next element.  */
466
  if (ldr_next_module (ctxt->proc, &ctxt->next) != 0)
467
    return 0;
468
  if (ctxt->next == LDR_NULL_MODULE)
469
    return 0;
470
  if (ldr_inq_module (ctxt->proc, ctxt->next, &minf, sizeof minf, &size) != 0)
471
    return 0;
472
 
473
  /* Initialize the module name and section count.  */
474
  init_so (so, minf.lmi_name, 0, minf.lmi_nregion);
475
 
476
  /* Retrieve section names and offsets.  */
477
  for (i = 0; i < minf.lmi_nregion; i++)
478
    {
479
      if (ldr_inq_region (ctxt->proc, ctxt->next, i, &rinf,
480
                          sizeof rinf, &size) != 0)
481
        goto err;
482
      init_sec (so, (int) i, 0, xstrdup (rinf.lri_name),
483
                (CORE_ADDR) rinf.lri_vaddr, (CORE_ADDR) rinf.lri_mapaddr);
484
    }
485
  lm_secs_sort (so->lm_info);
486
#else
487
  char *name;
488
  int errcode, i;
489
 
490
  /* Retrieve the next element.  */
491
  if (!ctxt->next)
492
    return 0;
493
  if (target_read_memory (ctxt->next, (char *) &minf, sizeof minf) != 0)
494
    return 0;
495
  if (ctxt->next == ctxt->tail)
496
    ctxt->next = 0;
497
  else
498
    ctxt->next = minf.next;
499
 
500
  /* Initialize the module name and section count.  */
501
  target_read_string (minf.module_name, &name, PATH_MAX, &errcode);
502
  if (errcode != 0)
503
    return 0;
504
  init_so (so, name, !minf.modinfo_addr, minf.region_count);
505
  xfree (name);
506
 
507
  /* Retrieve section names and offsets.  */
508
  for (i = 0; i < minf.region_count; i++)
509
    {
510
      if (target_read_memory (minf.regioninfo_addr + i * sizeof rinf,
511
                              (char *) &rinf, sizeof rinf) != 0)
512
        goto err;
513
      init_sec (so, i, rinf.regionname_addr, NULL, rinf.vaddr, rinf.mapaddr);
514
    }
515
#endif   /* !USE_LDR_ROUTINES */
516
  return 1;
517
 
518
 err:
519
  osf_free_so (so);
520
  return 0;
521
}
522
 
523
/* Free resources allocated by open_map (CTXT).  */
524
 
525
static void
526
close_map (struct read_map_ctxt *ctxt)
527
{
528
#ifdef USE_LDR_ROUTINES
529
  ldr_xdetach (ctxt->proc);
530
#endif
531
}
532
 
533
/* target_so_ops callback.  Return a list of shared objects currently loaded
534
   in the inferior.  */
535
 
536
static struct so_list *
537
osf_current_sos (void)
538
{
539
  struct so_list *head = NULL, *tail = NULL, *newtail, so;
540
  struct read_map_ctxt ctxt;
541
  int skipped_main;
542
 
543
  if (!open_map (&ctxt))
544
    return NULL;
545
 
546
  /* Read subsequent elements.  */
547
  for (skipped_main = 0;;)
548
    {
549
      if (!read_map (&ctxt, &so))
550
        break;
551
 
552
      /* Skip the main program module, which is first in the list after
553
         /sbin/loader.  */
554
      if (!so.lm_info->isloader && !skipped_main)
555
        {
556
          osf_free_so (&so);
557
          skipped_main = 1;
558
          continue;
559
        }
560
 
561
      newtail = xmalloc (sizeof *newtail);
562
      if (!head)
563
        head = newtail;
564
      else
565
        tail->next = newtail;
566
      tail = newtail;
567
 
568
      memcpy (tail, &so, sizeof so);
569
      tail->next = NULL;
570
    }
571
 
572
  close_map (&ctxt);
573
  return head;
574
}
575
 
576
/* target_so_ops callback.  Attempt to locate and open the main symbol
577
   file.  */
578
 
579
static int
580
osf_open_symbol_file_object (void *from_ttyp)
581
{
582
  struct read_map_ctxt ctxt;
583
  struct so_list so;
584
  int found;
585
 
586
  if (symfile_objfile)
587
    if (!query (_("Attempt to reload symbols from process? ")))
588
      return 0;
589
 
590
  /* The first module after /sbin/loader is the main program.  */
591
  if (!open_map (&ctxt))
592
    return 0;
593
  for (found = 0; !found;)
594
    {
595
      if (!read_map (&ctxt, &so))
596
        break;
597
      found = !so.lm_info->isloader;
598
      osf_free_so (&so);
599
    }
600
  close_map (&ctxt);
601
 
602
  if (found)
603
    symbol_file_add_main (so.so_name, *(int *) from_ttyp);
604
  return found;
605
}
606
 
607
/* target_so_ops callback.  Return whether PC is in the dynamic linker.  */
608
 
609
static int
610
osf_in_dynsym_resolve_code (CORE_ADDR pc)
611
{
612
  /* This function currently always return False. This is a temporary
613
     solution which only consequence is to introduce a minor incovenience
614
     for the user: When stepping inside a subprogram located in a shared
615
     library, gdb might stop inside the dynamic loader code instead of
616
     inside the subprogram itself. See the explanations in infrun.c about
617
     the in_solib_dynsym_resolve_code() function for more details. */
618
  return 0;
619
}
620
 
621
static struct target_so_ops osf_so_ops;
622
 
623
void
624
_initialize_osf_solib (void)
625
{
626
  osf_so_ops.relocate_section_addresses = osf_relocate_section_addresses;
627
  osf_so_ops.free_so = osf_free_so;
628
  osf_so_ops.clear_solib = osf_clear_solib;
629
  osf_so_ops.solib_create_inferior_hook = osf_solib_create_inferior_hook;
630
  osf_so_ops.special_symbol_handling = osf_special_symbol_handling;
631
  osf_so_ops.current_sos = osf_current_sos;
632
  osf_so_ops.open_symbol_file_object = osf_open_symbol_file_object;
633
  osf_so_ops.in_dynsym_resolve_code = osf_in_dynsym_resolve_code;
634
  osf_so_ops.bfd_open = solib_bfd_open;
635
 
636
  /* FIXME: Don't do this here.  *_gdbarch_init() should set so_ops. */
637
  current_target_so_ops = &osf_so_ops;
638
}

powered by: WebSVN 2.1.0

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