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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [minsyms.c] - Blame information for rev 816

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

Line No. Rev Author Line
1 24 jeremybenn
/* GDB routines for manipulating the minimal symbol tables.
2
   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3
   2002, 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
4
   Contributed by Cygnus Support, using pieces from other GDB modules.
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
 
22
/* This file contains support routines for creating, manipulating, and
23
   destroying minimal symbol tables.
24
 
25
   Minimal symbol tables are used to hold some very basic information about
26
   all defined global symbols (text, data, bss, abs, etc).  The only two
27
   required pieces of information are the symbol's name and the address
28
   associated with that symbol.
29
 
30
   In many cases, even if a file was compiled with no special options for
31
   debugging at all, as long as was not stripped it will contain sufficient
32
   information to build useful minimal symbol tables using this structure.
33
 
34
   Even when a file contains enough debugging information to build a full
35
   symbol table, these minimal symbols are still useful for quickly mapping
36
   between names and addresses, and vice versa.  They are also sometimes used
37
   to figure out what full symbol table entries need to be read in. */
38
 
39
 
40
#include "defs.h"
41
#include <ctype.h>
42
#include "gdb_string.h"
43
#include "symtab.h"
44
#include "bfd.h"
45
#include "symfile.h"
46
#include "objfiles.h"
47
#include "demangle.h"
48
#include "value.h"
49
#include "cp-abi.h"
50
 
51
/* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
52
   At the end, copy them all into one newly allocated location on an objfile's
53
   symbol obstack.  */
54
 
55
#define BUNCH_SIZE 127
56
 
57
struct msym_bunch
58
  {
59
    struct msym_bunch *next;
60
    struct minimal_symbol contents[BUNCH_SIZE];
61
  };
62
 
63
/* Bunch currently being filled up.
64
   The next field points to chain of filled bunches.  */
65
 
66
static struct msym_bunch *msym_bunch;
67
 
68
/* Number of slots filled in current bunch.  */
69
 
70
static int msym_bunch_index;
71
 
72
/* Total number of minimal symbols recorded so far for the objfile.  */
73
 
74
static int msym_count;
75
 
76
/* Compute a hash code based using the same criteria as `strcmp_iw'.  */
77
 
78
unsigned int
79
msymbol_hash_iw (const char *string)
80
{
81
  unsigned int hash = 0;
82
  while (*string && *string != '(')
83
    {
84
      while (isspace (*string))
85
        ++string;
86
      if (*string && *string != '(')
87
        {
88
          hash = hash * 67 + *string - 113;
89
          ++string;
90
        }
91
    }
92
  return hash;
93
}
94
 
95
/* Compute a hash code for a string.  */
96
 
97
unsigned int
98
msymbol_hash (const char *string)
99
{
100
  unsigned int hash = 0;
101
  for (; *string; ++string)
102
    hash = hash * 67 + *string - 113;
103
  return hash;
104
}
105
 
106
/* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE.  */
107
void
108
add_minsym_to_hash_table (struct minimal_symbol *sym,
109
                          struct minimal_symbol **table)
