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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [minsyms.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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