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