110
{
111
  if (sym->hash_next == NULL)
112
    {
113
      unsigned int hash
114
        = msymbol_hash (SYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
115
      sym->hash_next = table[hash];
116
      table[hash] = sym;
117
    }
118
}
119
 
120
/* Add the minimal symbol SYM to an objfile's minsym demangled hash table,
121
   TABLE.  */
122
static void
123
add_minsym_to_demangled_hash_table (struct minimal_symbol *sym,
124
                                  struct minimal_symbol **table)
125
{
126
  if (sym->demangled_hash_next == NULL)
127
    {
128
      unsigned int hash = msymbol_hash_iw (SYMBOL_DEMANGLED_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
129
      sym->demangled_hash_next = table[hash];
130
      table[hash] = sym;
131
    }
132
}
133
 
134
 
135
/* Look through all the current minimal symbol tables and find the
136
   first minimal symbol that matches NAME.  If OBJF is non-NULL, limit
137
   the search to that objfile.  If SFILE is non-NULL, the only file-scope
138
   symbols considered will be from that source file (global symbols are
139
   still preferred).  Returns a pointer to the minimal symbol that
140
   matches, or NULL if no match is found.
141
 
142
   Note:  One instance where there may be duplicate minimal symbols with
143
   the same name is when the symbol tables for a shared library and the
144
   symbol tables for an executable contain global symbols with the same
145
   names (the dynamic linker deals with the duplication).
146
 
147
   It's also possible to have minimal symbols with different mangled
148
   names, but identical demangled names.  For example, the GNU C++ v3
149
   ABI requires the generation of two (or perhaps three) copies of
150
   constructor functions --- "in-charge", "not-in-charge", and
151
   "allocate" copies; destructors may be duplicated as well.
152
   Obviously, there must be distinct mangled names for each of these,
153
   but the demangled names are all the same: S::S or S::~S.  */
154
 
155
struct minimal_symbol *
156
lookup_minimal_symbol (const char *name, const char *sfile,
157
                       struct objfile *objf)
158
{
159
  struct objfile *objfile;
160
  struct minimal_symbol *msymbol;
161
  struct minimal_symbol *found_symbol = NULL;
162
  struct minimal_symbol *found_file_symbol = NULL;
163
  struct minimal_symbol *trampoline_symbol = NULL;
164
 
165
  unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
166
  unsigned int dem_hash = msymbol_hash_iw (name) % MINIMAL_SYMBOL_HASH_SIZE;
167
 
168
  if (sfile != NULL)
169
    {
170
      char *p = strrchr (sfile, '/');
171
      if (p != NULL)
172
        sfile = p + 1;
173
    }
174
 
175
  for (objfile = object_files;
176
       objfile != NULL && found_symbol == NULL;
177
       objfile = objfile->next)
178
    {
179
      if (objf == NULL || objf == objfile
180
          || objf->separate_debug_objfile == objfile)
181
        {
182
          /* Do two passes: the first over the ordinary hash table,
183
             and the second over the demangled hash table.  */
184
        int pass;
185
 
186
        for (pass = 1; pass <= 2 && found_symbol == NULL; pass++)
187
            {
188
            /* Select hash list according to pass.  */
189
            if (pass == 1)
190
              msymbol = objfile->msymbol_hash[hash];
191
            else
192
              msymbol = objfile->msymbol_demangled_hash[dem_hash];
193
 
194
            while (msymbol != NULL && found_symbol == NULL)
195
                {
196
                  /* FIXME: carlton/2003-02-27: This is an unholy
197
                     mixture of linkage names and natural names.  If
198
                     you want to test the linkage names with strcmp,
199
                     do that.  If you want to test the natural names
200
                     with strcmp_iw, use SYMBOL_MATCHES_NATURAL_NAME.  */
201
                  if (strcmp (DEPRECATED_SYMBOL_NAME (msymbol), (name)) == 0
202
                      || (SYMBOL_DEMANGLED_NAME (msymbol) != NULL
203
                          && strcmp_iw (SYMBOL_DEMANGLED_NAME (msymbol),
204
                                        (name)) == 0))
205
                    {
206
                    switch (MSYMBOL_TYPE (msymbol))
207
                      {
208
                      case mst_file_text:
209
                      case mst_file_data:
210
                      case mst_file_bss:
211
                        if (sfile == NULL
212
                            || strcmp (msymbol->filename, sfile) == 0)
213
                          found_file_symbol = msymbol;
214
                        break;
215
 
216
                      case mst_solib_trampoline:
217
 
218
                        /* If a trampoline symbol is found, we prefer to
219
                           keep looking for the *real* symbol. If the
220
                           actual symbol is not found, then we'll use the
221
                           trampoline entry. */
222
                        if (trampoline_symbol == NULL)
223
                          trampoline_symbol = msymbol;
224
                        break;
225
 
226
                      case mst_unknown:
227
                      default:
228
                        found_symbol = msymbol;
229
                        break;
230
                      }
231
                    }
232
 
233
                /* Find the next symbol on the hash chain.  */
234
                if (pass == 1)
235
                  msymbol = msymbol->hash_next;
236
                else
237
                  msymbol = msymbol->demangled_hash_next;
238
                }
239
            }
240
        }
241
    }
242
  /* External symbols are best.  */
243
  if (found_symbol)
244
    return found_symbol;
245
 
246
  /* File-local symbols are next best.  */
247
  if (found_file_symbol)
248
    return found_file_symbol;
249
 
250
  /* Symbols for shared library trampolines are next best.  */
251
  if (trampoline_symbol)
252
    return trampoline_symbol;
253
 
254
  return NULL;
255
}
256
 
257
/* Look through all the current minimal symbol tables and find the
258
   first minimal symbol that matches NAME and has text type.  If OBJF
259
   is non-NULL, limit the search to that objfile.  Returns a pointer
260
   to the minimal symbol that matches, or NULL if no match is found.
261
 
262
   This function only searches the mangled (linkage) names.  */
263
 
264
struct minimal_symbol *
265
lookup_minimal_symbol_text (const char *name, struct objfile *objf)
266
{
267
  struct objfile *objfile;
268
  struct minimal_symbol *msymbol;
269
  struct minimal_symbol *found_symbol = NULL;
270
  struct minimal_symbol *found_file_symbol = NULL;
271
 
272
  unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
273
 
274
  for (objfile = object_files;
275
       objfile != NULL && found_symbol == NULL;
276
       objfile = objfile->next)
277
    {
278
      if (objf == NULL || objf == objfile
279
          || objf->separate_debug_objfile == objfile)
280
        {
281
          for (msymbol = objfile->msymbol_hash[hash];
282
               msymbol != NULL && found_symbol == NULL;
283
               msymbol = msymbol->hash_next)
284
            {
285
              if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
286
                  (MSYMBOL_TYPE (msymbol) == mst_text ||
287
                   MSYMBOL_TYPE (msymbol) == mst_file_text))
288
                {
289
                  switch (MSYMBOL_TYPE (msymbol))
290
                    {
291
                    case mst_file_text:
292
                      found_file_symbol = msymbol;
293
                      break;
294
                    default:
295
                      found_symbol = msymbol;
296
                      break;
297
                    }
298
                }
299
            }
300
        }
301
    }
302
  /* External symbols are best.  */
303
  if (found_symbol)
304
    return found_symbol;
305
 
306
  /* File-local symbols are next best.  */
307
  if (found_file_symbol)
308
    return found_file_symbol;
309
 
310
  return NULL;
311
}
312
 
313
/* Look through all the current minimal symbol tables and find the
314
   first minimal symbol that matches NAME and is a solib trampoline.
315
   If OBJF is non-NULL, limit the search to that objfile.  Returns a
316
   pointer to the minimal symbol that matches, or NULL if no match is
317
   found.
318
 
319
   This function only searches the mangled (linkage) names.  */
320
 
321
struct minimal_symbol *
322
lookup_minimal_symbol_solib_trampoline (const char *name,
323
                                        struct objfile *objf)
324
{
325
  struct objfile *objfile;
326
  struct minimal_symbol *msymbol;
327
  struct minimal_symbol *found_symbol = NULL;
328
 
329
  unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
330
 
331
  for (objfile = object_files;
332
       objfile != NULL && found_symbol == NULL;
333
       objfile = objfile->next)
334
    {
335
      if (objf == NULL || objf == objfile
336
          || objf->separate_debug_objfile == objfile)
337
        {
338
          for (msymbol = objfile->msymbol_hash[hash];
339
               msymbol != NULL && found_symbol == NULL;
340
               msymbol = msymbol->hash_next)
341
            {
342
              if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
343
                  MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
344
                return msymbol;
345
            }
346
        }
347
    }
348
 
349
  return NULL;
350
}
351
 
352
/* Search through the minimal symbol table for each objfile and find
353
   the symbol whose address is the largest address that is still less
354
   than or equal to PC, and matches SECTION (if non-NULL).  Returns a
355
   pointer to the minimal symbol if such a symbol is found, or NULL if
356
   PC is not in a suitable range.  Note that we need to look through
357
   ALL the minimal symbol tables before deciding on the symbol that
358
   comes closest to the specified PC.  This is because objfiles can
359
   overlap, for example objfile A has .text at 0x100 and .data at
360
   0x40000 and objfile B has .text at 0x234 and .data at 0x40048.  */
361
 
362
struct minimal_symbol *
363
lookup_minimal_symbol_by_pc_section (CORE_ADDR pc, asection *section)
364
{
365
  int lo;
366
  int hi;
367
  int new;
368
  struct objfile *objfile;
369
  struct minimal_symbol *msymbol;
370
  struct minimal_symbol *best_symbol = NULL;
371
  struct obj_section *pc_section;
372
 
373
  /* PC has to be in a known section.  This ensures that anything
374
     beyond the end of the last segment doesn't appear to be part of
375
     the last function in the last segment.  */
376
  pc_section = find_pc_section (pc);
377
  if (pc_section == NULL)
378
    return NULL;
379
 
380
  /* We can not require the symbol found to be in pc_section, because
381
     e.g. IRIX 6.5 mdebug relies on this code returning an absolute
382
     symbol - but find_pc_section won't return an absolute section and
383
     hence the code below would skip over absolute symbols.  We can
384
     still take advantage of the call to find_pc_section, though - the
385
     object file still must match.  In case we have separate debug
386
     files, search both the file and its separate debug file.  There's
387
     no telling which one will have the minimal symbols.  */
388
 
389
  objfile = pc_section->objfile;
390
  if (objfile->separate_debug_objfile)
391
    objfile = objfile->separate_debug_objfile;
392
 
393
  for (; objfile != NULL; objfile = objfile->separate_debug_objfile_backlink)
394
    {
395
      /* If this objfile has a minimal symbol table, go search it using
396
         a binary search.  Note that a minimal symbol table always consists
397
         of at least two symbols, a "real" symbol and the terminating
398
         "null symbol".  If there are no real symbols, then there is no
399
         minimal symbol table at all. */
400
 
401
      if (objfile->minimal_symbol_count > 0)
402
        {
403
          int best_zero_sized = -1;
404
 
405
          msymbol = objfile->msymbols;
406
          lo = 0;
407
          hi = objfile->minimal_symbol_count - 1;
408
 
409
          /* This code assumes that the minimal symbols are sorted by
410
             ascending address values.  If the pc value is greater than or
411
             equal to the first symbol's address, then some symbol in this
412
             minimal symbol table is a suitable candidate for being the
413
             "best" symbol.  This includes the last real symbol, for cases
414
             where the pc value is larger than any address in this vector.
415
 
416
             By iterating until the address associated with the current
417
             hi index (the endpoint of the test interval) is less than
418
             or equal to the desired pc value, we accomplish two things:
419
             (1) the case where the pc value is larger than any minimal
420
             symbol address is trivially solved, (2) the address associated
421
             with the hi index is always the one we want when the interation
422
             terminates.  In essence, we are iterating the test interval
423
             down until the pc value is pushed out of it from the high end.
424
 
425
             Warning: this code is trickier than it would appear at first. */
426
 
427
          /* Should also require that pc is <= end of objfile.  FIXME! */
428
          if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo]))
429
            {
430
              while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
431
                {
432
                  /* pc is still strictly less than highest address */
433
                  /* Note "new" will always be >= lo */
434
                  new = (lo + hi) / 2;
435
                  if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
436
                      (lo == new))
437
                    {
438
                      hi = new;
439
                    }
440
                  else
441
                    {
442
                      lo = new;
443
                    }
444
                }
445
 
446
              /* If we have multiple symbols at the same address, we want
447
                 hi to point to the last one.  That way we can find the
448
                 right symbol if it has an index greater than hi.  */
449
              while (hi < objfile->minimal_symbol_count - 1
450
                     && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
451
                         == SYMBOL_VALUE_ADDRESS (&msymbol[hi + 1])))
