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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [objfiles.c] - Blame information for rev 105

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

Line No. Rev Author Line
1 104 markom
/* GDB routines for manipulating objfiles.
2
   Copyright 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
3
   Contributed by Cygnus Support, using pieces from other GDB modules.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
/* This file contains support routines for creating, manipulating, and
23
   destroying objfile structures. */
24
 
25
#include "defs.h"
26
#include "bfd.h"                /* Binary File Description */
27
#include "symtab.h"
28
#include "symfile.h"
29
#include "objfiles.h"
30
#include "gdb-stabs.h"
31
#include "target.h"
32
 
33
#include <sys/types.h>
34
#include "gdb_stat.h"
35
#include <fcntl.h>
36
#include "obstack.h"
37
#include "gdb_string.h"
38
 
39
#include "breakpoint.h"
40
 
41
/* Prototypes for local functions */
42
 
43
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
44
 
45
static int
46
open_existing_mapped_file PARAMS ((char *, long, int));
47
 
48
static int
49
open_mapped_file PARAMS ((char *filename, long mtime, int flags));
50
 
51
static PTR
52
  map_to_file PARAMS ((int));
53
 
54
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
55
 
56
static void
57
add_to_objfile_sections PARAMS ((bfd *, sec_ptr, PTR));
58
 
59
/* Externally visible variables that are owned by this module.
60
   See declarations in objfile.h for more info. */
61
 
62
struct objfile *object_files;   /* Linked list of all objfiles */
63
struct objfile *current_objfile;        /* For symbol file being read in */
64
struct objfile *symfile_objfile;        /* Main symbol table loaded from */
65
struct objfile *rt_common_objfile;      /* For runtime common symbols */
66
 
67
int mapped_symbol_files;        /* Try to use mapped symbol files */
68
 
69
/* Locate all mappable sections of a BFD file.
70
   objfile_p_char is a char * to get it through
71
   bfd_map_over_sections; we cast it back to its proper type.  */
72
 
73
#ifndef TARGET_KEEP_SECTION
74
#define TARGET_KEEP_SECTION(ASECT)      0
75
#endif
76
 
77
/* Called via bfd_map_over_sections to build up the section table that
78
   the objfile references.  The objfile contains pointers to the start
79
   of the table (objfile->sections) and to the first location after
80
   the end of the table (objfile->sections_end). */
81
 
82
static void
83
add_to_objfile_sections (abfd, asect, objfile_p_char)
84
     bfd *abfd;
85
     sec_ptr asect;
86
     PTR objfile_p_char;
87
{
88
  struct objfile *objfile = (struct objfile *) objfile_p_char;
89
  struct obj_section section;
90
  flagword aflag;
91
 
92
  aflag = bfd_get_section_flags (abfd, asect);
93
 
94
  if (!(aflag & SEC_ALLOC) && !(TARGET_KEEP_SECTION (asect)))
95
    return;
96
 
97
  if (0 == bfd_section_size (abfd, asect))
98
    return;
99
  section.offset = 0;
100
  section.objfile = objfile;
101
  section.the_bfd_section = asect;
102
  section.ovly_mapped = 0;
103
  section.addr = bfd_section_vma (abfd, asect);
104
  section.endaddr = section.addr + bfd_section_size (abfd, asect);
105
  obstack_grow (&objfile->psymbol_obstack, (char *) &section, sizeof (section));
106
  objfile->sections_end = (struct obj_section *) (((unsigned long) objfile->sections_end) + 1);
107
}
108
 
109
/* Builds a section table for OBJFILE.
110
   Returns 0 if OK, 1 on error (in which case bfd_error contains the
111
   error).
112
 
113
   Note that while we are building the table, which goes into the
114
   psymbol obstack, we hijack the sections_end pointer to instead hold
115
   a count of the number of sections.  When bfd_map_over_sections
116
   returns, this count is used to compute the pointer to the end of
117
   the sections table, which then overwrites the count.
118
 
119
   Also note that the OFFSET and OVLY_MAPPED in each table entry
120
   are initialized to zero.
121
 
122
   Also note that if anything else writes to the psymbol obstack while
123
   we are building the table, we're pretty much hosed. */
124
 
125
int
126
build_objfile_section_table (objfile)
127
     struct objfile *objfile;
