Remove BSF_COMMON from comments
[external/binutils.git] / bfd / syms.c
1 /* Generic symbol-table support for the BFD library.
2    Copyright (C) 1990-2016 Free Software Foundation, Inc.
3    Written by Cygnus Support.
4
5    This file is part of BFD, the Binary File Descriptor library.
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, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22 /*
23 SECTION
24         Symbols
25
26         BFD tries to maintain as much symbol information as it can when
27         it moves information from file to file. BFD passes information
28         to applications though the <<asymbol>> structure. When the
29         application requests the symbol table, BFD reads the table in
30         the native form and translates parts of it into the internal
31         format. To maintain more than the information passed to
32         applications, some targets keep some information ``behind the
33         scenes'' in a structure only the particular back end knows
34         about. For example, the coff back end keeps the original
35         symbol table structure as well as the canonical structure when
36         a BFD is read in. On output, the coff back end can reconstruct
37         the output symbol table so that no information is lost, even
38         information unique to coff which BFD doesn't know or
39         understand. If a coff symbol table were read, but were written
40         through an a.out back end, all the coff specific information
41         would be lost. The symbol table of a BFD
42         is not necessarily read in until a canonicalize request is
43         made. Then the BFD back end fills in a table provided by the
44         application with pointers to the canonical information.  To
45         output symbols, the application provides BFD with a table of
46         pointers to pointers to <<asymbol>>s. This allows applications
47         like the linker to output a symbol as it was read, since the ``behind
48         the scenes'' information will be still available.
49 @menu
50 @* Reading Symbols::
51 @* Writing Symbols::
52 @* Mini Symbols::
53 @* typedef asymbol::
54 @* symbol handling functions::
55 @end menu
56
57 INODE
58 Reading Symbols, Writing Symbols, Symbols, Symbols
59 SUBSECTION
60         Reading symbols
61
62         There are two stages to reading a symbol table from a BFD:
63         allocating storage, and the actual reading process. This is an
64         excerpt from an application which reads the symbol table:
65
66 |         long storage_needed;
67 |         asymbol **symbol_table;
68 |         long number_of_symbols;
69 |         long i;
70 |
71 |         storage_needed = bfd_get_symtab_upper_bound (abfd);
72 |
73 |         if (storage_needed < 0)
74 |           FAIL
75 |
76 |         if (storage_needed == 0)
77 |           return;
78 |
79 |         symbol_table = xmalloc (storage_needed);
80 |           ...
81 |         number_of_symbols =
82 |            bfd_canonicalize_symtab (abfd, symbol_table);
83 |
84 |         if (number_of_symbols < 0)
85 |           FAIL
86 |
87 |         for (i = 0; i < number_of_symbols; i++)
88 |           process_symbol (symbol_table[i]);
89
90         All storage for the symbols themselves is in an objalloc
91         connected to the BFD; it is freed when the BFD is closed.
92
93 INODE
94 Writing Symbols, Mini Symbols, Reading Symbols, Symbols
95 SUBSECTION
96         Writing symbols
97
98         Writing of a symbol table is automatic when a BFD open for
99         writing is closed. The application attaches a vector of
100         pointers to pointers to symbols to the BFD being written, and
101         fills in the symbol count. The close and cleanup code reads
102         through the table provided and performs all the necessary
103         operations. The BFD output code must always be provided with an
104         ``owned'' symbol: one which has come from another BFD, or one
105         which has been created using <<bfd_make_empty_symbol>>.  Here is an
106         example showing the creation of a symbol table with only one element:
107
108 |       #include "sysdep.h"
109 |       #include "bfd.h"
110 |       int main (void)
111 |       {
112 |         bfd *abfd;
113 |         asymbol *ptrs[2];
114 |         asymbol *new;
115 |
116 |         abfd = bfd_openw ("foo","a.out-sunos-big");
117 |         bfd_set_format (abfd, bfd_object);
118 |         new = bfd_make_empty_symbol (abfd);
119 |         new->name = "dummy_symbol";
120 |         new->section = bfd_make_section_old_way (abfd, ".text");
121 |         new->flags = BSF_GLOBAL;
122 |         new->value = 0x12345;
123 |
124 |         ptrs[0] = new;
125 |         ptrs[1] = 0;
126 |
127 |         bfd_set_symtab (abfd, ptrs, 1);
128 |         bfd_close (abfd);
129 |         return 0;
130 |       }
131 |
132 |       ./makesym
133 |       nm foo
134 |       00012345 A dummy_symbol
135
136         Many formats cannot represent arbitrary symbol information; for
137         instance, the <<a.out>> object format does not allow an
138         arbitrary number of sections. A symbol pointing to a section
139         which is not one  of <<.text>>, <<.data>> or <<.bss>> cannot
140         be described.
141
142 INODE
143 Mini Symbols, typedef asymbol, Writing Symbols, Symbols
144 SUBSECTION
145         Mini Symbols
146
147         Mini symbols provide read-only access to the symbol table.
148         They use less memory space, but require more time to access.
149         They can be useful for tools like nm or objdump, which may
150         have to handle symbol tables of extremely large executables.
151
152         The <<bfd_read_minisymbols>> function will read the symbols
153         into memory in an internal form.  It will return a <<void *>>
154         pointer to a block of memory, a symbol count, and the size of
155         each symbol.  The pointer is allocated using <<malloc>>, and
156         should be freed by the caller when it is no longer needed.
157
158         The function <<bfd_minisymbol_to_symbol>> will take a pointer
159         to a minisymbol, and a pointer to a structure returned by
160         <<bfd_make_empty_symbol>>, and return a <<asymbol>> structure.
161         The return value may or may not be the same as the value from
162         <<bfd_make_empty_symbol>> which was passed in.
163
164 */
165
166 /*
167 DOCDD
168 INODE
169 typedef asymbol, symbol handling functions, Mini Symbols, Symbols
170
171 */
172 /*
173 SUBSECTION
174         typedef asymbol
175
176         An <<asymbol>> has the form:
177
178 */
179
180 /*
181 CODE_FRAGMENT
182
183 .
184 .typedef struct bfd_symbol
185 .{
186 .  {* A pointer to the BFD which owns the symbol. This information
187 .     is necessary so that a back end can work out what additional
188 .     information (invisible to the application writer) is carried
189 .     with the symbol.
190 .
191 .     This field is *almost* redundant, since you can use section->owner
192 .     instead, except that some symbols point to the global sections
193 .     bfd_{abs,com,und}_section.  This could be fixed by making
194 .     these globals be per-bfd (or per-target-flavor).  FIXME.  *}
195 .  struct bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field.  *}
196 .
197 .  {* The text of the symbol. The name is left alone, and not copied; the
198 .     application may not alter it.  *}
199 .  const char *name;
200 .
201 .  {* The value of the symbol.  This really should be a union of a
202 .     numeric value with a pointer, since some flags indicate that
203 .     a pointer to another symbol is stored here.  *}
204 .  symvalue value;
205 .
206 .  {* Attributes of a symbol.  *}
207 .#define BSF_NO_FLAGS           0x00
208 .
209 .  {* The symbol has local scope; <<static>> in <<C>>. The value
210 .     is the offset into the section of the data.  *}
211 .#define BSF_LOCAL              (1 << 0)
212 .
213 .  {* The symbol has global scope; initialized data in <<C>>. The
214 .     value is the offset into the section of the data.  *}
215 .#define BSF_GLOBAL             (1 << 1)
216 .
217 .  {* The symbol has global scope and is exported. The value is
218 .     the offset into the section of the data.  *}
219 .#define BSF_EXPORT     BSF_GLOBAL {* No real difference.  *}
220 .
221 .  {* A normal C symbol would be one of:
222 .     <<BSF_LOCAL>>, <<BSF_UNDEFINED>> or <<BSF_GLOBAL>>.  *}
223 .
224 .  {* The symbol is a debugging record. The value has an arbitrary
225 .     meaning, unless BSF_DEBUGGING_RELOC is also set.  *}
226 .#define BSF_DEBUGGING          (1 << 2)
227 .
228 .  {* The symbol denotes a function entry point.  Used in ELF,
229 .     perhaps others someday.  *}
230 .#define BSF_FUNCTION           (1 << 3)
231 .
232 .  {* Used by the linker.  *}
233 .#define BSF_KEEP               (1 << 5)
234 .#define BSF_KEEP_G             (1 << 6)
235 .
236 .  {* A weak global symbol, overridable without warnings by
237 .     a regular global symbol of the same name.  *}
238 .#define BSF_WEAK               (1 << 7)
239 .
240 .  {* This symbol was created to point to a section, e.g. ELF's
241 .     STT_SECTION symbols.  *}
242 .#define BSF_SECTION_SYM        (1 << 8)
243 .
244 .  {* The symbol used to be a common symbol, but now it is
245 .     allocated.  *}
246 .#define BSF_OLD_COMMON         (1 << 9)
247 .
248 .  {* In some files the type of a symbol sometimes alters its
249 .     location in an output file - ie in coff a <<ISFCN>> symbol
250 .     which is also <<C_EXT>> symbol appears where it was
251 .     declared and not at the end of a section.  This bit is set
252 .     by the target BFD part to convey this information.  *}
253 .#define BSF_NOT_AT_END         (1 << 10)
254 .
255 .  {* Signal that the symbol is the label of constructor section.  *}
256 .#define BSF_CONSTRUCTOR        (1 << 11)
257 .
258 .  {* Signal that the symbol is a warning symbol.  The name is a
259 .     warning.  The name of the next symbol is the one to warn about;
260 .     if a reference is made to a symbol with the same name as the next
261 .     symbol, a warning is issued by the linker.  *}
262 .#define BSF_WARNING            (1 << 12)
263 .
264 .  {* Signal that the symbol is indirect.  This symbol is an indirect
265 .     pointer to the symbol with the same name as the next symbol.  *}
266 .#define BSF_INDIRECT           (1 << 13)
267 .
268 .  {* BSF_FILE marks symbols that contain a file name.  This is used
269 .     for ELF STT_FILE symbols.  *}
270 .#define BSF_FILE               (1 << 14)
271 .
272 .  {* Symbol is from dynamic linking information.  *}
273 .#define BSF_DYNAMIC            (1 << 15)
274 .
275 .  {* The symbol denotes a data object.  Used in ELF, and perhaps
276 .     others someday.  *}
277 .#define BSF_OBJECT             (1 << 16)
278 .
279 .  {* This symbol is a debugging symbol.  The value is the offset
280 .     into the section of the data.  BSF_DEBUGGING should be set
281 .     as well.  *}
282 .#define BSF_DEBUGGING_RELOC    (1 << 17)
283 .
284 .  {* This symbol is thread local.  Used in ELF.  *}
285 .#define BSF_THREAD_LOCAL       (1 << 18)
286 .
287 .  {* This symbol represents a complex relocation expression,
288 .     with the expression tree serialized in the symbol name.  *}
289 .#define BSF_RELC               (1 << 19)
290 .
291 .  {* This symbol represents a signed complex relocation expression,
292 .     with the expression tree serialized in the symbol name.  *}
293 .#define BSF_SRELC              (1 << 20)
294 .
295 .  {* This symbol was created by bfd_get_synthetic_symtab.  *}
296 .#define BSF_SYNTHETIC          (1 << 21)
297 .
298 .  {* This symbol is an indirect code object.  Unrelated to BSF_INDIRECT.
299 .     The dynamic linker will compute the value of this symbol by
300 .     calling the function that it points to.  BSF_FUNCTION must
301 .     also be also set.  *}
302 .#define BSF_GNU_INDIRECT_FUNCTION (1 << 22)
303 .  {* This symbol is a globally unique data object.  The dynamic linker
304 .     will make sure that in the entire process there is just one symbol
305 .     with this name and type in use.  BSF_OBJECT must also be set.  *}
306 .#define BSF_GNU_UNIQUE         (1 << 23)
307 .
308 .  flagword flags;
309 .
310 .  {* A pointer to the section to which this symbol is
311 .     relative.  This will always be non NULL, there are special
312 .     sections for undefined and absolute symbols.  *}
313 .  struct bfd_section *section;
314 .
315 .  {* Back end special data.  *}
316 .  union
317 .    {
318 .      void *p;
319 .      bfd_vma i;
320 .    }
321 .  udata;
322 .}
323 .asymbol;
324 .
325 */
326
327 #include "sysdep.h"
328 #include "bfd.h"
329 #include "libbfd.h"
330 #include "safe-ctype.h"
331 #include "bfdlink.h"
332 #include "aout/stab_gnu.h"
333
334 /*
335 DOCDD
336 INODE
337 symbol handling functions,  , typedef asymbol, Symbols
338 SUBSECTION
339         Symbol handling functions
340 */
341
342 /*
343 FUNCTION
344         bfd_get_symtab_upper_bound
345
346 DESCRIPTION
347         Return the number of bytes required to store a vector of pointers
348         to <<asymbols>> for all the symbols in the BFD @var{abfd},
349         including a terminal NULL pointer. If there are no symbols in
350         the BFD, then return 0.  If an error occurs, return -1.
351
352 .#define bfd_get_symtab_upper_bound(abfd) \
353 .     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
354 .
355 */
356
357 /*
358 FUNCTION
359         bfd_is_local_label
360
361 SYNOPSIS
362         bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
363
364 DESCRIPTION
365         Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
366         a compiler generated local label, else return FALSE.
367 */
368
369 bfd_boolean
370 bfd_is_local_label (bfd *abfd, asymbol *sym)
371 {
372   /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
373      starts with '.' is local.  This would accidentally catch section names
374      if we didn't reject them here.  */
375   if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0)
376     return FALSE;
377   if (sym->name == NULL)
378     return FALSE;
379   return bfd_is_local_label_name (abfd, sym->name);
380 }
381
382 /*
383 FUNCTION
384         bfd_is_local_label_name
385
386 SYNOPSIS
387         bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
388
389 DESCRIPTION
390         Return TRUE if a symbol with the name @var{name} in the BFD
391         @var{abfd} is a compiler generated local label, else return
392         FALSE.  This just checks whether the name has the form of a
393         local label.
394
395 .#define bfd_is_local_label_name(abfd, name) \
396 .  BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
397 .
398 */
399
400 /*
401 FUNCTION
402         bfd_is_target_special_symbol
403
404 SYNOPSIS
405         bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
406
407 DESCRIPTION
408         Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something
409         special to the particular target represented by the BFD.  Such symbols
410         should normally not be mentioned to the user.
411
412 .#define bfd_is_target_special_symbol(abfd, sym) \
413 .  BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
414 .
415 */
416
417 /*
418 FUNCTION
419         bfd_canonicalize_symtab
420
421 DESCRIPTION
422         Read the symbols from the BFD @var{abfd}, and fills in
423         the vector @var{location} with pointers to the symbols and
424         a trailing NULL.
425         Return the actual number of symbol pointers, not
426         including the NULL.
427
428 .#define bfd_canonicalize_symtab(abfd, location) \
429 .  BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
430 .
431 */
432
433 /*
434 FUNCTION
435         bfd_set_symtab
436
437 SYNOPSIS
438         bfd_boolean bfd_set_symtab
439           (bfd *abfd, asymbol **location, unsigned int count);
440
441 DESCRIPTION
442         Arrange that when the output BFD @var{abfd} is closed,
443         the table @var{location} of @var{count} pointers to symbols
444         will be written.
445 */
446
447 bfd_boolean
448 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
449 {
450   if (abfd->format != bfd_object || bfd_read_p (abfd))
451     {
452       bfd_set_error (bfd_error_invalid_operation);
453       return FALSE;
454     }
455
456   bfd_get_outsymbols (abfd) = location;
457   bfd_get_symcount (abfd) = symcount;
458   return TRUE;
459 }
460
461 /*
462 FUNCTION
463         bfd_print_symbol_vandf
464
465 SYNOPSIS
466         void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
467
468 DESCRIPTION
469         Print the value and flags of the @var{symbol} supplied to the
470         stream @var{file}.
471 */
472 void
473 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
474 {
475   FILE *file = (FILE *) arg;
476
477   flagword type = symbol->flags;
478
479   if (symbol->section != NULL)
480     bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma);
481   else
482     bfd_fprintf_vma (abfd, file, symbol->value);
483
484   /* This presumes that a symbol can not be both BSF_DEBUGGING and
485      BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
486      BSF_OBJECT.  */
487   fprintf (file, " %c%c%c%c%c%c%c",
488            ((type & BSF_LOCAL)
489             ? (type & BSF_GLOBAL) ? '!' : 'l'
490             : (type & BSF_GLOBAL) ? 'g'
491             : (type & BSF_GNU_UNIQUE) ? 'u' : ' '),
492            (type & BSF_WEAK) ? 'w' : ' ',
493            (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
494            (type & BSF_WARNING) ? 'W' : ' ',
495            (type & BSF_INDIRECT) ? 'I' : (type & BSF_GNU_INDIRECT_FUNCTION) ? 'i' : ' ',
496            (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
497            ((type & BSF_FUNCTION)
498             ? 'F'
499             : ((type & BSF_FILE)
500                ? 'f'
501                : ((type & BSF_OBJECT) ? 'O' : ' '))));
502 }
503
504 /*
505 FUNCTION
506         bfd_make_empty_symbol
507
508 DESCRIPTION
509         Create a new <<asymbol>> structure for the BFD @var{abfd}
510         and return a pointer to it.
511
512         This routine is necessary because each back end has private
513         information surrounding the <<asymbol>>. Building your own
514         <<asymbol>> and pointing to it will not create the private
515         information, and will cause problems later on.
516
517 .#define bfd_make_empty_symbol(abfd) \
518 .  BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
519 .
520 */
521
522 /*
523 FUNCTION
524         _bfd_generic_make_empty_symbol
525
526 SYNOPSIS
527         asymbol *_bfd_generic_make_empty_symbol (bfd *);
528
529 DESCRIPTION
530         Create a new <<asymbol>> structure for the BFD @var{abfd}
531         and return a pointer to it.  Used by core file routines,
532         binary back-end and anywhere else where no private info
533         is needed.
534 */
535
536 asymbol *
537 _bfd_generic_make_empty_symbol (bfd *abfd)
538 {
539   bfd_size_type amt = sizeof (asymbol);
540   asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt);
541   if (new_symbol)
542     new_symbol->the_bfd = abfd;
543   return new_symbol;
544 }
545
546 /*
547 FUNCTION
548         bfd_make_debug_symbol
549
550 DESCRIPTION
551         Create a new <<asymbol>> structure for the BFD @var{abfd},
552         to be used as a debugging symbol.  Further details of its use have
553         yet to be worked out.
554
555 .#define bfd_make_debug_symbol(abfd,ptr,size) \
556 .  BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
557 .
558 */
559
560 struct section_to_type
561 {
562   const char *section;
563   char type;
564 };
565
566 /* Map section names to POSIX/BSD single-character symbol types.
567    This table is probably incomplete.  It is sorted for convenience of
568    adding entries.  Since it is so short, a linear search is used.  */
569 static const struct section_to_type stt[] =
570 {
571   {".bss", 'b'},
572   {"code", 't'},                /* MRI .text */
573   {".data", 'd'},
574   {"*DEBUG*", 'N'},
575   {".debug", 'N'},              /* MSVC's .debug (non-standard debug syms) */
576   {".drectve", 'i'},            /* MSVC's .drective section */
577   {".edata", 'e'},              /* MSVC's .edata (export) section */
578   {".fini", 't'},               /* ELF fini section */
579   {".idata", 'i'},              /* MSVC's .idata (import) section */
580   {".init", 't'},               /* ELF init section */
581   {".pdata", 'p'},              /* MSVC's .pdata (stack unwind) section */
582   {".rdata", 'r'},              /* Read only data.  */
583   {".rodata", 'r'},             /* Read only data.  */
584   {".sbss", 's'},               /* Small BSS (uninitialized data).  */
585   {".scommon", 'c'},            /* Small common.  */
586   {".sdata", 'g'},              /* Small initialized data.  */
587   {".text", 't'},
588   {"vars", 'd'},                /* MRI .data */
589   {"zerovars", 'b'},            /* MRI .bss */
590   {0, 0}
591 };
592
593 /* Return the single-character symbol type corresponding to
594    section S, or '?' for an unknown COFF section.
595
596    Check for any leading string which matches, so .text5 returns
597    't' as well as .text */
598
599 static char
600 coff_section_type (const char *s)
601 {
602   const struct section_to_type *t;
603
604   for (t = &stt[0]; t->section; t++)
605     if (!strncmp (s, t->section, strlen (t->section)))
606       return t->type;
607
608   return '?';
609 }
610
611 /* Return the single-character symbol type corresponding to section
612    SECTION, or '?' for an unknown section.  This uses section flags to
613    identify sections.
614
615    FIXME These types are unhandled: c, i, e, p.  If we handled these also,
616    we could perhaps obsolete coff_section_type.  */
617
618 static char
619 decode_section_type (const struct bfd_section *section)
620 {
621   if (section->flags & SEC_CODE)
622     return 't';
623   if (section->flags & SEC_DATA)
624     {
625       if (section->flags & SEC_READONLY)
626         return 'r';
627       else if (section->flags & SEC_SMALL_DATA)
628         return 'g';
629       else
630         return 'd';
631     }
632   if ((section->flags & SEC_HAS_CONTENTS) == 0)
633     {
634       if (section->flags & SEC_SMALL_DATA)
635         return 's';
636       else
637         return 'b';
638     }
639   if (section->flags & SEC_DEBUGGING)
640     return 'N';
641   if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
642     return 'n';
643
644   return '?';
645 }
646
647 /*
648 FUNCTION
649         bfd_decode_symclass
650
651 DESCRIPTION
652         Return a character corresponding to the symbol
653         class of @var{symbol}, or '?' for an unknown class.
654
655 SYNOPSIS
656         int bfd_decode_symclass (asymbol *symbol);
657 */
658 int
659 bfd_decode_symclass (asymbol *symbol)
660 {
661   char c;
662
663   if (symbol->section && bfd_is_com_section (symbol->section))
664     return 'C';
665   if (bfd_is_und_section (symbol->section))
666     {
667       if (symbol->flags & BSF_WEAK)
668         {
669           /* If weak, determine if it's specifically an object
670              or non-object weak.  */
671           if (symbol->flags & BSF_OBJECT)
672             return 'v';
673           else
674             return 'w';
675         }
676       else
677         return 'U';
678     }
679   if (bfd_is_ind_section (symbol->section))
680     return 'I';
681   if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION)
682     return 'i';
683   if (symbol->flags & BSF_WEAK)
684     {
685       /* If weak, determine if it's specifically an object
686          or non-object weak.  */
687       if (symbol->flags & BSF_OBJECT)
688         return 'V';
689       else
690         return 'W';
691     }
692   if (symbol->flags & BSF_GNU_UNIQUE)
693     return 'u';
694   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
695     return '?';
696
697   if (bfd_is_abs_section (symbol->section))
698     c = 'a';
699   else if (symbol->section)
700     {
701       c = coff_section_type (symbol->section->name);
702       if (c == '?')
703         c = decode_section_type (symbol->section);
704     }
705   else
706     return '?';
707   if (symbol->flags & BSF_GLOBAL)
708     c = TOUPPER (c);
709   return c;
710
711   /* We don't have to handle these cases just yet, but we will soon:
712      N_SETV: 'v';
713      N_SETA: 'l';
714      N_SETT: 'x';
715      N_SETD: 'z';
716      N_SETB: 's';
717      N_INDR: 'i';
718      */
719 }
720
721 /*
722 FUNCTION
723         bfd_is_undefined_symclass
724
725 DESCRIPTION
726         Returns non-zero if the class symbol returned by
727         bfd_decode_symclass represents an undefined symbol.
728         Returns zero otherwise.
729
730 SYNOPSIS
731         bfd_boolean bfd_is_undefined_symclass (int symclass);
732 */
733
734 bfd_boolean
735 bfd_is_undefined_symclass (int symclass)
736 {
737   return symclass == 'U' || symclass == 'w' || symclass == 'v';
738 }
739
740 /*
741 FUNCTION
742         bfd_symbol_info
743
744 DESCRIPTION
745         Fill in the basic info about symbol that nm needs.
746         Additional info may be added by the back-ends after
747         calling this function.
748
749 SYNOPSIS
750         void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
751 */
752
753 void
754 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
755 {
756   ret->type = bfd_decode_symclass (symbol);
757
758   if (bfd_is_undefined_symclass (ret->type))
759     ret->value = 0;
760   else
761     ret->value = symbol->value + symbol->section->vma;
762
763   ret->name = symbol->name;
764 }
765
766 /*
767 FUNCTION
768         bfd_copy_private_symbol_data
769
770 SYNOPSIS
771         bfd_boolean bfd_copy_private_symbol_data
772           (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
773
774 DESCRIPTION
775         Copy private symbol information from @var{isym} in the BFD
776         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
777         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
778         returns are:
779
780         o <<bfd_error_no_memory>> -
781         Not enough memory exists to create private data for @var{osec}.
782
783 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
784 .  BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
785 .            (ibfd, isymbol, obfd, osymbol))
786 .
787 */
788
789 /* The generic version of the function which returns mini symbols.
790    This is used when the backend does not provide a more efficient
791    version.  It just uses BFD asymbol structures as mini symbols.  */
792
793 long
794 _bfd_generic_read_minisymbols (bfd *abfd,
795                                bfd_boolean dynamic,
796                                void **minisymsp,
797                                unsigned int *sizep)
798 {
799   long storage;
800   asymbol **syms = NULL;
801   long symcount;
802
803   if (dynamic)
804     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
805   else
806     storage = bfd_get_symtab_upper_bound (abfd);
807   if (storage < 0)
808     goto error_return;
809   if (storage == 0)
810     return 0;
811
812   syms = (asymbol **) bfd_malloc (storage);
813   if (syms == NULL)
814     goto error_return;
815
816   if (dynamic)
817     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
818   else
819     symcount = bfd_canonicalize_symtab (abfd, syms);
820   if (symcount < 0)
821     goto error_return;
822
823   *minisymsp = syms;
824   *sizep = sizeof (asymbol *);
825
826   return symcount;
827
828  error_return:
829   bfd_set_error (bfd_error_no_symbols);
830   if (syms != NULL)
831     free (syms);
832   return -1;
833 }
834
835 /* The generic version of the function which converts a minisymbol to
836    an asymbol.  We don't worry about the sym argument we are passed;
837    we just return the asymbol the minisymbol points to.  */
838
839 asymbol *
840 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
841                                    bfd_boolean dynamic ATTRIBUTE_UNUSED,
842                                    const void *minisym,
843                                    asymbol *sym ATTRIBUTE_UNUSED)
844 {
845   return *(asymbol **) minisym;
846 }
847
848 /* Look through stabs debugging information in .stab and .stabstr
849    sections to find the source file and line closest to a desired
850    location.  This is used by COFF and ELF targets.  It sets *pfound
851    to TRUE if it finds some information.  The *pinfo field is used to
852    pass cached information in and out of this routine; this first time
853    the routine is called for a BFD, *pinfo should be NULL.  The value
854    placed in *pinfo should be saved with the BFD, and passed back each
855    time this function is called.  */
856
857 /* We use a cache by default.  */
858
859 #define ENABLE_CACHING
860
861 /* We keep an array of indexentry structures to record where in the
862    stabs section we should look to find line number information for a
863    particular address.  */
864
865 struct indexentry
866 {
867   bfd_vma val;
868   bfd_byte *stab;
869   bfd_byte *str;
870   char *directory_name;
871   char *file_name;
872   char *function_name;
873 };
874
875 /* Compare two indexentry structures.  This is called via qsort.  */
876
877 static int
878 cmpindexentry (const void *a, const void *b)
879 {
880   const struct indexentry *contestantA = (const struct indexentry *) a;
881   const struct indexentry *contestantB = (const struct indexentry *) b;
882
883   if (contestantA->val < contestantB->val)
884     return -1;
885   else if (contestantA->val > contestantB->val)
886     return 1;
887   else
888     return 0;
889 }
890
891 /* A pointer to this structure is stored in *pinfo.  */
892
893 struct stab_find_info
894 {
895   /* The .stab section.  */
896   asection *stabsec;
897   /* The .stabstr section.  */
898   asection *strsec;
899   /* The contents of the .stab section.  */
900   bfd_byte *stabs;
901   /* The contents of the .stabstr section.  */
902   bfd_byte *strs;
903
904   /* A table that indexes stabs by memory address.  */
905   struct indexentry *indextable;
906   /* The number of entries in indextable.  */
907   int indextablesize;
908
909 #ifdef ENABLE_CACHING
910   /* Cached values to restart quickly.  */
911   struct indexentry *cached_indexentry;
912   bfd_vma cached_offset;
913   bfd_byte *cached_stab;
914   char *cached_file_name;
915 #endif
916
917   /* Saved ptr to malloc'ed filename.  */
918   char *filename;
919 };
920
921 bfd_boolean
922 _bfd_stab_section_find_nearest_line (bfd *abfd,
923                                      asymbol **symbols,
924                                      asection *section,
925                                      bfd_vma offset,
926                                      bfd_boolean *pfound,
927                                      const char **pfilename,
928                                      const char **pfnname,
929                                      unsigned int *pline,
930                                      void **pinfo)
931 {
932   struct stab_find_info *info;
933   bfd_size_type stabsize, strsize;
934   bfd_byte *stab, *str;
935   bfd_byte *nul_fun, *nul_str;
936   bfd_size_type stroff;
937   struct indexentry *indexentry;
938   char *file_name;
939   char *directory_name;
940   bfd_boolean saw_line, saw_func;
941
942   *pfound = FALSE;
943   *pfilename = bfd_get_filename (abfd);
944   *pfnname = NULL;
945   *pline = 0;
946
947   /* Stabs entries use a 12 byte format:
948        4 byte string table index
949        1 byte stab type
950        1 byte stab other field
951        2 byte stab desc field
952        4 byte stab value
953      FIXME: This will have to change for a 64 bit object format.
954
955      The stabs symbols are divided into compilation units.  For the
956      first entry in each unit, the type of 0, the value is the length
957      of the string table for this unit, and the desc field is the
958      number of stabs symbols for this unit.  */
959
960 #define STRDXOFF (0)
961 #define TYPEOFF (4)
962 #define OTHEROFF (5)
963 #define DESCOFF (6)
964 #define VALOFF (8)
965 #define STABSIZE (12)
966
967   info = (struct stab_find_info *) *pinfo;
968   if (info != NULL)
969     {
970       if (info->stabsec == NULL || info->strsec == NULL)
971         {
972           /* No stabs debugging information.  */
973           return TRUE;
974         }
975
976       stabsize = (info->stabsec->rawsize
977                   ? info->stabsec->rawsize
978                   : info->stabsec->size);
979       strsize = (info->strsec->rawsize
980                  ? info->strsec->rawsize
981                  : info->strsec->size);
982     }
983   else
984     {
985       long reloc_size, reloc_count;
986       arelent **reloc_vector;
987       int i;
988       char *function_name;
989       bfd_size_type amt = sizeof *info;
990
991       info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
992       if (info == NULL)
993         return FALSE;
994
995       /* FIXME: When using the linker --split-by-file or
996          --split-by-reloc options, it is possible for the .stab and
997          .stabstr sections to be split.  We should handle that.  */
998
999       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
1000       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
1001
1002       if (info->stabsec == NULL || info->strsec == NULL)
1003         {
1004           /* Try SOM section names.  */
1005           info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$");
1006           info->strsec  = bfd_get_section_by_name (abfd, "$GDB_STRINGS$");
1007
1008           if (info->stabsec == NULL || info->strsec == NULL)
1009             {
1010               /* No stabs debugging information.  Set *pinfo so that we
1011                  can return quickly in the info != NULL case above.  */
1012               *pinfo = info;
1013               return TRUE;
1014             }
1015         }
1016
1017       stabsize = (info->stabsec->rawsize
1018                   ? info->stabsec->rawsize
1019                   : info->stabsec->size);
1020       stabsize = (stabsize / STABSIZE) * STABSIZE;
1021       strsize = (info->strsec->rawsize
1022                  ? info->strsec->rawsize
1023                  : info->strsec->size);
1024
1025       info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
1026       info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
1027       if (info->stabs == NULL || info->strs == NULL)
1028         return FALSE;
1029
1030       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1031                                       0, stabsize)
1032           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1033                                          0, strsize))
1034         return FALSE;
1035
1036       /* If this is a relocatable object file, we have to relocate
1037          the entries in .stab.  This should always be simple 32 bit
1038          relocations against symbols defined in this object file, so
1039          this should be no big deal.  */
1040       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1041       if (reloc_size < 0)
1042         return FALSE;
1043       reloc_vector = (arelent **) bfd_malloc (reloc_size);
1044       if (reloc_vector == NULL && reloc_size != 0)
1045         return FALSE;
1046       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1047                                             symbols);
1048       if (reloc_count < 0)
1049         {
1050           if (reloc_vector != NULL)
1051             free (reloc_vector);
1052           return FALSE;
1053         }
1054       if (reloc_count > 0)
1055         {
1056           arelent **pr;
1057
1058           for (pr = reloc_vector; *pr != NULL; pr++)
1059             {
1060               arelent *r;
1061               unsigned long val;
1062               asymbol *sym;
1063
1064               r = *pr;
1065               /* Ignore R_*_NONE relocs.  */
1066               if (r->howto->dst_mask == 0)
1067                 continue;
1068
1069               if (r->howto->rightshift != 0
1070                   || r->howto->size != 2
1071                   || r->howto->bitsize != 32
1072                   || r->howto->pc_relative
1073                   || r->howto->bitpos != 0
1074                   || r->howto->dst_mask != 0xffffffff)
1075                 {
1076                   (*_bfd_error_handler)
1077                     (_("Unsupported .stab relocation"));
1078                   bfd_set_error (bfd_error_invalid_operation);
1079                   if (reloc_vector != NULL)
1080                     free (reloc_vector);
1081                   return FALSE;
1082                 }
1083
1084               val = bfd_get_32 (abfd, info->stabs + r->address);
1085               val &= r->howto->src_mask;
1086               sym = *r->sym_ptr_ptr;
1087               val += sym->value + sym->section->vma + r->addend;
1088               bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1089             }
1090         }
1091
1092       if (reloc_vector != NULL)
1093         free (reloc_vector);
1094
1095       /* First time through this function, build a table matching
1096          function VM addresses to stabs, then sort based on starting
1097          VM address.  Do this in two passes: once to count how many
1098          table entries we'll need, and a second to actually build the
1099          table.  */
1100
1101       info->indextablesize = 0;
1102       nul_fun = NULL;
1103       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1104         {
1105           if (stab[TYPEOFF] == (bfd_byte) N_SO)
1106             {
1107               /* if we did not see a function def, leave space for one.  */
1108               if (nul_fun != NULL)
1109                 ++info->indextablesize;
1110
1111               /* N_SO with null name indicates EOF */
1112               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1113                 nul_fun = NULL;
1114               else
1115                 {
1116                   nul_fun = stab;
1117
1118                   /* two N_SO's in a row is a filename and directory. Skip */
1119                   if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1120                       && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1121                     stab += STABSIZE;
1122                 }
1123             }
1124           else if (stab[TYPEOFF] == (bfd_byte) N_FUN
1125                    && bfd_get_32 (abfd, stab + STRDXOFF) != 0)
1126             {
1127               nul_fun = NULL;
1128               ++info->indextablesize;
1129             }
1130         }
1131
1132       if (nul_fun != NULL)
1133         ++info->indextablesize;
1134
1135       if (info->indextablesize == 0)
1136         return TRUE;
1137       ++info->indextablesize;
1138
1139       amt = info->indextablesize;
1140       amt *= sizeof (struct indexentry);
1141       info->indextable = (struct indexentry *) bfd_alloc (abfd, amt);
1142       if (info->indextable == NULL)
1143         return FALSE;
1144
1145       file_name = NULL;
1146       directory_name = NULL;
1147       nul_fun = NULL;
1148       stroff = 0;
1149
1150       for (i = 0, stab = info->stabs, nul_str = str = info->strs;
1151            i < info->indextablesize && stab < info->stabs + stabsize;
1152            stab += STABSIZE)
1153         {
1154           switch (stab[TYPEOFF])
1155             {
1156             case 0:
1157               /* This is the first entry in a compilation unit.  */
1158               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1159                 break;
1160               str += stroff;
1161               stroff = bfd_get_32 (abfd, stab + VALOFF);
1162               break;
1163
1164             case N_SO:
1165               /* The main file name.  */
1166
1167               /* The following code creates a new indextable entry with
1168                  a NULL function name if there were no N_FUNs in a file.
1169                  Note that a N_SO without a file name is an EOF and
1170                  there could be 2 N_SO following it with the new filename
1171                  and directory.  */
1172               if (nul_fun != NULL)
1173                 {
1174                   info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1175                   info->indextable[i].stab = nul_fun;
1176                   info->indextable[i].str = nul_str;
1177                   info->indextable[i].directory_name = directory_name;
1178                   info->indextable[i].file_name = file_name;
1179                   info->indextable[i].function_name = NULL;
1180                   ++i;
1181                 }
1182
1183               directory_name = NULL;
1184               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1185               if (file_name == (char *) str)
1186                 {
1187                   file_name = NULL;
1188                   nul_fun = NULL;
1189                 }
1190               else
1191                 {
1192                   nul_fun = stab;
1193                   nul_str = str;
1194                   if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
1195                     file_name = NULL;
1196                   if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1197                       && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1198                     {
1199                       /* Two consecutive N_SOs are a directory and a
1200                          file name.  */
1201                       stab += STABSIZE;
1202                       directory_name = file_name;
1203                       file_name = ((char *) str
1204                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1205                       if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
1206                         file_name = NULL;
1207                     }
1208                 }
1209               break;
1210
1211             case N_SOL:
1212               /* The name of an include file.  */
1213               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1214               /* PR 17512: file: 0c680a1f.  */
1215               /* PR 17512: file: 5da8aec4.  */
1216               if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
1217                 file_name = NULL;
1218               break;
1219
1220             case N_FUN:
1221               /* A function name.  */
1222               function_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1223               if (function_name == (char *) str)
1224                 continue;
1225               if (function_name >= (char *) info->strs + strsize)
1226                 function_name = NULL;
1227
1228               nul_fun = NULL;
1229               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1230               info->indextable[i].stab = stab;
1231               info->indextable[i].str = str;
1232               info->indextable[i].directory_name = directory_name;
1233               info->indextable[i].file_name = file_name;
1234               info->indextable[i].function_name = function_name;
1235               ++i;
1236               break;
1237             }
1238         }
1239
1240       if (nul_fun != NULL)
1241         {
1242           info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1243           info->indextable[i].stab = nul_fun;
1244           info->indextable[i].str = nul_str;
1245           info->indextable[i].directory_name = directory_name;
1246           info->indextable[i].file_name = file_name;
1247           info->indextable[i].function_name = NULL;
1248           ++i;
1249         }
1250
1251       info->indextable[i].val = (bfd_vma) -1;
1252       info->indextable[i].stab = info->stabs + stabsize;
1253       info->indextable[i].str = str;
1254       info->indextable[i].directory_name = NULL;
1255       info->indextable[i].file_name = NULL;
1256       info->indextable[i].function_name = NULL;
1257       ++i;
1258
1259       info->indextablesize = i;
1260       qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1261              cmpindexentry);
1262
1263       *pinfo = info;
1264     }
1265
1266   /* We are passed a section relative offset.  The offsets in the
1267      stabs information are absolute.  */
1268   offset += bfd_get_section_vma (abfd, section);
1269
1270 #ifdef ENABLE_CACHING
1271   if (info->cached_indexentry != NULL
1272       && offset >= info->cached_offset
1273       && offset < (info->cached_indexentry + 1)->val)
1274     {
1275       stab = info->cached_stab;
1276       indexentry = info->cached_indexentry;
1277       file_name = info->cached_file_name;
1278     }
1279   else
1280 #endif
1281     {
1282       long low, high;
1283       long mid = -1;
1284
1285       /* Cache non-existent or invalid.  Do binary search on
1286          indextable.  */
1287       indexentry = NULL;
1288
1289       low = 0;
1290       high = info->indextablesize - 1;
1291       while (low != high)
1292         {
1293           mid = (high + low) / 2;
1294           if (offset >= info->indextable[mid].val
1295               && offset < info->indextable[mid + 1].val)
1296             {
1297               indexentry = &info->indextable[mid];
1298               break;
1299             }
1300
1301           if (info->indextable[mid].val > offset)
1302             high = mid;
1303           else
1304             low = mid + 1;
1305         }
1306
1307       if (indexentry == NULL)
1308         return TRUE;
1309
1310       stab = indexentry->stab + STABSIZE;
1311       file_name = indexentry->file_name;
1312     }
1313
1314   directory_name = indexentry->directory_name;
1315   str = indexentry->str;
1316
1317   saw_line = FALSE;
1318   saw_func = FALSE;
1319   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1320     {
1321       bfd_boolean done;
1322       bfd_vma val;
1323
1324       done = FALSE;
1325
1326       switch (stab[TYPEOFF])
1327         {
1328         case N_SOL:
1329           /* The name of an include file.  */
1330           val = bfd_get_32 (abfd, stab + VALOFF);
1331           if (val <= offset)
1332             {
1333               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1334               if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
1335                 file_name = NULL;
1336               *pline = 0;
1337             }
1338           break;
1339
1340         case N_SLINE:
1341         case N_DSLINE:
1342         case N_BSLINE:
1343           /* A line number.  If the function was specified, then the value
1344              is relative to the start of the function.  Otherwise, the
1345              value is an absolute address.  */
1346           val = ((indexentry->function_name ? indexentry->val : 0)
1347                  + bfd_get_32 (abfd, stab + VALOFF));
1348           /* If this line starts before our desired offset, or if it's
1349              the first line we've been able to find, use it.  The
1350              !saw_line check works around a bug in GCC 2.95.3, which emits
1351              the first N_SLINE late.  */
1352           if (!saw_line || val <= offset)
1353             {
1354               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1355
1356 #ifdef ENABLE_CACHING
1357               info->cached_stab = stab;
1358               info->cached_offset = val;
1359               info->cached_file_name = file_name;
1360               info->cached_indexentry = indexentry;
1361 #endif
1362             }
1363           if (val > offset)
1364             done = TRUE;
1365           saw_line = TRUE;
1366           break;
1367
1368         case N_FUN:
1369         case N_SO:
1370           if (saw_func || saw_line)
1371             done = TRUE;
1372           saw_func = TRUE;
1373           break;
1374         }
1375
1376       if (done)
1377         break;
1378     }
1379
1380   *pfound = TRUE;
1381
1382   if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1383       || directory_name == NULL)
1384     *pfilename = file_name;
1385   else
1386     {
1387       size_t dirlen;
1388
1389       dirlen = strlen (directory_name);
1390       if (info->filename == NULL
1391           || filename_ncmp (info->filename, directory_name, dirlen) != 0
1392           || filename_cmp (info->filename + dirlen, file_name) != 0)
1393         {
1394           size_t len;
1395
1396           /* Don't free info->filename here.  objdump and other
1397              apps keep a copy of a previously returned file name
1398              pointer.  */
1399           len = strlen (file_name) + 1;
1400           info->filename = (char *) bfd_alloc (abfd, dirlen + len);
1401           if (info->filename == NULL)
1402             return FALSE;
1403           memcpy (info->filename, directory_name, dirlen);
1404           memcpy (info->filename + dirlen, file_name, len);
1405         }
1406
1407       *pfilename = info->filename;
1408     }
1409
1410   if (indexentry->function_name != NULL)
1411     {
1412       char *s;
1413
1414       /* This will typically be something like main:F(0,1), so we want
1415          to clobber the colon.  It's OK to change the name, since the
1416          string is in our own local storage anyhow.  */
1417       s = strchr (indexentry->function_name, ':');
1418       if (s != NULL)
1419         *s = '\0';
1420
1421       *pfnname = indexentry->function_name;
1422     }
1423
1424   return TRUE;
1425 }