452
                hi++;
453
 
454
              /* Skip various undesirable symbols.  */
455
              while (hi >= 0)
456
                {
457
                  /* Skip any absolute symbols.  This is apparently
458
                     what adb and dbx do, and is needed for the CM-5.
459
                     There are two known possible problems: (1) on
460
                     ELF, apparently end, edata, etc. are absolute.
461
                     Not sure ignoring them here is a big deal, but if
462
                     we want to use them, the fix would go in
463
                     elfread.c.  (2) I think shared library entry
464
                     points on the NeXT are absolute.  If we want
465
                     special handling for this it probably should be
466
                     triggered by a special mst_abs_or_lib or some
467
                     such.  */
468
 
469
                  if (msymbol[hi].type == mst_abs)
470
                    {
471
                      hi--;
472
                      continue;
473
                    }
474
 
475
                  /* If SECTION was specified, skip any symbol from
476
                     wrong section.  */
477
                  if (section
478
                      /* Some types of debug info, such as COFF,
479
                         don't fill the bfd_section member, so don't
480
                         throw away symbols on those platforms.  */
481
                      && SYMBOL_BFD_SECTION (&msymbol[hi]) != NULL
482
                      && (!matching_bfd_sections
483
                          (SYMBOL_BFD_SECTION (&msymbol[hi]), section)))
484
                    {
485
                      hi--;
486
                      continue;
487
                    }
488
 
489
                  /* If the minimal symbol has a zero size, save it
490
                     but keep scanning backwards looking for one with
491
                     a non-zero size.  A zero size may mean that the
492
                     symbol isn't an object or function (e.g. a
493
                     label), or it may just mean that the size was not
494
                     specified.  */
495
                  if (MSYMBOL_SIZE (&msymbol[hi]) == 0
496
                      && best_zero_sized == -1)
497
                    {
498
                      best_zero_sized = hi;
499
                      hi--;
500
                      continue;
501
                    }
502
 
503
                  /* If we are past the end of the current symbol, try
504
                     the previous symbol if it has a larger overlapping
505
                     size.  This happens on i686-pc-linux-gnu with glibc;
506
                     the nocancel variants of system calls are inside
507
                     the cancellable variants, but both have sizes.  */
508
                  if (hi > 0
509
                      && MSYMBOL_SIZE (&msymbol[hi]) != 0
510
                      && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
511
                                + MSYMBOL_SIZE (&msymbol[hi]))
512
                      && pc < (SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1])