128
{
129
  /* objfile->sections can be already set when reading a mapped symbol
130
     file.  I believe that we do need to rebuild the section table in
131
     this case (we rebuild other things derived from the bfd), but we
132
     can't free the old one (it's in the psymbol_obstack).  So we just
133
     waste some memory.  */
134
 
135
  objfile->sections_end = 0;
136
  bfd_map_over_sections (objfile->obfd, add_to_objfile_sections, (char *) objfile);
137
  objfile->sections = (struct obj_section *)
138
    obstack_finish (&objfile->psymbol_obstack);
139
  objfile->sections_end = objfile->sections + (unsigned long) objfile->sections_end;
140
  return (0);
141
}
142
 
143
/* Given a pointer to an initialized bfd (ABFD) and some flag bits
144
   allocate a new objfile struct, fill it in as best we can, link it
145
   into the list of all known objfiles, and return a pointer to the
146
   new objfile struct.
147
 
148
   The FLAGS word contains various bits (OBJF_*) that can be taken as
149
   requests for specific operations, like trying to open a mapped
150
   version of the objfile (OBJF_MAPPED).  Other bits like
151
   OBJF_SHARED are simply copied through to the new objfile flags
152
   member. */
153
 
154
struct objfile *
155
allocate_objfile (abfd, flags)
156
     bfd *abfd;
157
     int flags;
158
{
159
  struct objfile *objfile = NULL;
160
  struct objfile *last_one = NULL;
161
 
162
  if (mapped_symbol_files)
163
    flags |= OBJF_MAPPED;
164
 
165
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
166
  if (abfd != NULL)
167
    {
168
 
169
      /* If we can support mapped symbol files, try to open/reopen the
170
         mapped file that corresponds to the file from which we wish to
171
         read symbols.  If the objfile is to be mapped, we must malloc
172
         the structure itself using the mmap version, and arrange that
173
         all memory allocation for the objfile uses the mmap routines.
174
         If we are reusing an existing mapped file, from which we get
175
         our objfile pointer, we have to make sure that we update the
176
         pointers to the alloc/free functions in the obstack, in case
177
         these functions have moved within the current gdb.  */
178
 
179
      int fd;
180
 
181
      fd = open_mapped_file (bfd_get_filename (abfd), bfd_get_mtime (abfd),
182
                             flags);
183
      if (fd >= 0)
184
        {
185
          PTR md;
186
 
187
          if ((md = map_to_file (fd)) == NULL)
188
            {
189
              close (fd);
190
            }
191
          else if ((objfile = (struct objfile *) mmalloc_getkey (md, 0)) != NULL)
192
            {
193
              /* Update memory corruption handler function addresses. */
194
              init_malloc (md);
195
              objfile->md = md;
196
              objfile->mmfd = fd;
197
              /* Update pointers to functions to *our* copies */
198
              obstack_chunkfun (&objfile->psymbol_cache.cache, xmmalloc);
199
              obstack_freefun (&objfile->psymbol_cache.cache, mfree);
200
              obstack_chunkfun (&objfile->psymbol_obstack, xmmalloc);
201
              obstack_freefun (&objfile->psymbol_obstack, mfree);
202
              obstack_chunkfun (&objfile->symbol_obstack, xmmalloc);
203
              obstack_freefun (&objfile->symbol_obstack, mfree);
204
              obstack_chunkfun (&objfile->type_obstack, xmmalloc);
205
              obstack_freefun (&objfile->type_obstack, mfree);
206
              /* If already in objfile list, unlink it. */
207
              unlink_objfile (objfile);
208
              /* Forget things specific to a particular gdb, may have changed. */
209
              objfile->sf = NULL;
210
            }
211
          else
212
            {
213
 
214
              /* Set up to detect internal memory corruption.  MUST be
215
                 done before the first malloc.  See comments in
216
                 init_malloc() and mmcheck().  */
217
 
218
              init_malloc (md);
219
 
220
              objfile = (struct objfile *)
221
                xmmalloc (md, sizeof (struct objfile));
222
              memset (objfile, 0, sizeof (struct objfile));
223
              objfile->md = md;
224
              objfile->mmfd = fd;
225
              objfile->flags |= OBJF_MAPPED;
226
              mmalloc_setkey (objfile->md, 0, objfile);
227
              obstack_specify_allocation_with_arg (&objfile->psymbol_cache.cache,
228
                                                   0, 0, xmmalloc, mfree,
229
                                                   objfile->md);
230
              obstack_specify_allocation_with_arg (&objfile->psymbol_obstack,
231
                                                   0, 0, xmmalloc, mfree,
232
                                                   objfile->md);
233
              obstack_specify_allocation_with_arg (&objfile->symbol_obstack,
234
                                                   0, 0, xmmalloc, mfree,
235
                                                   objfile->md);
236
              obstack_specify_allocation_with_arg (&objfile->type_obstack,
237
                                                   0, 0, xmmalloc, mfree,
238
                                                   objfile->md);
239
            }
240
        }
241
 
242
      if ((flags & OBJF_MAPPED) && (objfile == NULL))
243
        {
244
          warning ("symbol table for '%s' will not be mapped",
245
                   bfd_get_filename (abfd));
246
          flags &= ~OBJF_MAPPED;
247
        }
248
    }
249
#else /* !defined(USE_MMALLOC) || !defined(HAVE_MMAP) */
250
 
251
  if (flags & OBJF_MAPPED)
252
    {
253
      warning ("mapped symbol tables are not supported on this machine; missing or broken mmap().");
254
 
255
      /* Turn off the global flag so we don't try to do mapped symbol tables
256
         any more, which shuts up gdb unless the user specifically gives the
257
         "mapped" keyword again. */
258
 
259
      mapped_symbol_files = 0;
260
      flags &= ~OBJF_MAPPED;
261
    }
262
 
263
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
264
 
265
  /* If we don't support mapped symbol files, didn't ask for the file to be
266
     mapped, or failed to open the mapped file for some reason, then revert
267
     back to an unmapped objfile. */
268
 
269
  if (objfile == NULL)
270
    {
271
      objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
272
      memset (objfile, 0, sizeof (struct objfile));
273
      objfile->md = NULL;
274
      obstack_specify_allocation (&objfile->psymbol_cache.cache, 0, 0,
275
                                  xmalloc, free);
276
      obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0, xmalloc,
277
                                  free);
278
      obstack_specify_allocation (&objfile->symbol_obstack, 0, 0, xmalloc,
279
                                  free);
280
      obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,
281
                                  free);
