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