513
                               + MSYMBOL_SIZE (&msymbol[hi - 1])))
514
                    {
515
                      hi--;
516
                      continue;
517
                    }
518
 
519
                  /* Otherwise, this symbol must be as good as we're going
520
                     to get.  */
521
                  break;
522
                }
523
 
524
              /* If HI has a zero size, and best_zero_sized is set,
525
                 then we had two or more zero-sized symbols; prefer
526
                 the first one we found (which may have a higher
527
                 address).  Also, if we ran off the end, be sure
528
                 to back up.  */
529
              if (best_zero_sized != -1
530
                  && (hi < 0 || MSYMBOL_SIZE (&msymbol[hi]) == 0))
531
                hi = best_zero_sized;
532
 
533
              /* If the minimal symbol has a non-zero size, and this
534
                 PC appears to be outside the symbol's contents, then
535
                 refuse to use this symbol.  If we found a zero-sized
536
                 symbol with an address greater than this symbol's,
537
                 use that instead.  We assume that if symbols have
538
                 specified sizes, they do not overlap.  */
539
 
540
              if (hi >= 0
541
                  && MSYMBOL_SIZE (&msymbol[hi]) != 0
542
                  && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
543
                            + MSYMBOL_SIZE (&msymbol[hi])))
544
                {
545
                  if (best_zero_sized != -1)
546
                    hi = best_zero_sized;
547
                  else
548
                    /* Go on to the next object file.  */
549
                    continue;
550
                }
551
 
552
              /* The minimal symbol indexed by hi now is the best one in this
553
                 objfile's minimal symbol table.  See if it is the best one
554
                 overall. */
555
 
556
              if (hi >= 0
557
                  && ((best_symbol == NULL) ||
558
                      (SYMBOL_VALUE_ADDRESS (best_symbol) <
559
                       SYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
560
                {
561
                  best_symbol = &msymbol[hi];
562
                }
563
            }
564
        }
565
    }