282
      flags &= ~OBJF_MAPPED;
283
    }
284
 
285
  /* Update the per-objfile information that comes from the bfd, ensuring
286
     that any data that is reference is saved in the per-objfile data
287
     region. */
288
 
289
  objfile->obfd = abfd;
290
  if (objfile->name != NULL)
291
    {
292
      mfree (objfile->md, objfile->name);
293
    }
294
  if (abfd != NULL)
295
    {
296
      objfile->name = mstrsave (objfile->md, bfd_get_filename (abfd));
297
      objfile->mtime = bfd_get_mtime (abfd);
298
 
299
      /* Build section table.  */
300
 
301
      if (build_objfile_section_table (objfile))
302
        {
303
          error ("Can't find the file sections in `%s': %s",
304
                 objfile->name, bfd_errmsg (bfd_get_error ()));
305
        }
306
    }
307
 
308
  /* Add this file onto the tail of the linked list of other such files. */
309
 
310
  objfile->next = NULL;
311
  if (object_files == NULL)
312
    object_files = objfile;
313
  else
314
    {
315
      for (last_one = object_files;
316
           last_one->next;
317
           last_one = last_one->next);
318
      last_one->next = objfile;
319
    }
320
 
321
  /* Save passed in flag bits. */
322
  objfile->flags |= flags;
323
 
324
  return (objfile);
325
}
326
 
327
/* Put OBJFILE at the front of the list.  */
328
 
329
void
330
objfile_to_front (objfile)
331
     struct objfile *objfile;
332
{
333
  struct objfile **objp;
334
  for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
335
    {
336
      if (*objp == objfile)
337
        {
338
          /* Unhook it from where it is.  */
339
          *objp = objfile->next;
340
          /* Put it in the front.  */
341
          objfile->next = object_files;
342
          object_files = objfile;
343
          break;
344
        }
345
    }
346
}
347
 
348
/* Unlink OBJFILE from the list of known objfiles, if it is found in the
349
   list.
350
 
351
   It is not a bug, or error, to call this function if OBJFILE is not known
352
   to be in the current list.  This is done in the case of mapped objfiles,
353
   for example, just to ensure that the mapped objfile doesn't appear twice
354
   in the list.  Since the list is threaded, linking in a mapped objfile
355
   twice would create a circular list.
356
 
357
   If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
358
   unlinking it, just to ensure that we have completely severed any linkages
359
   between the OBJFILE and the list. */
