GDB (xrefs)
/tmp/gdb-7.10/gdb/minsyms.c
Go to the documentation of this file.
1 /* GDB routines for manipulating the minimal symbol tables.
2  Copyright (C) 1992-2015 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 3 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, see <http://www.gnu.org/licenses/>. */
19 
20 
21 /* This file contains support routines for creating, manipulating, and
22  destroying minimal symbol tables.
23 
24  Minimal symbol tables are used to hold some very basic information about
25  all defined global symbols (text, data, bss, abs, etc). The only two
26  required pieces of information are the symbol's name and the address
27  associated with that symbol.
28 
29  In many cases, even if a file was compiled with no special options for
30  debugging at all, as long as was not stripped it will contain sufficient
31  information to build useful minimal symbol tables using this structure.
32 
33  Even when a file contains enough debugging information to build a full
34  symbol table, these minimal symbols are still useful for quickly mapping
35  between names and addresses, and vice versa. They are also sometimes used
36  to figure out what full symbol table entries need to be read in. */
37 
38 
39 #include "defs.h"
40 #include <ctype.h>
41 #include "symtab.h"
42 #include "bfd.h"
43 #include "filenames.h"
44 #include "symfile.h"
45 #include "objfiles.h"
46 #include "demangle.h"
47 #include "value.h"
48 #include "cp-abi.h"
49 #include "target.h"
50 #include "cp-support.h"
51 #include "language.h"
52 #include "cli/cli-utils.h"
53 #include "symbol.h"
54 
55 /* Accumulate the minimal symbols for each objfile in bunches of BUNCH_SIZE.
56  At the end, copy them all into one newly allocated location on an objfile's
57  per-BFD storage obstack. */
58 
59 #define BUNCH_SIZE 127
60 
61 struct msym_bunch
62  {
63  struct msym_bunch *next;
65  };
66 
67 /* Bunch currently being filled up.
68  The next field points to chain of filled bunches. */
69 
70 static struct msym_bunch *msym_bunch;
71 
72 /* Number of slots filled in current bunch. */
73 
74 static int msym_bunch_index;
75 
76 /* Total number of minimal symbols recorded so far for the objfile. */
77 
78 static int msym_count;
79 
80 /* See minsyms.h. */
81 
82 unsigned int
83 msymbol_hash_iw (const char *string)
84 {
85  unsigned int hash = 0;
86 
87  while (*string && *string != '(')
88  {
89  string = skip_spaces_const (string);
90  if (*string && *string != '(')
91  {
92  hash = SYMBOL_HASH_NEXT (hash, *string);
93  ++string;
94  }
95  }
96  return hash;
97 }
98 
99 /* See minsyms.h. */
100 
101 unsigned int
102 msymbol_hash (const char *string)
103 {
104  unsigned int hash = 0;
105 
106  for (; *string; ++string)
107  hash = SYMBOL_HASH_NEXT (hash, *string);
108  return hash;
109 }
110 
111 /* Add the minimal symbol SYM to an objfile's minsym hash table, TABLE. */
112 static void
114  struct minimal_symbol **table)
115 {
116  if (sym->hash_next == NULL)
117  {
118  unsigned int hash
120 
121  sym->hash_next = table[hash];
122  table[hash] = sym;
123  }
124 }
125 
126 /* Add the minimal symbol SYM to an objfile's minsym demangled hash table,
127  TABLE. */
128 static void
130  struct minimal_symbol **table)
131 {
132  if (sym->demangled_hash_next == NULL)
133  {
134  unsigned int hash = msymbol_hash_iw (MSYMBOL_SEARCH_NAME (sym))
136 
137  sym->demangled_hash_next = table[hash];
138  table[hash] = sym;
139  }
140 }
141 
142 /* Look through all the current minimal symbol tables and find the
143  first minimal symbol that matches NAME. If OBJF is non-NULL, limit
144  the search to that objfile. If SFILE is non-NULL, the only file-scope
145  symbols considered will be from that source file (global symbols are
146  still preferred). Returns a pointer to the minimal symbol that
147  matches, or NULL if no match is found.
148 
149  Note: One instance where there may be duplicate minimal symbols with
150  the same name is when the symbol tables for a shared library and the
151  symbol tables for an executable contain global symbols with the same
152  names (the dynamic linker deals with the duplication).
153 
154  It's also possible to have minimal symbols with different mangled
155  names, but identical demangled names. For example, the GNU C++ v3
156  ABI requires the generation of two (or perhaps three) copies of
157  constructor functions --- "in-charge", "not-in-charge", and
158  "allocate" copies; destructors may be duplicated as well.
159  Obviously, there must be distinct mangled names for each of these,
160  but the demangled names are all the same: S::S or S::~S. */
161 
163 lookup_minimal_symbol (const char *name, const char *sfile,
164  struct objfile *objf)
165 {
166  struct objfile *objfile;
167  struct bound_minimal_symbol found_symbol = { NULL, NULL };
168  struct bound_minimal_symbol found_file_symbol = { NULL, NULL };
169  struct bound_minimal_symbol trampoline_symbol = { NULL, NULL };
170 
171  unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
172  unsigned int dem_hash = msymbol_hash_iw (name) % MINIMAL_SYMBOL_HASH_SIZE;
173 
174  int needtofreename = 0;
175  const char *modified_name;
176 
177  if (sfile != NULL)
178  sfile = lbasename (sfile);
179 
180  /* For C++, canonicalize the input name. */
181  modified_name = name;
183  {
184  char *cname = cp_canonicalize_string (name);
185 
186  if (cname)
187  {
188  modified_name = cname;
189  needtofreename = 1;
190  }
191  }
192 
193  for (objfile = object_files;
194  objfile != NULL && found_symbol.minsym == NULL;
195  objfile = objfile->next)
196  {
197  struct minimal_symbol *msymbol;
198 
199  if (objf == NULL || objf == objfile
200  || objf == objfile->separate_debug_objfile_backlink)
201  {
202  /* Do two passes: the first over the ordinary hash table,
203  and the second over the demangled hash table. */
204  int pass;
205 
207  {
209  "lookup_minimal_symbol (%s, %s, %s)\n",
210  name, sfile != NULL ? sfile : "NULL",
211  objfile_debug_name (objfile));
212  }
213 
214  for (pass = 1; pass <= 2 && found_symbol.minsym == NULL; pass++)
215  {
216  /* Select hash list according to pass. */
217  if (pass == 1)
218  msymbol = objfile->per_bfd->msymbol_hash[hash];
219  else
220  msymbol = objfile->per_bfd->msymbol_demangled_hash[dem_hash];
221 
222  while (msymbol != NULL && found_symbol.minsym == NULL)
223  {
224  int match;
225 
226  if (pass == 1)
227  {
228  int (*cmp) (const char *, const char *);
229 
231  ? strcmp : strcasecmp);
232  match = cmp (MSYMBOL_LINKAGE_NAME (msymbol),
233  modified_name) == 0;
234  }
235  else
236  {
237  /* The function respects CASE_SENSITIVITY. */
238  match = MSYMBOL_MATCHES_SEARCH_NAME (msymbol,
239  modified_name);
240  }
241 
242  if (match)
243  {
244  switch (MSYMBOL_TYPE (msymbol))
245  {
246  case mst_file_text:
247  case mst_file_data:
248  case mst_file_bss:
249  if (sfile == NULL
250  || filename_cmp (msymbol->filename, sfile) == 0)
251  {
252  found_file_symbol.minsym = msymbol;
253  found_file_symbol.objfile = objfile;
254  }
255  break;
256 
258 
259  /* If a trampoline symbol is found, we prefer to
260  keep looking for the *real* symbol. If the
261  actual symbol is not found, then we'll use the
262  trampoline entry. */
263  if (trampoline_symbol.minsym == NULL)
264  {
265  trampoline_symbol.minsym = msymbol;
266  trampoline_symbol.objfile = objfile;
267  }
268  break;
269 
270  case mst_unknown:
271  default:
272  found_symbol.minsym = msymbol;
273  found_symbol.objfile = objfile;
274  break;
275  }
276  }
277 
278  /* Find the next symbol on the hash chain. */
279  if (pass == 1)
280  msymbol = msymbol->hash_next;
281  else
282  msymbol = msymbol->demangled_hash_next;
283  }
284  }
285  }
286  }
287 
288  if (needtofreename)
289  xfree ((void *) modified_name);
290 
291  /* External symbols are best. */
292  if (found_symbol.minsym != NULL)
293  {
295  {
297  "lookup_minimal_symbol (...) = %s"
298  " (external)\n",
299  host_address_to_string (found_symbol.minsym));
300  }
301  return found_symbol;
302  }
303 
304  /* File-local symbols are next best. */
305  if (found_file_symbol.minsym != NULL)
306  {
308  {
310  "lookup_minimal_symbol (...) = %s"
311  " (file-local)\n",
313  (found_file_symbol.minsym));
314  }
315  return found_file_symbol;
316  }
317 
318  /* Symbols for shared library trampolines are next best. */
320  {
322  "lookup_minimal_symbol (...) = %s%s\n",
323  trampoline_symbol.minsym != NULL
324  ? host_address_to_string (trampoline_symbol.minsym)
325  : "NULL",
326  trampoline_symbol.minsym != NULL
327  ? " (trampoline)" : "");
328  }
329  return trampoline_symbol;
330 }
331 
332 /* See minsyms.h. */
333 
336 {
337  return lookup_minimal_symbol (name, NULL, NULL);
338 }
339 
340 /* See common/symbol.h. */
341 
342 int
343 find_minimal_symbol_address (const char *name, CORE_ADDR *addr,
344  struct objfile *objfile)
345 {
346  struct bound_minimal_symbol sym
347  = lookup_minimal_symbol (name, NULL, objfile);
348 
349  if (sym.minsym != NULL)
350  *addr = BMSYMBOL_VALUE_ADDRESS (sym);
351 
352  return sym.minsym == NULL;
353 }
354 
355 /* See minsyms.h. */
356 
357 void
358 iterate_over_minimal_symbols (struct objfile *objf, const char *name,
359  void (*callback) (struct minimal_symbol *,
360  void *),
361  void *user_data)
362 {
363  unsigned int hash;
364  struct minimal_symbol *iter;
365  int (*cmp) (const char *, const char *);
366 
367  /* The first pass is over the ordinary hash table. */
368  hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
369  iter = objf->per_bfd->msymbol_hash[hash];
370  cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
371  while (iter)
372  {
373  if (cmp (MSYMBOL_LINKAGE_NAME (iter), name) == 0)
374  (*callback) (iter, user_data);
375  iter = iter->hash_next;
376  }
377 
378  /* The second pass is over the demangled table. */
380  iter = objf->per_bfd->msymbol_demangled_hash[hash];
381  while (iter)
382  {
383  if (MSYMBOL_MATCHES_SEARCH_NAME (iter, name))
384  (*callback) (iter, user_data);
385  iter = iter->demangled_hash_next;
386  }
387 }
388 
389 /* See minsyms.h. */
390 
393 {
394  struct objfile *objfile;
395  struct minimal_symbol *msymbol;
396  struct bound_minimal_symbol found_symbol = { NULL, NULL };
397  struct bound_minimal_symbol found_file_symbol = { NULL, NULL };
398 
399  unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
400 
401  for (objfile = object_files;
402  objfile != NULL && found_symbol.minsym == NULL;
403  objfile = objfile->next)
404  {
405  if (objf == NULL || objf == objfile
406  || objf == objfile->separate_debug_objfile_backlink)
407  {
408  for (msymbol = objfile->per_bfd->msymbol_hash[hash];
409  msymbol != NULL && found_symbol.minsym == NULL;
410  msymbol = msymbol->hash_next)
411  {
412  if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
413  (MSYMBOL_TYPE (msymbol) == mst_text
414  || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc
415  || MSYMBOL_TYPE (msymbol) == mst_file_text))
416  {
417  switch (MSYMBOL_TYPE (msymbol))
418  {
419  case mst_file_text:
420  found_file_symbol.minsym = msymbol;
421  found_file_symbol.objfile = objfile;
422  break;
423  default:
424  found_symbol.minsym = msymbol;
425  found_symbol.objfile = objfile;
426  break;
427  }
428  }
429  }
430  }
431  }
432  /* External symbols are best. */
433  if (found_symbol.minsym)
434  return found_symbol;
435 
436  /* File-local symbols are next best. */
437  return found_file_symbol;
438 }
439 
440 /* See minsyms.h. */
441 
442 struct minimal_symbol *
444  struct objfile *objf)
445 {
446  struct objfile *objfile;
447  struct minimal_symbol *msymbol;
448 
449  unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
450 
451  for (objfile = object_files;
452  objfile != NULL;
453  objfile = objfile->next)
454  {
455  if (objf == NULL || objf == objfile
456  || objf == objfile->separate_debug_objfile_backlink)
457  {
458  for (msymbol = objfile->per_bfd->msymbol_hash[hash];
459  msymbol != NULL;
460  msymbol = msymbol->hash_next)
461  {
462  if (MSYMBOL_VALUE_ADDRESS (objfile, msymbol) == pc
463  && strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0)
464  return msymbol;
465  }
466  }
467  }
468 
469  return NULL;
470 }
471 
472 /* See minsyms.h. */
473 
476  struct objfile *objf)
477 {
478  struct objfile *objfile;
479  struct minimal_symbol *msymbol;
480  struct bound_minimal_symbol found_symbol = { NULL, NULL };
481 
482  unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
483 
484  for (objfile = object_files;
485  objfile != NULL;
486  objfile = objfile->next)
487  {
488  if (objf == NULL || objf == objfile
489  || objf == objfile->separate_debug_objfile_backlink)
490  {
491  for (msymbol = objfile->per_bfd->msymbol_hash[hash];
492  msymbol != NULL;
493  msymbol = msymbol->hash_next)
494  {
495  if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
496  MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
497  {
498  found_symbol.objfile = objfile;
499  found_symbol.minsym = msymbol;
500  return found_symbol;
501  }
502  }
503  }
504  }
505 
506  return found_symbol;
507 }
508 
509 /* A helper function that makes *PC section-relative. This searches
510  the sections of OBJFILE and if *PC is in a section, it subtracts
511  the section offset and returns true. Otherwise it returns
512  false. */
513 
514 static int
516 {
517  struct obj_section *iter;
518 
519  ALL_OBJFILE_OSECTIONS (objfile, iter)
520  {
521  if (*pc >= obj_section_addr (iter) && *pc < obj_section_endaddr (iter))
522  {
523  *pc -= obj_section_offset (iter);
524  return 1;
525  }
526  }
527 
528  return 0;
529 }
530 
531 /* Search through the minimal symbol table for each objfile and find
532  the symbol whose address is the largest address that is still less
533  than or equal to PC, and matches SECTION (which is not NULL).
534  Returns a pointer to the minimal symbol if such a symbol is found,
535  or NULL if PC is not in a suitable range.
536  Note that we need to look through ALL the minimal symbol tables
537  before deciding on the symbol that comes closest to the specified PC.
538  This is because objfiles can overlap, for example objfile A has .text
539  at 0x100 and .data at 0x40000 and objfile B has .text at 0x234 and
540  .data at 0x40048.
541 
542  If WANT_TRAMPOLINE is set, prefer mst_solib_trampoline symbols when
543  there are text and trampoline symbols at the same address.
544  Otherwise prefer mst_text symbols. */
545 
546 static struct bound_minimal_symbol
548  struct obj_section *section,
549  int want_trampoline)
550 {
551  int lo;
552  int hi;
553  int newobj;
554  struct objfile *objfile;
555  struct minimal_symbol *msymbol;
556  struct minimal_symbol *best_symbol = NULL;
557  struct objfile *best_objfile = NULL;
558  struct bound_minimal_symbol result;
559  enum minimal_symbol_type want_type, other_type;
560 
561  want_type = want_trampoline ? mst_solib_trampoline : mst_text;
562  other_type = want_trampoline ? mst_text : mst_solib_trampoline;
563 
564  /* We can not require the symbol found to be in section, because
565  e.g. IRIX 6.5 mdebug relies on this code returning an absolute
566  symbol - but find_pc_section won't return an absolute section and
567  hence the code below would skip over absolute symbols. We can
568  still take advantage of the call to find_pc_section, though - the
569  object file still must match. In case we have separate debug
570  files, search both the file and its separate debug file. There's
571  no telling which one will have the minimal symbols. */
572 
573  gdb_assert (section != NULL);
574 
575  for (objfile = section->objfile;
576  objfile != NULL;
577  objfile = objfile_separate_debug_iterate (section->objfile, objfile))
578  {
579  CORE_ADDR pc = pc_in;
580 
581  /* If this objfile has a minimal symbol table, go search it using
582  a binary search. Note that a minimal symbol table always consists
583  of at least two symbols, a "real" symbol and the terminating
584  "null symbol". If there are no real symbols, then there is no
585  minimal symbol table at all. */
586 
587  if (objfile->per_bfd->minimal_symbol_count > 0)
588  {
589  int best_zero_sized = -1;
590 
591  msymbol = objfile->per_bfd->msymbols;
592  lo = 0;
593  hi = objfile->per_bfd->minimal_symbol_count - 1;
594 
595  /* This code assumes that the minimal symbols are sorted by
596  ascending address values. If the pc value is greater than or
597  equal to the first symbol's address, then some symbol in this
598  minimal symbol table is a suitable candidate for being the
599  "best" symbol. This includes the last real symbol, for cases
600  where the pc value is larger than any address in this vector.
601 
602  By iterating until the address associated with the current
603  hi index (the endpoint of the test interval) is less than
604  or equal to the desired pc value, we accomplish two things:
605  (1) the case where the pc value is larger than any minimal
606  symbol address is trivially solved, (2) the address associated
607  with the hi index is always the one we want when the interation
608  terminates. In essence, we are iterating the test interval
609  down until the pc value is pushed out of it from the high end.
610 
611  Warning: this code is trickier than it would appear at first. */
612 
613  if (frob_address (objfile, &pc)
614  && pc >= MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[lo]))
615  {
616  while (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi]) > pc)
617  {
618  /* pc is still strictly less than highest address. */
619  /* Note "new" will always be >= lo. */
620  newobj = (lo + hi) / 2;
621  if ((MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[newobj]) >= pc)
622  || (lo == newobj))
623  {
624  hi = newobj;
625  }
626  else
627  {
628  lo = newobj;
629  }
630  }
631 
632  /* If we have multiple symbols at the same address, we want
633  hi to point to the last one. That way we can find the
634  right symbol if it has an index greater than hi. */
635  while (hi < objfile->per_bfd->minimal_symbol_count - 1
636  && (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi])
637  == MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi + 1])))
638  hi++;
639 
640  /* Skip various undesirable symbols. */
641  while (hi >= 0)
642  {
643  /* Skip any absolute symbols. This is apparently
644  what adb and dbx do, and is needed for the CM-5.
645  There are two known possible problems: (1) on
646  ELF, apparently end, edata, etc. are absolute.
647  Not sure ignoring them here is a big deal, but if
648  we want to use them, the fix would go in
649  elfread.c. (2) I think shared library entry
650  points on the NeXT are absolute. If we want
651  special handling for this it probably should be
652  triggered by a special mst_abs_or_lib or some
653  such. */
654 
655  if (MSYMBOL_TYPE (&msymbol[hi]) == mst_abs)
656  {
657  hi--;
658  continue;
659  }
660 
661  /* If SECTION was specified, skip any symbol from
662  wrong section. */
663  if (section
664  /* Some types of debug info, such as COFF,
665  don't fill the bfd_section member, so don't
666  throw away symbols on those platforms. */
667  && MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]) != NULL
669  (MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]),
670  section)))
671  {
672  hi--;
673  continue;
674  }
675 
676  /* If we are looking for a trampoline and this is a
677  text symbol, or the other way around, check the
678  preceding symbol too. If they are otherwise
679  identical prefer that one. */
680  if (hi > 0
681  && MSYMBOL_TYPE (&msymbol[hi]) == other_type
682  && MSYMBOL_TYPE (&msymbol[hi - 1]) == want_type
683  && (MSYMBOL_SIZE (&msymbol[hi])
684  == MSYMBOL_SIZE (&msymbol[hi - 1]))
685  && (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi])
686  == MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi - 1]))
687  && (MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi])
688  == MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi - 1])))
689  {
690  hi--;
691  continue;
692  }
693 
694  /* If the minimal symbol has a zero size, save it
695  but keep scanning backwards looking for one with
696  a non-zero size. A zero size may mean that the
697  symbol isn't an object or function (e.g. a
698  label), or it may just mean that the size was not
699  specified. */
700  if (MSYMBOL_SIZE (&msymbol[hi]) == 0
701  && best_zero_sized == -1)
702  {
703  best_zero_sized = hi;
704  hi--;
705  continue;
706  }
707 
708  /* If we are past the end of the current symbol, try
709  the previous symbol if it has a larger overlapping
710  size. This happens on i686-pc-linux-gnu with glibc;
711  the nocancel variants of system calls are inside
712  the cancellable variants, but both have sizes. */
713  if (hi > 0
714  && MSYMBOL_SIZE (&msymbol[hi]) != 0
715  && pc >= (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi])
716  + MSYMBOL_SIZE (&msymbol[hi]))
717  && pc < (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi - 1])
718  + MSYMBOL_SIZE (&msymbol[hi - 1])))
719  {
720  hi--;
721  continue;
722  }
723 
724  /* Otherwise, this symbol must be as good as we're going
725  to get. */
726  break;
727  }
728 
729  /* If HI has a zero size, and best_zero_sized is set,
730  then we had two or more zero-sized symbols; prefer
731  the first one we found (which may have a higher
732  address). Also, if we ran off the end, be sure
733  to back up. */
734  if (best_zero_sized != -1
735  && (hi < 0 || MSYMBOL_SIZE (&msymbol[hi]) == 0))
736  hi = best_zero_sized;
737 
738  /* If the minimal symbol has a non-zero size, and this
739  PC appears to be outside the symbol's contents, then
740  refuse to use this symbol. If we found a zero-sized
741  symbol with an address greater than this symbol's,
742  use that instead. We assume that if symbols have
743  specified sizes, they do not overlap. */
744 
745  if (hi >= 0
746  && MSYMBOL_SIZE (&msymbol[hi]) != 0
747  && pc >= (MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi])
748  + MSYMBOL_SIZE (&msymbol[hi])))
749  {
750  if (best_zero_sized != -1)
751  hi = best_zero_sized;
752  else
753  /* Go on to the next object file. */
754  continue;
755  }
756 
757  /* The minimal symbol indexed by hi now is the best one in this
758  objfile's minimal symbol table. See if it is the best one
759  overall. */
760 
761  if (hi >= 0
762  && ((best_symbol == NULL) ||
763  (MSYMBOL_VALUE_RAW_ADDRESS (best_symbol) <
764  MSYMBOL_VALUE_RAW_ADDRESS (&msymbol[hi]))))
765  {
766  best_symbol = &msymbol[hi];
767  best_objfile = objfile;
768  }
769  }
770  }
771  }
772 
773  result.minsym = best_symbol;
774  result.objfile = best_objfile;
775  return result;
776 }
777 
780 {
781  if (section == NULL)
782  {
783  /* NOTE: cagney/2004-01-27: This was using find_pc_mapped_section to
784  force the section but that (well unless you're doing overlay
785  debugging) always returns NULL making the call somewhat useless. */
786  section = find_pc_section (pc);
787  if (section == NULL)
788  {
789  struct bound_minimal_symbol result;
790 
791  memset (&result, 0, sizeof (result));
792  return result;
793  }
794  }
795  return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
796 }
797 
798 /* See minsyms.h. */
799 
802 {
803  struct obj_section *section = find_pc_section (pc);
804 
805  if (section == NULL)
806  {
807  struct bound_minimal_symbol result;
808 
809  memset (&result, 0, sizeof (result));
810  return result;
811  }
812  return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
813 }
814 
815 /* Return non-zero iff PC is in an STT_GNU_IFUNC function resolver. */
816 
817 int
819 {
821 
822  return msymbol.minsym && MSYMBOL_TYPE (msymbol.minsym) == mst_text_gnu_ifunc;
823 }
824 
825 /* See elf_gnu_ifunc_resolve_addr for its real implementation. */
826 
827 static CORE_ADDR
829 {
830  error (_("GDB cannot resolve STT_GNU_IFUNC symbol at address %s without "
831  "the ELF support compiled in."),
832  paddress (gdbarch, pc));
833 }
834 
835 /* See elf_gnu_ifunc_resolve_name for its real implementation. */
836 
837 static int
838 stub_gnu_ifunc_resolve_name (const char *function_name,
839  CORE_ADDR *function_address_p)
840 {
841  error (_("GDB cannot resolve STT_GNU_IFUNC symbol \"%s\" without "
842  "the ELF support compiled in."),
843  function_name);
844 }
845 
846 /* See elf_gnu_ifunc_resolver_stop for its real implementation. */
847 
848 static void
850 {
851  internal_error (__FILE__, __LINE__,
852  _("elf_gnu_ifunc_resolver_stop cannot be reached."));
853 }
854 
855 /* See elf_gnu_ifunc_resolver_return_stop for its real implementation. */
856 
857 static void
859 {
860  internal_error (__FILE__, __LINE__,
861  _("elf_gnu_ifunc_resolver_return_stop cannot be reached."));
862 }
863 
864 /* See elf_gnu_ifunc_fns for its real implementation. */
865 
866 static const struct gnu_ifunc_fns stub_gnu_ifunc_fns =
867 {
872 };
873 
874 /* A placeholder for &elf_gnu_ifunc_fns. */
875 
876 const struct gnu_ifunc_fns *gnu_ifunc_fns_p = &stub_gnu_ifunc_fns;
877 
878 /* See minsyms.h. */
879 
882 {
883  struct bound_minimal_symbol result;
884  struct objfile *objfile;
885  unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
886 
887  ALL_OBJFILES (objfile)
888  {
889  struct minimal_symbol *msym;
890 
891  for (msym = objfile->per_bfd->msymbol_hash[hash];
892  msym != NULL;
893  msym = msym->hash_next)
894  {
895  if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
896  {
897  result.minsym = msym;
898  result.objfile = objfile;
899  return result;
900  }
901  }
902  }
903 
904  memset (&result, 0, sizeof (result));
905  return result;
906 }
907 
908 
909 /* Return leading symbol character for a BFD. If BFD is NULL,
910  return the leading symbol character from the main objfile. */
911 
912 static int
914 {
915  if (abfd != NULL)
916  return bfd_get_symbol_leading_char (abfd);
917  if (symfile_objfile != NULL && symfile_objfile->obfd != NULL)
918  return bfd_get_symbol_leading_char (symfile_objfile->obfd);
919  return 0;
920 }
921 
922 /* See minsyms.h. */
923 
924 void
926 {
927  msym_count = 0;
928  msym_bunch = NULL;
929  /* Note that presetting msym_bunch_index to BUNCH_SIZE causes the
930  first call to save a minimal symbol to allocate the memory for
931  the first bunch. */
932  msym_bunch_index = BUNCH_SIZE;
933 }
934 
935 /* See minsyms.h. */
936 
937 void
938 prim_record_minimal_symbol (const char *name, CORE_ADDR address,
939  enum minimal_symbol_type ms_type,
940  struct objfile *objfile)
941 {
942  int section;
943 
944  switch (ms_type)
945  {
946  case mst_text:
947  case mst_text_gnu_ifunc:
948  case mst_file_text:
950  section = SECT_OFF_TEXT (objfile);
951  break;
952  case mst_data:
953  case mst_file_data:
954  section = SECT_OFF_DATA (objfile);
955  break;
956  case mst_bss:
957  case mst_file_bss:
958  section = SECT_OFF_BSS (objfile);
959  break;
960  default:
961  section = -1;
962  }
963 
964  prim_record_minimal_symbol_and_info (name, address, ms_type,
965  section, objfile);
966 }
967 
968 /* See minsyms.h. */
969 
970 struct minimal_symbol *
971 prim_record_minimal_symbol_full (const char *name, int name_len, int copy_name,
972  CORE_ADDR address,
973  enum minimal_symbol_type ms_type,
974  int section,
975  struct objfile *objfile)
976 {
977  struct obj_section *obj_section;
978  struct msym_bunch *newobj;
979  struct minimal_symbol *msymbol;
980 
981  /* Don't put gcc_compiled, __gnu_compiled_cplus, and friends into
982  the minimal symbols, because if there is also another symbol
983  at the same address (e.g. the first function of the file),
984  lookup_minimal_symbol_by_pc would have no way of getting the
985  right one. */
986  if (ms_type == mst_file_text && name[0] == 'g'
987  && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0
988  || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0))
989  return (NULL);
990 
991  /* It's safe to strip the leading char here once, since the name
992  is also stored stripped in the minimal symbol table. */
993  if (name[0] == get_symbol_leading_char (objfile->obfd))
994  {
995  ++name;
996  --name_len;
997  }
998 
999  if (ms_type == mst_file_text && startswith (name, "__gnu_compiled"))
1000  return (NULL);
1001 
1002  if (msym_bunch_index == BUNCH_SIZE)
1003  {
1004  newobj = XCNEW (struct msym_bunch);
1005  msym_bunch_index = 0;
1006  newobj->next = msym_bunch;
1007  msym_bunch = newobj;
1008  }
1009  msymbol = &msym_bunch->contents[msym_bunch_index];
1011  &objfile->per_bfd->storage_obstack);
1012  MSYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile);
1013 
1014  SET_MSYMBOL_VALUE_ADDRESS (msymbol, address);
1015  MSYMBOL_SECTION (msymbol) = section;
1016 
1017  MSYMBOL_TYPE (msymbol) = ms_type;
1018  MSYMBOL_TARGET_FLAG_1 (msymbol) = 0;
1019  MSYMBOL_TARGET_FLAG_2 (msymbol) = 0;
1020  /* Do not use the SET_MSYMBOL_SIZE macro to initialize the size,
1021  as it would also set the has_size flag. */
1022  msymbol->size = 0;
1023 
1024  /* The hash pointers must be cleared! If they're not,
1025  add_minsym_to_hash_table will NOT add this msymbol to the hash table. */
1026  msymbol->hash_next = NULL;
1027  msymbol->demangled_hash_next = NULL;
1028 
1029  /* If we already read minimal symbols for this objfile, then don't
1030  ever allocate a new one. */
1031  if (!objfile->per_bfd->minsyms_read)
1032  {
1033  msym_bunch_index++;
1034  objfile->per_bfd->n_minsyms++;
1035  }
1036  msym_count++;
1037  return msymbol;
1038 }
1039 
1040 /* See minsyms.h. */
1041 
1042 struct minimal_symbol *
1044  enum minimal_symbol_type ms_type,
1045  int section,
1046  struct objfile *objfile)
1047 {
1048  return prim_record_minimal_symbol_full (name, strlen (name), 1,
1049  address, ms_type,
1050  section, objfile);
1051 }
1052 
1053 /* Compare two minimal symbols by address and return a signed result based
1054  on unsigned comparisons, so that we sort into unsigned numeric order.
1055  Within groups with the same address, sort by name. */
1056 
1057 static int
1058 compare_minimal_symbols (const void *fn1p, const void *fn2p)
1059 {
1060  const struct minimal_symbol *fn1;
1061  const struct minimal_symbol *fn2;
1062 
1063  fn1 = (const struct minimal_symbol *) fn1p;
1064  fn2 = (const struct minimal_symbol *) fn2p;
1065 
1067  {
1068  return (-1); /* addr 1 is less than addr 2. */
1069  }
1071  {
1072  return (1); /* addr 1 is greater than addr 2. */
1073  }
1074  else
1075  /* addrs are equal: sort by name */
1076  {
1077  const char *name1 = MSYMBOL_LINKAGE_NAME (fn1);
1078  const char *name2 = MSYMBOL_LINKAGE_NAME (fn2);
1079 
1080  if (name1 && name2) /* both have names */
1081  return strcmp (name1, name2);
1082  else if (name2)
1083  return 1; /* fn1 has no name, so it is "less". */
1084  else if (name1) /* fn2 has no name, so it is "less". */
1085  return -1;
1086  else
1087  return (0); /* Neither has a name, so they're equal. */
1088  }
1089 }
1090 
1091 /* Discard the currently collected minimal symbols, if any. If we wish
1092  to save them for later use, we must have already copied them somewhere
1093  else before calling this function.
1094 
1095  FIXME: We could allocate the minimal symbol bunches on their own
1096  obstack and then simply blow the obstack away when we are done with
1097  it. Is it worth the extra trouble though? */
1098 
1099 static void
1101 {
1102  struct msym_bunch *next;
1103 
1104  while (msym_bunch != NULL)
1105  {
1106  next = msym_bunch->next;
1107  xfree (msym_bunch);
1108  msym_bunch = next;
1109  }
1110 }
1111 
1112 /* See minsyms.h. */
1113 
1114 struct cleanup *
1116 {
1118 }
1119 
1120 
1121 
1122 /* Compact duplicate entries out of a minimal symbol table by walking
1123  through the table and compacting out entries with duplicate addresses
1124  and matching names. Return the number of entries remaining.
1125 
1126  On entry, the table resides between msymbol[0] and msymbol[mcount].
1127  On exit, it resides between msymbol[0] and msymbol[result_count].
1128 
1129  When files contain multiple sources of symbol information, it is
1130  possible for the minimal symbol table to contain many duplicate entries.
1131  As an example, SVR4 systems use ELF formatted object files, which
1132  usually contain at least two different types of symbol tables (a
1133  standard ELF one and a smaller dynamic linking table), as well as
1134  DWARF debugging information for files compiled with -g.
1135 
1136  Without compacting, the minimal symbol table for gdb itself contains
1137  over a 1000 duplicates, about a third of the total table size. Aside
1138  from the potential trap of not noticing that two successive entries
1139  identify the same location, this duplication impacts the time required
1140  to linearly scan the table, which is done in a number of places. So we
1141  just do one linear scan here and toss out the duplicates.
1142 
1143  Note that we are not concerned here about recovering the space that
1144  is potentially freed up, because the strings themselves are allocated
1145  on the storage_obstack, and will get automatically freed when the symbol
1146  table is freed. The caller can free up the unused minimal symbols at
1147  the end of the compacted region if their allocation strategy allows it.
1148 
1149  Also note we only go up to the next to last entry within the loop
1150  and then copy the last entry explicitly after the loop terminates.
1151 
1152  Since the different sources of information for each symbol may
1153  have different levels of "completeness", we may have duplicates
1154  that have one entry with type "mst_unknown" and the other with a
1155  known type. So if the one we are leaving alone has type mst_unknown,
1156  overwrite its type with the type from the one we are compacting out. */
1157 
1158 static int
1159 compact_minimal_symbols (struct minimal_symbol *msymbol, int mcount,
1160  struct objfile *objfile)
1161 {
1162  struct minimal_symbol *copyfrom;
1163  struct minimal_symbol *copyto;
1164 
1165  if (mcount > 0)
1166  {
1167  copyfrom = copyto = msymbol;
1168  while (copyfrom < msymbol + mcount - 1)
1169  {
1170  if (MSYMBOL_VALUE_RAW_ADDRESS (copyfrom)
1171  == MSYMBOL_VALUE_RAW_ADDRESS ((copyfrom + 1))
1172  && MSYMBOL_SECTION (copyfrom) == MSYMBOL_SECTION (copyfrom + 1)
1173  && strcmp (MSYMBOL_LINKAGE_NAME (copyfrom),
1174  MSYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0)
1175  {
1176  if (MSYMBOL_TYPE ((copyfrom + 1)) == mst_unknown)
1177  {
1178  MSYMBOL_TYPE ((copyfrom + 1)) = MSYMBOL_TYPE (copyfrom);
1179  }
1180  copyfrom++;
1181  }
1182  else
1183  *copyto++ = *copyfrom++;
1184  }
1185  *copyto++ = *copyfrom++;
1186  mcount = copyto - msymbol;
1187  }
1188  return (mcount);
1189 }
1190 
1191 /* Build (or rebuild) the minimal symbol hash tables. This is necessary
1192  after compacting or sorting the table since the entries move around
1193  thus causing the internal minimal_symbol pointers to become jumbled. */
1194 
1195 static void
1197 {
1198  int i;
1199  struct minimal_symbol *msym;
1200 
1201  /* Clear the hash tables. */
1202  for (i = 0; i < MINIMAL_SYMBOL_HASH_SIZE; i++)
1203  {
1204  objfile->per_bfd->msymbol_hash[i] = 0;
1205  objfile->per_bfd->msymbol_demangled_hash[i] = 0;
1206  }
1207 
1208  /* Now, (re)insert the actual entries. */
1209  for ((i = objfile->per_bfd->minimal_symbol_count,
1210  msym = objfile->per_bfd->msymbols);
1211  i > 0;
1212  i--, msym++)
1213  {
1214  msym->hash_next = 0;
1215  add_minsym_to_hash_table (msym, objfile->per_bfd->msymbol_hash);
1216 
1217  msym->demangled_hash_next = 0;
1218  if (MSYMBOL_SEARCH_NAME (msym) != MSYMBOL_LINKAGE_NAME (msym))
1220  objfile->per_bfd->msymbol_demangled_hash);
1221  }
1222 }
1223 
1224 /* Add the minimal symbols in the existing bunches to the objfile's official
1225  minimal symbol table. In most cases there is no minimal symbol table yet
1226  for this objfile, and the existing bunches are used to create one. Once
1227  in a while (for shared libraries for example), we add symbols (e.g. common
1228  symbols) to an existing objfile.
1229 
1230  Because of the way minimal symbols are collected, we generally have no way
1231  of knowing what source language applies to any particular minimal symbol.
1232  Specifically, we have no way of knowing if the minimal symbol comes from a
1233  C++ compilation unit or not. So for the sake of supporting cached
1234  demangled C++ names, we have no choice but to try and demangle each new one
1235  that comes in. If the demangling succeeds, then we assume it is a C++
1236  symbol and set the symbol's language and demangled name fields
1237  appropriately. Note that in order to avoid unnecessary demanglings, and
1238  allocating obstack space that subsequently can't be freed for the demangled
1239  names, we mark all newly added symbols with language_auto. After
1240  compaction of the minimal symbols, we go back and scan the entire minimal
1241  symbol table looking for these new symbols. For each new symbol we attempt
1242  to demangle it, and if successful, record it as a language_cplus symbol
1243  and cache the demangled form on the symbol obstack. Symbols which don't
1244  demangle are marked as language_unknown symbols, which inhibits future
1245  attempts to demangle them if we later add more minimal symbols. */
1246 
1247 void
1249 {
1250  int bindex;
1251  int mcount;
1252  struct msym_bunch *bunch;
1253  struct minimal_symbol *msymbols;
1254  int alloc_count;
1255 
1256  if (objfile->per_bfd->minsyms_read)
1257  return;
1258 
1259  if (msym_count > 0)
1260  {
1261  if (symtab_create_debug)
1262  {
1264  "Installing %d minimal symbols of objfile %s.\n",
1265  msym_count, objfile_name (objfile));
1266  }
1267 
1268  /* Allocate enough space in the obstack, into which we will gather the
1269  bunches of new and existing minimal symbols, sort them, and then
1270  compact out the duplicate entries. Once we have a final table,
1271  we will give back the excess space. */
1272 
1273  alloc_count = msym_count + objfile->per_bfd->minimal_symbol_count + 1;
1274  obstack_blank (&objfile->per_bfd->storage_obstack,
1275  alloc_count * sizeof (struct minimal_symbol));
1276  msymbols = (struct minimal_symbol *)
1277  obstack_base (&objfile->per_bfd->storage_obstack);
1278 
1279  /* Copy in the existing minimal symbols, if there are any. */
1280 
1281  if (objfile->per_bfd->minimal_symbol_count)
1282  memcpy ((char *) msymbols, (char *) objfile->per_bfd->msymbols,
1283  objfile->per_bfd->minimal_symbol_count * sizeof (struct minimal_symbol));
1284 
1285  /* Walk through the list of minimal symbol bunches, adding each symbol
1286  to the new contiguous array of symbols. Note that we start with the
1287  current, possibly partially filled bunch (thus we use the current
1288  msym_bunch_index for the first bunch we copy over), and thereafter
1289  each bunch is full. */
1290 
1291  mcount = objfile->per_bfd->minimal_symbol_count;
1292 
1293  for (bunch = msym_bunch; bunch != NULL; bunch = bunch->next)
1294  {
1295  for (bindex = 0; bindex < msym_bunch_index; bindex++, mcount++)
1296  msymbols[mcount] = bunch->contents[bindex];
1297  msym_bunch_index = BUNCH_SIZE;
1298  }
1299 
1300  /* Sort the minimal symbols by address. */
1301 
1302  qsort (msymbols, mcount, sizeof (struct minimal_symbol),
1304 
1305  /* Compact out any duplicates, and free up whatever space we are
1306  no longer using. */
1307 
1308  mcount = compact_minimal_symbols (msymbols, mcount, objfile);
1309 
1310  obstack_blank_fast (&objfile->per_bfd->storage_obstack,
1311  (mcount + 1 - alloc_count) * sizeof (struct minimal_symbol));
1312  msymbols = (struct minimal_symbol *)
1313  obstack_finish (&objfile->per_bfd->storage_obstack);
1314 
1315  /* We also terminate the minimal symbol table with a "null symbol",
1316  which is *not* included in the size of the table. This makes it
1317  easier to find the end of the table when we are handed a pointer
1318  to some symbol in the middle of it. Zero out the fields in the
1319  "null symbol" allocated at the end of the array. Note that the
1320  symbol count does *not* include this null symbol, which is why it
1321  is indexed by mcount and not mcount-1. */
1322 
1323  memset (&msymbols[mcount], 0, sizeof (struct minimal_symbol));
1324 
1325  /* Attach the minimal symbol table to the specified objfile.
1326  The strings themselves are also located in the storage_obstack
1327  of this objfile. */
1328 
1329  objfile->per_bfd->minimal_symbol_count = mcount;
1330  objfile->per_bfd->msymbols = msymbols;
1331 
1332  /* Now build the hash tables; we can't do this incrementally
1333  at an earlier point since we weren't finished with the obstack
1334  yet. (And if the msymbol obstack gets moved, all the internal
1335  pointers to other msymbols need to be adjusted.) */
1337  }
1338 }
1339 
1340 /* See minsyms.h. */
1341 
1342 void
1344 {
1345  if (! objfile->per_bfd->msymbols)
1346  objfile->per_bfd->msymbols
1347  = ((struct minimal_symbol *)
1348  obstack_alloc (&objfile->per_bfd->storage_obstack,
1349  sizeof (struct minimal_symbol)));
1350 
1351  {
1352  struct minimal_symbol *m
1353  = &objfile->per_bfd->msymbols[objfile->per_bfd->minimal_symbol_count];
1354 
1355  memset (m, 0, sizeof (*m));
1356  /* Don't rely on these enumeration values being 0's. */
1357  MSYMBOL_TYPE (m) = mst_unknown;
1359  &objfile->per_bfd->storage_obstack);
1360  }
1361 }
1362 
1363 /* Check if PC is in a shared library trampoline code stub.
1364  Return minimal symbol for the trampoline entry or NULL if PC is not
1365  in a trampoline code stub. */
1366 
1367 static struct minimal_symbol *
1369 {
1370  struct obj_section *section = find_pc_section (pc);
1371  struct bound_minimal_symbol msymbol;
1372 
1373  if (section == NULL)
1374  return NULL;
1375  msymbol = lookup_minimal_symbol_by_pc_section_1 (pc, section, 1);
1376 
1377  if (msymbol.minsym != NULL
1378  && MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
1379  return msymbol.minsym;
1380  return NULL;
1381 }
1382 
1383 /* If PC is in a shared library trampoline code stub, return the
1384  address of the `real' function belonging to the stub.
1385  Return 0 if PC is not in a trampoline code stub or if the real
1386  function is not found in the minimal symbol table.
1387 
1388  We may fail to find the right function if a function with the
1389  same name is defined in more than one shared library, but this
1390  is considered bad programming style. We could return 0 if we find
1391  a duplicate function in case this matters someday. */
1392 
1393 CORE_ADDR
1395 {
1396  struct objfile *objfile;
1397  struct minimal_symbol *msymbol;
1399 
1400  if (tsymbol != NULL)
1401  {
1402  ALL_MSYMBOLS (objfile, msymbol)
1403  {
1404  if ((MSYMBOL_TYPE (msymbol) == mst_text
1405  || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc)
1406  && strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
1407  MSYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1408  return MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
1409 
1410  /* Also handle minimal symbols pointing to function descriptors. */
1411  if (MSYMBOL_TYPE (msymbol) == mst_data
1412  && strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
1413  MSYMBOL_LINKAGE_NAME (tsymbol)) == 0)
1414  {
1415  CORE_ADDR func;
1416 
1418  (get_objfile_arch (objfile),
1419  MSYMBOL_VALUE_ADDRESS (objfile, msymbol),
1420  &current_target);
1421 
1422  /* Ignore data symbols that are not function descriptors. */
1423  if (func != MSYMBOL_VALUE_ADDRESS (objfile, msymbol))
1424  return func;
1425  }
1426  }
1427  }
1428  return 0;
1429 }
1430 
1431 /* See minsyms.h. */
1432 
1433 CORE_ADDR
1435 {
1436  int i;
1437  short section;
1438  struct obj_section *obj_section;
1439  CORE_ADDR result;
1440  struct minimal_symbol *msymbol;
1441 
1442  gdb_assert (minsym.minsym != NULL);
1443 
1444  /* If the minimal symbol has a size, use it. Otherwise use the
1445  lesser of the next minimal symbol in the same section, or the end
1446  of the section, as the end of the function. */
1447 
1448  if (MSYMBOL_SIZE (minsym.minsym) != 0)
1449  return BMSYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym.minsym);
1450 
1451  /* Step over other symbols at this same address, and symbols in
1452  other sections, to find the next symbol in this section with a
1453  different address. */
1454 
1455  msymbol = minsym.minsym;
1456  section = MSYMBOL_SECTION (msymbol);
1457  for (i = 1; MSYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
1458  {
1459  if ((MSYMBOL_VALUE_RAW_ADDRESS (msymbol + i)
1460  != MSYMBOL_VALUE_RAW_ADDRESS (msymbol))
1461  && MSYMBOL_SECTION (msymbol + i) == section)
1462  break;
1463  }
1464 
1465  obj_section = MSYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym);
1466  if (MSYMBOL_LINKAGE_NAME (msymbol + i) != NULL
1467  && (MSYMBOL_VALUE_ADDRESS (minsym.objfile, msymbol + i)
1468  < obj_section_endaddr (obj_section)))
1469  result = MSYMBOL_VALUE_ADDRESS (minsym.objfile, msymbol + i);
1470  else
1471  /* We got the start address from the last msymbol in the objfile.
1472  So the end address is the end of the section. */
1473  result = obj_section_endaddr (obj_section);
1474 
1475  return result;
1476 }
#define BUNCH_SIZE
Definition: minsyms.c:59
const char * string
Definition: signals.c:50
struct minimal_symbol * msymbols
Definition: objfiles.h:222
#define object_files
Definition: progspace.h:220
static int compare_minimal_symbols(const void *fn1p, const void *fn2p)
Definition: minsyms.c:1058
struct bound_minimal_symbol lookup_minimal_symbol_by_pc_section(CORE_ADDR pc, struct obj_section *section)
Definition: minsyms.c:779
struct bound_minimal_symbol lookup_minimal_symbol_solib_trampoline(const char *name, struct objfile *objf)
Definition: minsyms.c:475
bfd * obfd
Definition: objfiles.h:313
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:683
struct minimal_symbol * hash_next
Definition: symtab.h:364
static void build_minimal_symbol_hash_tables(struct objfile *objfile)
Definition: minsyms.c:1196
struct obstack storage_obstack
Definition: objfiles.h:177
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:409
bfd_vma CORE_ADDR
Definition: common-types.h:41
struct minimal_symbol contents[BUNCH_SIZE]
Definition: minsyms.c:64
void xfree(void *)
Definition: common-utils.c:97
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:401
#define GCC2_COMPILED_FLAG_SYMBOL
Definition: symtab.h:1330
void(* func)(char *)
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
static CORE_ADDR stub_gnu_ifunc_resolve_addr(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: minsyms.c:828
struct type ** const(pascal_builtin_types[])
#define obj_section_offset(s)
Definition: objfiles.h:131
static void stub_gnu_ifunc_resolver_return_stop(struct breakpoint *b)
Definition: minsyms.c:858
#define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value)
Definition: symtab.h:395
CORE_ADDR minimal_symbol_upper_bound(struct bound_minimal_symbol minsym)
Definition: minsyms.c:1434
void prim_record_minimal_symbol(const char *name, CORE_ADDR address, enum minimal_symbol_type ms_type, struct objfile *objfile)
Definition: minsyms.c:938
static int frob_address(struct objfile *objfile, CORE_ADDR *pc)
Definition: minsyms.c:515
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
#define obj_section_endaddr(s)
Definition: objfiles.h:141
unsigned int symbol_lookup_debug
Definition: symtab.c:207
static int msym_bunch_index
Definition: minsyms.c:74
#define MSYMBOL_TARGET_FLAG_2(msymbol)
Definition: symtab.h:373
enum language la_language
Definition: language.h:152
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:627
#define MINIMAL_SYMBOL_HASH_SIZE
Definition: objfiles.h:166
struct minimal_symbol * prim_record_minimal_symbol_and_info(const char *name, CORE_ADDR address, enum minimal_symbol_type ms_type, int section, struct objfile *objfile)
Definition: minsyms.c:1043
unsigned long size
Definition: symtab.h:339
#define _(String)
Definition: gdb_locale.h:40
#define MSYMBOL_TARGET_FLAG_1(msymbol)
Definition: symtab.h:372
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:318
struct bound_minimal_symbol lookup_minimal_symbol_text(const char *name, struct objfile *objf)
Definition: minsyms.c:392
tuple m
Definition: arm-linux.py:44
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
#define obj_section_addr(s)
Definition: objfiles.h:135
struct minimal_symbol * lookup_minimal_symbol_by_pc_name(CORE_ADDR pc, const char *name, struct objfile *objf)
Definition: minsyms.c:443
#define MSYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:402
static struct minimal_symbol * lookup_solib_trampoline_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:1368
#define MSYMBOL_VALUE_RAW_ADDRESS(symbol)
Definition: symtab.h:386
const char *const name
Definition: aarch64-tdep.c:68
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
int find_minimal_symbol_address(const char *name, CORE_ADDR *addr, struct objfile *objfile)
Definition: minsyms.c:343
struct minimal_symbol * demangled_hash_next
Definition: symtab.h:369
struct target_ops current_target
CORE_ADDR find_solib_trampoline_target(struct frame_info *frame, CORE_ADDR pc)
Definition: minsyms.c:1394
const char * skip_spaces_const(const char *chp)
Definition: common-utils.c:271
static int msym_count
Definition: minsyms.c:78
struct bound_minimal_symbol lookup_minimal_symbol_and_objfile(const char *name)
Definition: minsyms.c:881
const char * filename
Definition: symtab.h:342
static void add_minsym_to_demangled_hash_table(struct minimal_symbol *sym, struct minimal_symbol **table)
Definition: minsyms.c:129
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:2975
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
#define SYMBOL_HASH_NEXT(hash, c)
Definition: minsyms.h:154
#define SECT_OFF_DATA(objfile)
Definition: objfiles.h:671
void iterate_over_minimal_symbols(struct objfile *objf, const char *name, void(*callback)(struct minimal_symbol *, void *), void *user_data)
Definition: minsyms.c:358
#define MSYMBOL_SIZE(msymbol)
Definition: symtab.h:374
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
#define MSYMBOL_SEARCH_NAME(symbol)
Definition: symtab.h:416
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
#define symfile_objfile
Definition: progspace.h:216
struct cleanup * make_cleanup_discard_minimal_symbols(void)
Definition: minsyms.c:1115
static void do_discard_minimal_symbols_cleanup(void *arg)
Definition: minsyms.c:1100
char * cp_canonicalize_string(const char *string)
Definition: cp-support.c:587
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
unsigned int msymbol_hash(const char *string)
Definition: minsyms.c:102
struct ui_file * gdb_stdlog
Definition: main.c:73
static int get_symbol_leading_char(bfd *abfd)
Definition: minsyms.c:913
void init_minimal_symbol_collection(void)
Definition: minsyms.c:925
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
unsigned int minsyms_read
Definition: objfiles.h:239
struct msym_bunch * next
Definition: minsyms.c:63
const char const char int
Definition: command.h:229
static const struct gnu_ifunc_fns stub_gnu_ifunc_fns
Definition: minsyms.c:866
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:382
#define ALL_MSYMBOLS(objfile, m)
Definition: objfiles.h:623
const struct language_defn * current_language
Definition: language.c:85
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:801
#define MSYMBOL_SET_NAMES(symbol, linkage_name, len, copy_name, objfile)
Definition: symtab.h:420
static void stub_gnu_ifunc_resolver_stop(struct breakpoint *b)
Definition: minsyms.c:849
#define GCC_COMPILED_FLAG_SYMBOL
Definition: symtab.h:1325
struct minimal_symbol * minsym
Definition: minsyms.h:32
#define MSYMBOL_SECTION(symbol)
Definition: symtab.h:401
struct objfile * objfile_separate_debug_iterate(const struct objfile *parent, const struct objfile *objfile)
Definition: objfiles.c:411
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition: minsyms.c:335
const char * objfile_debug_name(const struct objfile *objfile)
Definition: objfiles.c:1521
struct objfile * next
Definition: objfiles.h:267
#define qsort
Definition: ada-exp.c:2747
#define MSYMBOL_MATCHES_SEARCH_NAME(symbol, name)
Definition: symtab.h:418
int in_gnu_ifunc_stub(CORE_ADDR pc)
Definition: minsyms.c:818
unsigned int symtab_create_debug
Definition: symtab.c:204
static int stub_gnu_ifunc_resolve_name(const char *function_name, CORE_ADDR *function_address_p)
Definition: minsyms.c:838
static void add_minsym_to_hash_table(struct minimal_symbol *sym, struct minimal_symbol **table)
Definition: minsyms.c:113
static struct msym_bunch * msym_bunch
Definition: minsyms.c:70
#define MSYMBOL_SET_LANGUAGE(symbol, language, obstack)
Definition: symtab.h:414
struct minimal_symbol * msymbol_hash[MINIMAL_SYMBOL_HASH_SIZE]
Definition: objfiles.h:243
#define SECT_OFF_BSS(objfile)
Definition: objfiles.h:692
int matching_obj_sections(struct obj_section *obj_first, struct obj_section *obj_second)
Definition: symtab.c:1075
struct objfile * objfile
Definition: minsyms.h:37
void terminate_minimal_symbol_table(struct objfile *objfile)
Definition: minsyms.c:1343
minimal_symbol_type
Definition: symtab.h:287
static struct bound_minimal_symbol lookup_minimal_symbol_by_pc_section_1(CORE_ADDR pc_in, struct obj_section *section, int want_trampoline)
Definition: minsyms.c:547
struct minimal_symbol * msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE]
Definition: objfiles.h:248
void install_minimal_symbols(struct objfile *objfile)
Definition: minsyms.c:1248
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
struct minimal_symbol * prim_record_minimal_symbol_full(const char *name, int name_len, int copy_name, CORE_ADDR address, enum minimal_symbol_type ms_type, int section, struct objfile *objfile)
Definition: minsyms.c:971
static int compact_minimal_symbols(struct minimal_symbol *msymbol, int mcount, struct objfile *objfile)
Definition: minsyms.c:1159
case_sensitivity
Definition: language.h:88
void error(const char *fmt,...)
Definition: errors.c:38
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol)
Definition: symtab.h:389
char * copy_name(struct stoken token)
Definition: parse.c:783
unsigned int msymbol_hash_iw(const char *string)
Definition: minsyms.c:83