566
  return (best_symbol);
567
}
568
 
569
/* Backward compatibility: search through the minimal symbol table
570
   for a matching PC (no section given) */
571
 
572
struct minimal_symbol *
573
lookup_minimal_symbol_by_pc (CORE_ADDR pc)
574
{
575
  /* NOTE: cagney/2004-01-27: This was using find_pc_mapped_section to
576
     force the section but that (well unless you're doing overlay
577
     debugging) always returns NULL making the call somewhat useless.  */
578
  struct obj_section *section = find_pc_section (pc);
579
  if (section == NULL)
580
    return NULL;
581
  return lookup_minimal_symbol_by_pc_section (pc, section->the_bfd_section);
582
}
583
 
584
 
585
/* Return leading symbol character for a BFD. If BFD is NULL,
586
   return the leading symbol character from the main objfile.  */
587
 
588
static int get_symbol_leading_char (bfd *);
589
 
590
static int
591
get_symbol_leading_char (bfd *abfd)
592
{
593
  if (abfd != NULL)
594
    return bfd_get_symbol_leading_char (abfd);
595
  if (symfile_objfile != NULL && symfile_objfile->obfd != NULL)
596
    return bfd_get_symbol_leading_char (symfile_objfile->obfd);
597
  return 0;
598
}
599
 
600
/* Prepare to start collecting minimal symbols.  Note that presetting
601
   msym_bunch_index to BUNCH_SIZE causes the first call to save a minimal
602
   symbol to allocate the memory for the first bunch. */
603
 
604
void
605
init_minimal_symbol_collection (void)
606
{
607
  msym_count = 0;
608
  msym_bunch = NULL;
609
  msym_bunch_index = BUNCH_SIZE;
610
}
611
 
612
void
613
prim_record_minimal_symbol (const char *name, CORE_ADDR address,
614
                            enum minimal_symbol_type ms_type,
615
                            struct objfile *objfile)
616
{
617
  int section;
618
 
619
  switch (ms_type)
620
    {
621
    case mst_text:
622
    case mst_file_text:
623
    case mst_solib_trampoline:
624
      section = SECT_OFF_TEXT (objfile);
625
      break;
626
    case mst_data:
627
    case mst_file_data:
628
      section = SECT_OFF_DATA (objfile);
629
      break;
630
    case mst_bss:
631
    case mst_file_bss:
632
      section = SECT_OFF_BSS (objfile);
633
      break;
634
    default:
635
      section = -1;
636
    }
637
 
638
  prim_record_minimal_symbol_and_info (name, address, ms_type,
639
                                       NULL, section, NULL, objfile);
640
}
641
 
642
/* Record a minimal symbol in the msym bunches.  Returns the symbol
643
   newly created.  */
644
 
645
struct minimal_symbol *
646
prim_record_minimal_symbol_and_info (const char *name, CORE_ADDR address,
647
                                     enum minimal_symbol_type ms_type,
648
                                     char *info, int section,
649
                                     asection *bfd_section,
650
                                     struct objfile *objfile)
651
{
652
  struct msym_bunch *new;
653
  struct minimal_symbol *msymbol;
654
 
655
  /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
656
     the minimal symbols, because if there is also another symbol
657
     at the same address (e.g. the first function of the file),
658
     lookup_minimal_symbol_by_pc would have no way of getting the
659
     right one.  */
660
  if (ms_type == mst_file_text && name[0] == 'g'
661
      && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
662
          || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
663
    return (NULL);
664
 
665
  /* It's safe to strip the leading char here once, since the name
666
     is also stored stripped in the minimal symbol table. */
667
  if (name[0] == get_symbol_leading_char (objfile->obfd))
668
    ++name;
669
 
670
  if (ms_type == mst_file_text && strncmp (name, "__gnu_compiled", 14) == 0)
671
    return (NULL);
672
 
673
  if (msym_bunch_index == BUNCH_SIZE)
674
    {
675
      new = (struct msym_bunch *) xmalloc (sizeof (struct msym_bunch));
676
      msym_bunch_index = 0;
677
      new->next = msym_bunch;
678
      msym_bunch = new;
679
    }
680
  msymbol = &msym_bunch->contents[msym_bunch_index];
681
  SYMBOL_INIT_LANGUAGE_SPECIFIC (msymbol, language_unknown);
682
  SYMBOL_LANGUAGE (msymbol) = language_auto;
683
  SYMBOL_SET_NAMES (msymbol, (char *)name, strlen (name), objfile);
684
 
685
  SYMBOL_VALUE_ADDRESS (msymbol) = address;
686
  SYMBOL_SECTION (msymbol) = section;
687
  SYMBOL_BFD_SECTION (msymbol) = bfd_section;
688
 
689
  MSYMBOL_TYPE (msymbol) = ms_type;
690
  /* FIXME:  This info, if it remains, needs its own field.  */
691
  MSYMBOL_INFO (msymbol) = info;        /* FIXME! */
692
  MSYMBOL_SIZE (msymbol) = 0;
693
 
694
  /* The hash pointers must be cleared! If they're not,
695
     add_minsym_to_hash_table will NOT add this msymbol to the hash table. */
696
  msymbol->hash_next = NULL;
697
  msymbol->demangled_hash_next = NULL;
698
 
699
  msym_bunch_index++;
700
  msym_count++;
701
  OBJSTAT (objfile, n_minsyms++);
702
  return msymbol;
703
}
704
 
705
/* Compare two minimal symbols by address and return a signed result based
706
   on unsigned comparisons, so that we sort into unsigned numeric order.
707
   Within groups with the same address, sort by name.  */
708
 
709
static int
710
compare_minimal_symbols (const void *fn1p, const void *fn2p)
711
{
712
  const struct minimal_symbol *fn1;
713
  const struct minimal_symbol *fn2;
714
 
715
  fn1 = (const struct minimal_symbol *) fn1p;
716
  fn2 = (const struct minimal_symbol *) fn2p;
717
 
718
  if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2))