360
 
361
void
362
unlink_objfile (objfile)
363
     struct objfile *objfile;
364
{
365
  struct objfile **objpp;
366
 
367
  for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
368
    {
369
      if (*objpp == objfile)
370
        {
371
          *objpp = (*objpp)->next;
372
          objfile->next = NULL;
373
          return;
374
        }
375
    }
376
 
377
  internal_error ("objfiles.c (unlink_objfile): objfile already unlinked");
378
}
379
 
380
 
381
/* Destroy an objfile and all the symtabs and psymtabs under it.  Note
382
   that as much as possible is allocated on the symbol_obstack and
383
   psymbol_obstack, so that the memory can be efficiently freed.
384
 
385
   Things which we do NOT free because they are not in malloc'd memory
386
   or not in memory specific to the objfile include:
387
 
388
   objfile -> sf
389
 
390
   FIXME:  If the objfile is using reusable symbol information (via mmalloc),
391
   then we need to take into account the fact that more than one process
392
   may be using the symbol information at the same time (when mmalloc is
393
   extended to support cooperative locking).  When more than one process
394
   is using the mapped symbol info, we need to be more careful about when
395
   we free objects in the reusable area. */
396
 
397
void
398
free_objfile (objfile)
399
     struct objfile *objfile;
400
{
401
  /* First do any symbol file specific actions required when we are
402
     finished with a particular symbol file.  Note that if the objfile
403
     is using reusable symbol information (via mmalloc) then each of
404
     these routines is responsible for doing the correct thing, either
405
     freeing things which are valid only during this particular gdb
406
     execution, or leaving them to be reused during the next one. */
407
 
408
  if (objfile->sf != NULL)
409
    {
410
      (*objfile->sf->sym_finish) (objfile);
411
    }
412
 
413
  /* We always close the bfd. */
414
 
415
  if (objfile->obfd != NULL)
416
    {
417
      char *name = bfd_get_filename (objfile->obfd);
418
      if (!bfd_close (objfile->obfd))
419
        warning ("cannot close \"%s\": %s",
420
                 name, bfd_errmsg (bfd_get_error ()));
421
      free (name);
422
    }
423
 
424
  /* Remove it from the chain of all objfiles. */
425
 
426
  unlink_objfile (objfile);
427
 
428
  /* If we are going to free the runtime common objfile, mark it
429
     as unallocated.  */
430
 
431
  if (objfile == rt_common_objfile)
432
    rt_common_objfile = NULL;
433
 
434
  /* Before the symbol table code was redone to make it easier to
435
     selectively load and remove information particular to a specific
436
     linkage unit, gdb used to do these things whenever the monolithic
437
     symbol table was blown away.  How much still needs to be done
438
     is unknown, but we play it safe for now and keep each action until
439
     it is shown to be no longer needed. */
440
 
441
  /* I *think* all our callers call clear_symtab_users.  If so, no need
442
     to call this here.  */
443
  clear_pc_function_cache ();
444
 
445
  /* The last thing we do is free the objfile struct itself for the
446
     non-reusable case, or detach from the mapped file for the reusable
447
     case.  Note that the mmalloc_detach or the mfree is the last thing
448
     we can do with this objfile. */
449
 
450
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
451
 
452
  if (objfile->flags & OBJF_MAPPED)
453
    {
454
      /* Remember the fd so we can close it.  We can't close it before
455
         doing the detach, and after the detach the objfile is gone. */
456
      int mmfd;
457
 
458
      mmfd = objfile->mmfd;
459
      mmalloc_detach (objfile->md);
460
      objfile = NULL;
461
      close (mmfd);
462
    }
463
 
464
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
465
 
466
  /* If we still have an objfile, then either we don't support reusable
467
     objfiles or this one was not reusable.  So free it normally. */
468
 
469
  if (objfile != NULL)
470
    {
471
      if (objfile->name != NULL)
472
        {
473
          mfree (objfile->md, objfile->name);
474
        }
475
      if (objfile->global_psymbols.list)
476
        mfree (objfile->md, objfile->global_psymbols.list);
477
      if (objfile->static_psymbols.list)
478
        mfree (objfile->md, objfile->static_psymbols.list);
479
      /* Free the obstacks for non-reusable objfiles */
480
      free_bcache (&objfile->psymbol_cache);
481
      obstack_free (&objfile->psymbol_obstack, 0);
482
      obstack_free (&objfile->symbol_obstack, 0);
483
      obstack_free (&objfile->type_obstack, 0);
484
      mfree (objfile->md, objfile);
485
      objfile = NULL;
486
    }
487
}
488
 
