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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [solib-osf.c] - Blame information for rev 840

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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