719
    {
720
      return (-1);              /* addr 1 is less than addr 2 */
721
    }
722
  else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2))
723
    {
724
      return (1);               /* addr 1 is greater than addr 2 */
725
    }
726
  else
727
    /* addrs are equal: sort by name */
728
    {
729
      char *name1 = SYMBOL_LINKAGE_NAME (fn1);
730
      char *name2 = SYMBOL_LINKAGE_NAME (fn2);
731
 
732
      if (name1 && name2)       /* both have names */
733
        return strcmp (name1, name2);
734
      else if (name2)
735
        return 1;               /* fn1 has no name, so it is "less" */
736
      else if (name1)           /* fn2 has no name, so it is "less" */
737
        return -1;
738
      else
739
        return (0);              /* neither has a name, so they're equal. */
740
    }
741
}
742
 
743
/* Discard the currently collected minimal symbols, if any.  If we wish
744
   to save them for later use, we must have already copied them somewhere
745
   else before calling this function.
746
 
747
   FIXME:  We could allocate the minimal symbol bunches on their own
748
   obstack and then simply blow the obstack away when we are done with
749
   it.  Is it worth the extra trouble though? */
750
 
751
static void
752
do_discard_minimal_symbols_cleanup (void *arg)
753
{
754
  struct msym_bunch *next;
755
 
756
  while (msym_bunch != NULL)
757
    {
758
      next = msym_bunch->next;
759
      xfree (msym_bunch);
760
      msym_bunch = next;
761
    }
762
}
763
 
764
struct cleanup *
765
make_cleanup_discard_minimal_symbols (void)
766
{
767
  return make_cleanup (do_discard_minimal_symbols_cleanup, 0);
768
}
769
 
770
 
771
 
772
/* Compact duplicate entries out of a minimal symbol table by walking
773
   through the table and compacting out entries with duplicate addresses
774
   and matching names.  Return the number of entries remaining.
775
 
776
   On entry, the table resides between msymbol[0] and msymbol[mcount].
777
   On exit, it resides between msymbol[0] and msymbol[result_count].
778
 
779
   When files contain multiple sources of symbol information, it is
780
   possible for the minimal symbol table to contain many duplicate entries.
781
   As an example, SVR4 systems use ELF formatted object files, which
782
   usually contain at least two different types of symbol tables (a
783
   standard ELF one and a smaller dynamic linking table), as well as
784
   DWARF debugging information for files compiled with -g.
785
 
786
   Without compacting, the minimal symbol table for gdb itself contains
787
   over a 1000 duplicates, about a third of the total table size.  Aside
788
   from the potential trap of not noticing that two successive entries
789
   identify the same location, this duplication impacts the time required
790
   to linearly scan the table, which is done in a number of places.  So we
791
   just do one linear scan here and toss out the duplicates.
792
 
793
   Note that we are not concerned here about recovering the space that
794
   is potentially freed up, because the strings themselves are allocated
795
   on the objfile_obstack, and will get automatically freed when the symbol
796
   table is freed.  The caller can free up the unused minimal symbols at
797
   the end of the compacted region if their allocation strategy allows it.
798
 
799
   Also note we only go up to the next to last entry within the loop
800
   and then copy the last entry explicitly after the loop terminates.
801
 
802
   Since the different sources of information for each symbol may
803
   have different levels of "completeness", we may have duplicates
804
   that have one entry with type "mst_unknown" and the other with a
805
   known type.  So if the one we are leaving alone has type mst_unknown,
806
   overwrite its type with the type from the one we are compacting out.  */
807
 
808
static int
809
compact_minimal_symbols (struct minimal_symbol *msymbol, int mcount,
810
                         struct objfile *objfile)