489
 
490
/* Free all the object files at once and clean up their users.  */
491
 
492
void
493
free_all_objfiles ()
494
{
495
  struct objfile *objfile, *temp;
496
 
497
  ALL_OBJFILES_SAFE (objfile, temp)
498
  {
499
    free_objfile (objfile);
500
  }
501
  clear_symtab_users ();
502
}
503
 
504
/* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
505
   entries in new_offsets.  */
506
void
507
objfile_relocate (objfile, new_offsets)
508
     struct objfile *objfile;
509
     struct section_offsets *new_offsets;
510
{
511
  struct section_offsets *delta =
512
    (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
513
 
514
  {
515
    int i;
516
    int something_changed = 0;
517
    for (i = 0; i < objfile->num_sections; ++i)
518
      {
519
        ANOFFSET (delta, i) =
520
          ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
521
        if (ANOFFSET (delta, i) != 0)
522
          something_changed = 1;
523
      }
524
    if (!something_changed)
525
      return;
526
  }
527
 
528
  /* OK, get all the symtabs.  */
529
  {
530
    struct symtab *s;
531
 
532
    ALL_OBJFILE_SYMTABS (objfile, s)
533
    {
534
      struct linetable *l;
535
      struct blockvector *bv;
536
      int i;
537
 
538
      /* First the line table.  */
539
      l = LINETABLE (s);
540
      if (l)
541
        {
542
          for (i = 0; i < l->nitems; ++i)
543
            l->item[i].pc += ANOFFSET (delta, s->block_line_section);
544
        }
545
 
546
      /* Don't relocate a shared blockvector more than once.  */
547
      if (!s->primary)
548
        continue;
549
 
550
      bv = BLOCKVECTOR (s);
551
      for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
552
        {
553
          struct block *b;
554
          int j;
555
 
556
          b = BLOCKVECTOR_BLOCK (bv, i);
557
          BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
558
          BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
559
 
560
          for (j = 0; j < BLOCK_NSYMS (b); ++j)
561
            {
562
              struct symbol *sym = BLOCK_SYM (b, j);
563
              /* The RS6000 code from which this was taken skipped
564
                 any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE.
565
                 But I'm leaving out that test, on the theory that
566
                 they can't possibly pass the tests below.  */
567
              if ((SYMBOL_CLASS (sym) == LOC_LABEL
568
                   || SYMBOL_CLASS (sym) == LOC_STATIC
569
                   || SYMBOL_CLASS (sym) == LOC_INDIRECT)
570
                  && SYMBOL_SECTION (sym) >= 0)
571
                {
572
                  SYMBOL_VALUE_ADDRESS (sym) +=
573
                    ANOFFSET (delta, SYMBOL_SECTION (sym));
574
                }
575
#ifdef MIPS_EFI_SYMBOL_NAME
576
              /* Relocate Extra Function Info for ecoff.  */
577
 
578
              else if (SYMBOL_CLASS (sym) == LOC_CONST
579
                       && SYMBOL_NAMESPACE (sym) == LABEL_NAMESPACE
580
                   && STRCMP (SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)
581
                ecoff_relocate_efi (sym, ANOFFSET (delta,
582
                                                   s->block_line_section));
583
#endif
584
            }
585
        }
586
    }
587
  }
588
 
589
  {
590
    struct partial_symtab *p;
591
 
592
    ALL_OBJFILE_PSYMTABS (objfile, p)
593
    {
594
      p->textlow += ANOFFSET (delta, SECT_OFF_TEXT);
595
      p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT);
596
    }
597
  }
598
 
599
  {
600
    struct partial_symbol **psym;
601
 
602
    for (psym = objfile->global_psymbols.list;
603
         psym < objfile->global_psymbols.next;
604
         psym++)
605
      if (SYMBOL_SECTION (*psym) >= 0)
606
        SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
607
                                                  SYMBOL_SECTION (*psym));
608
    for (psym = objfile->static_psymbols.list;
609
         psym < objfile->static_psymbols.next;
610
         psym++)
611
      if (SYMBOL_SECTION (*psym) >= 0)
612
        SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
613
                                                  SYMBOL_SECTION (*psym));
614
  }
615
 
616
  {
617
    struct minimal_symbol *msym;
618
    ALL_OBJFILE_MSYMBOLS (objfile, msym)
619
      if (SYMBOL_SECTION (msym) >= 0)
620
      SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
621
  }
622
  /* Relocating different sections by different amounts may cause the symbols
623
     to be out of order.  */
624
  msymbols_sort (objfile);
625
 
626
  {
627
    int i;
628
    for (i = 0; i < objfile->num_sections; ++i)
629
      ANOFFSET (objfile->section_offsets, i) = ANOFFSET (new_offsets, i);
630
  }
631
 
632
  {
633
    struct obj_section *s;
634
    bfd *abfd;
635
 
636
    abfd = objfile->obfd;
637
 
638
    ALL_OBJFILE_OSECTIONS (objfile, s)
639
      {
640
        flagword flags;
641
 
642
        flags = bfd_get_section_flags (abfd, s->the_bfd_section);
643
 
644
        if (flags & SEC_CODE)
645
          {
646
            s->addr += ANOFFSET (delta, SECT_OFF_TEXT);
647
            s->endaddr += ANOFFSET (delta, SECT_OFF_TEXT);
648
          }
649
        else if (flags & (SEC_DATA | SEC_LOAD))
650
          {
651
            s->addr += ANOFFSET (delta, SECT_OFF_DATA);
652
            s->endaddr += ANOFFSET (delta, SECT_OFF_DATA);
653
          }
654
        else if (flags & SEC_ALLOC)
655
          {
656
            s->addr += ANOFFSET (delta, SECT_OFF_BSS);
657
            s->endaddr += ANOFFSET (delta, SECT_OFF_BSS);
658
          }
659
      }
660
  }
661
 
662
  if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
663
    objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT);
664
 
665
  if (objfile->ei.entry_func_lowpc != INVALID_ENTRY_LOWPC)
666
    {
667
      objfile->ei.entry_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT);
668
      objfile->ei.entry_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT);
669
    }
670
 
671
  if (objfile->ei.entry_file_lowpc != INVALID_ENTRY_LOWPC)
672
    {
673
      objfile->ei.entry_file_lowpc += ANOFFSET (delta, SECT_OFF_TEXT);
674
      objfile->ei.entry_file_highpc += ANOFFSET (delta, SECT_OFF_TEXT);
675
    }
676
 
677
  if (objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC)
678
    {
679
      objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT);
680
      objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT);
681
    }
682
 
683
  /* Relocate breakpoints as necessary, after things are relocated. */
684
  breakpoint_re_set ();
685
}
686
 
687
/* Many places in gdb want to test just to see if we have any partial
688
   symbols available.  This function returns zero if none are currently
689
   available, nonzero otherwise. */
690
 
691
int
692
have_partial_symbols ()
693
{
694
  struct objfile *ofp;
695
 
696
  ALL_OBJFILES (ofp)
697
  {
698
    if (ofp->psymtabs != NULL)
699
      {
700
        return 1;
701
      }
702
  }
703
  return 0;
704
}
705
 
706
/* Many places in gdb want to test just to see if we have any full
707
   symbols available.  This function returns zero if none are currently
708
   available, nonzero otherwise. */
709
 
710
int
711
have_full_symbols ()
712
{
713
  struct objfile *ofp;
714
 
715
  ALL_OBJFILES (ofp)
716
  {
717
    if (ofp->symtabs != NULL)
718
      {
719
        return 1;
720
      }
721
  }
722
  return 0;
723
}
724
 
725
 
726
/* This operations deletes all objfile entries that represent solibs that
727
   weren't explicitly loaded by the user, via e.g., the add-symbol-file
728
   command.
729
 */
730
void
731
objfile_purge_solibs ()
732
{
733
  struct objfile *objf;
734
  struct objfile *temp;
735
 
736
  ALL_OBJFILES_SAFE (objf, temp)
737
  {
738
    /* We assume that the solib package has been purged already, or will
739
       be soon.
740
     */
741
    if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
742
      free_objfile (objf);
743
  }
744
}
745
 
746
 
747
/* Many places in gdb want to test just to see if we have any minimal
748
   symbols available.  This function returns zero if none are currently
749
   available, nonzero otherwise. */