811
{
812
  struct minimal_symbol *copyfrom;
813
  struct minimal_symbol *copyto;
814
 
815
  if (mcount > 0)
816
    {
817
      copyfrom = copyto = msymbol;
818
      while (copyfrom < msymbol + mcount - 1)
819
        {
820
          if (SYMBOL_VALUE_ADDRESS (copyfrom)
821
              == SYMBOL_VALUE_ADDRESS ((copyfrom + 1))
822
              && strcmp (SYMBOL_LINKAGE_NAME (copyfrom),
823
                         SYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0)
824
            {
825
              if (MSYMBOL_TYPE ((copyfrom + 1)) == mst_unknown)
826
                {
827
                  MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom);
828
                }
829
              copyfrom++;
830
            }
831
          else
832
            *copyto++ = *copyfrom++;
833
        }
834
      *copyto++ = *copyfrom++;
835
      mcount = copyto - msymbol;
836
    }
837
  return (mcount);
838
}
839
 
840
/* Build (or rebuild) the minimal symbol hash tables.  This is necessary
841
   after compacting or sorting the table since the entries move around
842
   thus causing the internal minimal_symbol pointers to become jumbled. */
843
 
844
static void
845
build_minimal_symbol_hash_tables (struct objfile *objfile)
846
{
847
  int i;
848
  struct minimal_symbol *msym;
849
 
850
  /* Clear the hash tables. */
851
  for (i = 0; i < MINIMAL_SYMBOL_HASH_SIZE; i++)
852
    {
853
      objfile->msymbol_hash[i] = 0;
854
      objfile->msymbol_demangled_hash[i] = 0;
855
    }
856
 
857
  /* Now, (re)insert the actual entries. */
858
  for (i = objfile->minimal_symbol_count, msym = objfile->msymbols;
859
       i > 0;
860
       i--, msym++)
861
    {
862
      msym->hash_next = 0;
863
      add_minsym_to_hash_table (msym, objfile->msymbol_hash);
864
 
865
      msym->demangled_hash_next = 0;
866
      if (SYMBOL_SEARCH_NAME (msym) != SYMBOL_LINKAGE_NAME (msym))
867
        add_minsym_to_demangled_hash_table (msym,
868
                                            objfile->msymbol_demangled_hash);
869
    }
870
}
871
 
872
/* Add the minimal symbols in the existing bunches to the objfile's official
873
   minimal symbol table.  In most cases there is no minimal symbol table yet
874
   for this objfile, and the existing bunches are used to create one.  Once
875
   in a while (for shared libraries for example), we add symbols (e.g. common
876
   symbols) to an existing objfile.
877
 
878
   Because of the way minimal symbols are collected, we generally have no way
879
   of knowing what source language applies to any particular minimal symbol.
880
   Specifically, we have no way of knowing if the minimal symbol comes from a
881
   C++ compilation unit or not.  So for the sake of supporting cached
882
   demangled C++ names, we have no choice but to try and demangle each new one
883
   that comes in.  If the demangling succeeds, then we assume it is a C++
884
   symbol and set the symbol's language and demangled name fields
885
   appropriately.  Note that in order to avoid unnecessary demanglings, and
886
   allocating obstack space that subsequently can't be freed for the demangled
887
   names, we mark all newly added symbols with language_auto.  After
888
   compaction of the minimal symbols, we go back and scan the entire minimal
889
   symbol table looking for these new symbols.  For each new symbol we attempt
890
   to demangle it, and if successful, record it as a language_cplus symbol
891
   and cache the demangled form on the symbol obstack.  Symbols which don't
892
   demangle are marked as language_unknown symbols, which inhibits future
893
   attempts to demangle them if we later add more minimal symbols. */
894
 
895
void
896
install_minimal_symbols (struct objfile *objfile)
897
{
898
  int bindex;
899
  int mcount;
900
  struct msym_bunch *bunch;
901
  struct minimal_symbol *msymbols;
902
  int alloc_count;
903
 
904
  if (msym_count > 0)
905
    {
906
      /* Allocate enough space in the obstack, into which we will gather the
907
         bunches of new and existing minimal symbols, sort them, and then
908
         compact out the duplicate entries.  Once we have a final table,
909
         we will give back the excess space.  */
910
 
911
      alloc_count = msym_count + objfile->minimal_symbol_count + 1;
912
      obstack_blank (&objfile->objfile_obstack,
913
                     alloc_count * sizeof (struct minimal_symbol));
914
      msymbols = (struct minimal_symbol *)
915
        obstack_base (&objfile->objfile_obstack);
916
 
917
      /* Copy in the existing minimal symbols, if there are any.  */
918
 
919
      if (objfile->minimal_symbol_count)
920
        memcpy ((char *) msymbols, (char *) objfile->msymbols,
921
            objfile->minimal_symbol_count * sizeof (struct minimal_symbol));
922
 
923
      /* Walk through the list of minimal symbol bunches, adding each symbol
924
         to the new contiguous array of symbols.  Note that we start with the
925
         current, possibly partially filled bunch (thus we use the current
926
         msym_bunch_index for the first bunch we copy over), and thereafter
927
         each bunch is full. */
928
 
929
      mcount = objfile->minimal_symbol_count;
930
 
931
      for (bunch = msym_bunch; bunch != NULL; bunch = bunch->next)
932
        {
933
          for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
934
            msymbols[mcount] = bunch->contents[bindex];
935
          msym_bunch_index = BUNCH_SIZE;
936
        }
937
 
938
      /* Sort the minimal symbols by address.  */
939
 
940
      qsort (msymbols, mcount, sizeof (struct minimal_symbol),
941
             compare_minimal_symbols);
942
 
943
      /* Compact out any duplicates, and free up whatever space we are
944
         no longer using.  */
945
 
946
      mcount = compact_minimal_symbols (msymbols, mcount, objfile);
947
 
948
      obstack_blank (&objfile->objfile_obstack,
949
               (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
950
      msymbols = (struct minimal_symbol *)
951
        obstack_finish (&objfile->objfile_obstack);
952
 
953
      /* We also terminate the minimal symbol table with a "null symbol",
954
         which is *not* included in the size of the table.  This makes it
955
         easier to find the end of the table when we are handed a pointer
956
         to some symbol in the middle of it.  Zero out the fields in the
957
         "null symbol" allocated at the end of the array.  Note that the
958
         symbol count does *not* include this null symbol, which is why it
959
         is indexed by mcount and not mcount-1. */
960
 
961
      SYMBOL_LINKAGE_NAME (&msymbols[mcount]) = NULL;
962
      SYMBOL_VALUE_ADDRESS (&msymbols[mcount]) = 0;
963
      MSYMBOL_INFO (&msymbols[mcount]) = NULL;
964
      MSYMBOL_SIZE (&msymbols[mcount]) = 0;
965
      MSYMBOL_TYPE (&msymbols[mcount]) = mst_unknown;
966
      SYMBOL_INIT_LANGUAGE_SPECIFIC (&msymbols[mcount], language_unknown);
967
 
968
      /* Attach the minimal symbol table to the specified objfile.
969
         The strings themselves are also located in the objfile_obstack
970
         of this objfile.  */
971
 
972
      objfile->minimal_symbol_count = mcount;
973
      objfile->msymbols = msymbols;
974
 
975
      /* Try to guess the appropriate C++ ABI by looking at the names
976
         of the minimal symbols in the table.  */
977
      {
978
        int i;
979
 
980
        for (i = 0; i < mcount; i++)
981
          {
982
            /* If a symbol's name starts with _Z and was successfully
983
               demangled, then we can assume we've found a GNU v3 symbol.
984
               For now we set the C++ ABI globally; if the user is
985
               mixing ABIs then the user will need to "set cp-abi"
986
               manually.  */
987
            const char *name = SYMBOL_LINKAGE_NAME (&objfile->msymbols[i]);
988
            if (name[0] == '_' && name[1] == 'Z'
989
                && SYMBOL_DEMANGLED_NAME (&objfile->msymbols[i]) != NULL)
990
              {
991
                set_cp_abi_as_auto_default ("gnu-v3");
992
                break;
993
              }
994
          }
995
      }
996
 
997
      /* Now build the hash tables; we can't do this incrementally
998
         at an earlier point since we weren't finished with the obstack
999
         yet.  (And if the msymbol obstack gets moved, all the internal
1000
         pointers to other msymbols need to be adjusted.) */
1001
      build_minimal_symbol_hash_tables (objfile);
1002
    }
1003
}
1004
 
1005
/* Sort all the minimal symbols in OBJFILE.  */
1006
 
1007
void
1008
msymbols_sort (struct objfile *objfile)
1009
{
1010
  qsort (objfile->msymbols, objfile->minimal_symbol_count,
1011
         sizeof (struct minimal_symbol), compare_minimal_symbols);
1012
  build_minimal_symbol_hash_tables (objfile);
1013
}
1014
 
1015
/* Check if PC is in a shared library trampoline code stub.
1016
   Return minimal symbol for the trampoline entry or NULL if PC is not
1017
   in a trampoline code stub.  */
1018
 
1019
struct minimal_symbol *
1020
lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc)
1021
{
1022
  struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
1023
 
1024
  if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
1025
    return msymbol;
1026
  return NULL;
1027
}
1028
 
1029
/* If PC is in a shared library trampoline code stub, return the
1030
   address of the `real' function belonging to the stub.
1031
   Return 0 if PC is not in a trampoline code stub or if the real
1032
   function is not found in the minimal symbol table.
1033
 
1034
   We may fail to find the right function if a function with the
1035
   same name is defined in more than one shared library, but this
1036
   is considered bad programming style. We could return 0 if we find
1037
   a duplicate function in case this matters someday.  */
1038
 
1039
CORE_ADDR
1040
find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc)
1041
{
1042
  struct objfile *objfile;
1043
  struct minimal_symbol *msymbol;
1044
  struct minimal_symbol *tsymbol = lookup_solib_trampoline_symbol_by_pc (pc);
1045
 
1046
  if (tsymbol != NULL)
1047
    {
1048
      ALL_MSYMBOLS (objfile, msymbol)
1049
      {
1050
        if (MSYMBOL_TYPE (msymbol) == mst_text
1051
            && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
1052
                       SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1053
          return SYMBOL_VALUE_ADDRESS (msymbol);
1054
      }
1055
    }
1056
  return 0;
1057
}

powered by: WebSVN 2.1.0

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