750
 
751
int
752
have_minimal_symbols ()
753
{
754
  struct objfile *ofp;
755
 
756
  ALL_OBJFILES (ofp)
757
  {
758
    if (ofp->msymbols != NULL)
759
      {
760
        return 1;
761
      }
762
  }
763
  return 0;
764
}
765
 
766
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
767
 
768
/* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
769
   of the corresponding symbol file in MTIME, try to open an existing file
770
   with the name SYMSFILENAME and verify it is more recent than the base
771
   file by checking it's timestamp against MTIME.
772
 
773
   If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
774
 
775
   If SYMSFILENAME does exist, but is out of date, we check to see if the
776
   user has specified creation of a mapped file.  If so, we don't issue
777
   any warning message because we will be creating a new mapped file anyway,
778
   overwriting the old one.  If not, then we issue a warning message so that
779
   the user will know why we aren't using this existing mapped symbol file.
780
   In either case, we return -1.
781
 
782
   If SYMSFILENAME does exist and is not out of date, but can't be opened for
783
   some reason, then prints an appropriate system error message and returns -1.
784
 
785
   Otherwise, returns the open file descriptor.  */
786
 
787
static int
788
open_existing_mapped_file (symsfilename, mtime, flags)
789
     char *symsfilename;
790
     long mtime;
791
     int flags;
792
{
793
  int fd = -1;
794
  struct stat sbuf;
795
 
796
  if (stat (symsfilename, &sbuf) == 0)
797
    {
798
      if (sbuf.st_mtime < mtime)
799
        {
800
          if (!(flags & OBJF_MAPPED))
801
            {
802
              warning ("mapped symbol file `%s' is out of date, ignored it",
803
                       symsfilename);
804
            }
805
        }
806
      else if ((fd = open (symsfilename, O_RDWR)) < 0)
807
        {
808
          if (error_pre_print)
809
            {
810
              printf_unfiltered (error_pre_print);
811
            }
812
          print_sys_errmsg (symsfilename, errno);
813
        }
814
    }
815
  return (fd);
816
}
817
 
818
/* Look for a mapped symbol file that corresponds to FILENAME and is more
819
   recent than MTIME.  If MAPPED is nonzero, the user has asked that gdb
820
   use a mapped symbol file for this file, so create a new one if one does
821
   not currently exist.
822
 
823
   If found, then return an open file descriptor for the file, otherwise
824
   return -1.
825
 
826
   This routine is responsible for implementing the policy that generates
827
   the name of the mapped symbol file from the name of a file containing
828
   symbols that gdb would like to read.  Currently this policy is to append
829
   ".syms" to the name of the file.
830
 
831
   This routine is also responsible for implementing the policy that
832
   determines where the mapped symbol file is found (the search path).
833
   This policy is that when reading an existing mapped file, a file of
834
   the correct name in the current directory takes precedence over a
835
   file of the correct name in the same directory as the symbol file.
836
   When creating a new mapped file, it is always created in the current
837
   directory.  This helps to minimize the chances of a user unknowingly
838
   creating big mapped files in places like /bin and /usr/local/bin, and
839
   allows a local copy to override a manually installed global copy (in
840
   /bin for example).  */
841
 
842
static int
843
open_mapped_file (filename, mtime, flags)
844
     char *filename;
845
     long mtime;
846
     int flags;
847
{
848
  int fd;
849
  char *symsfilename;
850
 
851
  /* First try to open an existing file in the current directory, and
852
     then try the directory where the symbol file is located. */
853
 
854
  symsfilename = concat ("./", basename (filename), ".syms", (char *) NULL);
855
  if ((fd = open_existing_mapped_file (symsfilename, mtime, flags)) < 0)
856
    {
857
      free (symsfilename);
858
      symsfilename = concat (filename, ".syms", (char *) NULL);
859
      fd = open_existing_mapped_file (symsfilename, mtime, flags);
860
    }
861
 
862
  /* If we don't have an open file by now, then either the file does not
863
     already exist, or the base file has changed since it was created.  In
864
     either case, if the user has specified use of a mapped file, then
865
     create a new mapped file, truncating any existing one.  If we can't
866
     create one, print a system error message saying why we can't.
867
 
868
     By default the file is rw for everyone, with the user's umask taking
869
     care of turning off the permissions the user wants off. */
870
 
871
  if ((fd < 0) && (flags & OBJF_MAPPED))
872
    {
873
      free (symsfilename);
874
      symsfilename = concat ("./", basename (filename), ".syms",
875
                             (char *) NULL);
876
      if ((fd = open (symsfilename, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
877
        {
878
          if (error_pre_print)
879
            {
880
              printf_unfiltered (error_pre_print);
881
            }
882
          print_sys_errmsg (symsfilename, errno);
883
        }
884
    }
885
 
886
  free (symsfilename);
887
  return (fd);
888
}
889
 
890
static PTR
891
map_to_file (fd)
892
     int fd;
893
{
894
  PTR md;
895
  CORE_ADDR mapto;
896
 
897
  md = mmalloc_attach (fd, (PTR) 0);
898
  if (md != NULL)
899
    {
900
      mapto = (CORE_ADDR) mmalloc_getkey (md, 1);
901
      md = mmalloc_detach (md);
902
      if (md != NULL)
903
        {
904
          /* FIXME: should figure out why detach failed */
905
          md = NULL;
906
        }
907
      else if (mapto != (CORE_ADDR) NULL)
908
        {
909
          /* This mapping file needs to be remapped at "mapto" */
910
          md = mmalloc_attach (fd, (PTR) mapto);
911
        }
912
      else
913
        {
914
          /* This is a freshly created mapping file. */
915
          mapto = (CORE_ADDR) mmalloc_findbase (20 * 1024 * 1024);
916
          if (mapto != 0)
917
            {
918
              /* To avoid reusing the freshly created mapping file, at the
919
                 address selected by mmap, we must truncate it before trying
920
                 to do an attach at the address we want. */
921
              ftruncate (fd, 0);
922
              md = mmalloc_attach (fd, (PTR) mapto);
923
              if (md != NULL)
924
                {
925
                  mmalloc_setkey (md, 1, (PTR) mapto);
926
                }
927
            }
928
        }
929
    }
930
  return (md);
931
}
932
 
933
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
934
 
935
/* Returns a section whose range includes PC and SECTION,
936
   or NULL if none found.  Note the distinction between the return type,
937
   struct obj_section (which is defined in gdb), and the input type
938
   struct sec (which is a bfd-defined data type).  The obj_section
939
   contains a pointer to the bfd struct sec section.  */
940
 
941
struct obj_section *
942
find_pc_sect_section (pc, section)
943
     CORE_ADDR pc;
944
     struct sec *section;
945
{
946
  struct obj_section *s;
947
  struct objfile *objfile;
948
 
949
  ALL_OBJSECTIONS (objfile, s)
950
    if ((section == 0 || section == s->the_bfd_section) &&
951
        s->addr <= pc && pc < s->endaddr)
952
      return (s);
953
 
954
  return (NULL);
955
}
956
 
957
/* Returns a section whose range includes PC or NULL if none found.
958
   Backward compatibility, no section.  */
959
 
960
struct obj_section *
961
find_pc_section (pc)
962
     CORE_ADDR pc;
963
{
964
  return find_pc_sect_section (pc, find_pc_mapped_section (pc));
965
}
966
 
967
 
968
/* In SVR4, we recognize a trampoline by it's section name.
969
   That is, if the pc is in a section named ".plt" then we are in
970
   a trampoline.  */
971
 
972
int
973
in_plt_section (pc, name)
974
     CORE_ADDR pc;
975
     char *name;
976
{
977
  struct obj_section *s;
978
  int retval = 0;
979
 
980
  s = find_pc_section (pc);
981
 
982
  retval = (s != NULL
983
            && s->the_bfd_section->name != NULL
984
            && STREQ (s->the_bfd_section->name, ".plt"));
985
  return (retval);
986
}
987
 
988
/* Return nonzero if NAME is in the import list of OBJFILE.  Else
989
   return zero.  */
990
 
991
int
992
is_in_import_list (name, objfile)
993
     char *name;
994
     struct objfile *objfile;
995
{
996
  register int i;
997
 
998
  if (!objfile || !name || !*name)
999
    return 0;
1000
 
1001
  for (i = 0; i < objfile->import_list_size; i++)
1002
    if (objfile->import_list[i] && STREQ (name, objfile->import_list[i]))
1003
      return 1;
1004
  return 0;
1005
}
1006
 

powered by: WebSVN 2.1.0

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