Fix an illegal memory access when dumping corrupt x86_64 PE unwind data.
[external/binutils.git] / bfd / syms.c
1 /* Generic symbol-table support for the BFD library.
2    Copyright (C) 1990-2019 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 leading strings which match, followed by a number, '.',
599    or '$' so .text5 matches the .text entry, but .init_array doesn't
600    match the .init entry.  */
601
602 static char
603 coff_section_type (const char *s)
604 {
605   const struct section_to_type *t;
606
607   for (t = &stt[0]; t->section; t++)
608     {
609       size_t len = strlen (t->section);
610       if (strncmp (s, t->section, len) == 0
611           && memchr (".$0123456789", s[len], 13) != 0)
612         return t->type;
613     }
614
615   return '?';
616 }
617
618 /* Return the single-character symbol type corresponding to section
619    SECTION, or '?' for an unknown section.  This uses section flags to
620    identify sections.
621
622    FIXME These types are unhandled: c, i, e, p.  If we handled these also,
623    we could perhaps obsolete coff_section_type.  */
624
625 static char
626 decode_section_type (const struct bfd_section *section)
627 {
628   if (section->flags & SEC_CODE)
629     return 't';
630   if (section->flags & SEC_DATA)
631     {
632       if (section->flags & SEC_READONLY)
633         return 'r';
634       else if (section->flags & SEC_SMALL_DATA)
635         return 'g';
636       else
637         return 'd';
638     }
639   if ((section->flags & SEC_HAS_CONTENTS) == 0)
640     {
641       if (section->flags & SEC_SMALL_DATA)
642         return 's';
643       else
644         return 'b';
645     }
646   if (section->flags & SEC_DEBUGGING)
647     return 'N';
648   if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
649     return 'n';
650
651   return '?';
652 }
653
654 /*
655 FUNCTION
656         bfd_decode_symclass
657
658 DESCRIPTION
659         Return a character corresponding to the symbol
660         class of @var{symbol}, or '?' for an unknown class.
661
662 SYNOPSIS
663         int bfd_decode_symclass (asymbol *symbol);
664 */
665 int
666 bfd_decode_symclass (asymbol *symbol)
667 {
668   char c;
669
670   if (symbol->section && bfd_is_com_section (symbol->section))
671     return 'C';
672   if (bfd_is_und_section (symbol->section))
673     {
674       if (symbol->flags & BSF_WEAK)
675         {
676           /* If weak, determine if it's specifically an object
677              or non-object weak.  */
678           if (symbol->flags & BSF_OBJECT)
679             return 'v';
680           else
681             return 'w';
682         }
683       else
684         return 'U';
685     }
686   if (bfd_is_ind_section (symbol->section))
687     return 'I';
688   if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION)
689     return 'i';
690   if (symbol->flags & BSF_WEAK)
691     {
692       /* If weak, determine if it's specifically an object
693          or non-object weak.  */
694       if (symbol->flags & BSF_OBJECT)
695         return 'V';
696       else
697         return 'W';
698     }
699   if (symbol->flags & BSF_GNU_UNIQUE)
700     return 'u';
701   if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
702     return '?';
703
704   if (bfd_is_abs_section (symbol->section))
705     c = 'a';
706   else if (symbol->section)
707     {
708       c = decode_section_type (symbol->section);
709       if (c == '?')
710         c = coff_section_type (symbol->section->name);
711     }
712   else
713     return '?';
714   if (symbol->flags & BSF_GLOBAL)
715     c = TOUPPER (c);
716   return c;
717
718   /* We don't have to handle these cases just yet, but we will soon:
719      N_SETV: 'v';
720      N_SETA: 'l';
721      N_SETT: 'x';
722      N_SETD: 'z';
723      N_SETB: 's';
724      N_INDR: 'i';
725      */
726 }
727
728 /*
729 FUNCTION
730         bfd_is_undefined_symclass
731
732 DESCRIPTION
733         Returns non-zero if the class symbol returned by
734         bfd_decode_symclass represents an undefined symbol.
735         Returns zero otherwise.
736
737 SYNOPSIS
738         bfd_boolean bfd_is_undefined_symclass (int symclass);
739 */
740
741 bfd_boolean
742 bfd_is_undefined_symclass (int symclass)
743 {
744   return symclass == 'U' || symclass == 'w' || symclass == 'v';
745 }
746
747 /*
748 FUNCTION
749         bfd_symbol_info
750
751 DESCRIPTION
752         Fill in the basic info about symbol that nm needs.
753         Additional info may be added by the back-ends after
754         calling this function.
755
756 SYNOPSIS
757         void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
758 */
759
760 void
761 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
762 {
763   ret->type = bfd_decode_symclass (symbol);
764
765   if (bfd_is_undefined_symclass (ret->type))
766     ret->value = 0;
767   else
768     ret->value = symbol->value + symbol->section->vma;
769
770   ret->name = symbol->name;
771 }
772
773 /*
774 FUNCTION
775         bfd_copy_private_symbol_data
776
777 SYNOPSIS
778         bfd_boolean bfd_copy_private_symbol_data
779           (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
780
781 DESCRIPTION
782         Copy private symbol information from @var{isym} in the BFD
783         @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
784         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
785         returns are:
786
787         o <<bfd_error_no_memory>> -
788         Not enough memory exists to create private data for @var{osec}.
789
790 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
791 .       BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
792 .                 (ibfd, isymbol, obfd, osymbol))
793 .
794 */
795
796 /* The generic version of the function which returns mini symbols.
797    This is used when the backend does not provide a more efficient
798    version.  It just uses BFD asymbol structures as mini symbols.  */
799
800 long
801 _bfd_generic_read_minisymbols (bfd *abfd,
802                                bfd_boolean dynamic,
803                                void **minisymsp,
804                                unsigned int *sizep)
805 {
806   long storage;
807   asymbol **syms = NULL;
808   long symcount;
809
810   if (dynamic)
811     storage = bfd_get_dynamic_symtab_upper_bound (abfd);
812   else
813     storage = bfd_get_symtab_upper_bound (abfd);
814   if (storage < 0)
815     goto error_return;
816   if (storage == 0)
817     return 0;
818
819   syms = (asymbol **) bfd_malloc (storage);
820   if (syms == NULL)
821     goto error_return;
822
823   if (dynamic)
824     symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
825   else
826     symcount = bfd_canonicalize_symtab (abfd, syms);
827   if (symcount < 0)
828     goto error_return;
829
830   if (symcount == 0)
831     /* We return 0 above when storage is 0.  Exit in the same state
832        here, so as to not complicate callers with having to deal with
833        freeing memory for zero symcount.  */
834     free (syms);
835   else
836     {
837       *minisymsp = syms;
838       *sizep = sizeof (asymbol *);
839     }
840   return symcount;
841
842  error_return:
843   bfd_set_error (bfd_error_no_symbols);
844   if (syms != NULL)
845     free (syms);
846   return -1;
847 }
848
849 /* The generic version of the function which converts a minisymbol to
850    an asymbol.  We don't worry about the sym argument we are passed;
851    we just return the asymbol the minisymbol points to.  */
852
853 asymbol *
854 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
855                                    bfd_boolean dynamic ATTRIBUTE_UNUSED,
856                                    const void *minisym,
857                                    asymbol *sym ATTRIBUTE_UNUSED)
858 {
859   return *(asymbol **) minisym;
860 }
861
862 /* Look through stabs debugging information in .stab and .stabstr
863    sections to find the source file and line closest to a desired
864    location.  This is used by COFF and ELF targets.  It sets *pfound
865    to TRUE if it finds some information.  The *pinfo field is used to
866    pass cached information in and out of this routine; this first time
867    the routine is called for a BFD, *pinfo should be NULL.  The value
868    placed in *pinfo should be saved with the BFD, and passed back each
869    time this function is called.  */
870
871 /* We use a cache by default.  */
872
873 #define ENABLE_CACHING
874
875 /* We keep an array of indexentry structures to record where in the
876    stabs section we should look to find line number information for a
877    particular address.  */
878
879 struct indexentry
880 {
881   bfd_vma val;
882   bfd_byte *stab;
883   bfd_byte *str;
884   char *directory_name;
885   char *file_name;
886   char *function_name;
887 };
888
889 /* Compare two indexentry structures.  This is called via qsort.  */
890
891 static int
892 cmpindexentry (const void *a, const void *b)
893 {
894   const struct indexentry *contestantA = (const struct indexentry *) a;
895   const struct indexentry *contestantB = (const struct indexentry *) b;
896
897   if (contestantA->val < contestantB->val)
898     return -1;
899   else if (contestantA->val > contestantB->val)
900     return 1;
901   else
902     return 0;
903 }
904
905 /* A pointer to this structure is stored in *pinfo.  */
906
907 struct stab_find_info
908 {
909   /* The .stab section.  */
910   asection *stabsec;
911   /* The .stabstr section.  */
912   asection *strsec;
913   /* The contents of the .stab section.  */
914   bfd_byte *stabs;
915   /* The contents of the .stabstr section.  */
916   bfd_byte *strs;
917
918   /* A table that indexes stabs by memory address.  */
919   struct indexentry *indextable;
920   /* The number of entries in indextable.  */
921   int indextablesize;
922
923 #ifdef ENABLE_CACHING
924   /* Cached values to restart quickly.  */
925   struct indexentry *cached_indexentry;
926   bfd_vma cached_offset;
927   bfd_byte *cached_stab;
928   char *cached_file_name;
929 #endif
930
931   /* Saved ptr to malloc'ed filename.  */
932   char *filename;
933 };
934
935 bfd_boolean
936 _bfd_stab_section_find_nearest_line (bfd *abfd,
937                                      asymbol **symbols,
938                                      asection *section,
939                                      bfd_vma offset,
940                                      bfd_boolean *pfound,
941                                      const char **pfilename,
942                                      const char **pfnname,
943                                      unsigned int *pline,
944                                      void **pinfo)
945 {
946   struct stab_find_info *info;
947   bfd_size_type stabsize, strsize;
948   bfd_byte *stab, *str;
949   bfd_byte *nul_fun, *nul_str;
950   bfd_size_type stroff;
951   struct indexentry *indexentry;
952   char *file_name;
953   char *directory_name;
954   bfd_boolean saw_line, saw_func;
955
956   *pfound = FALSE;
957   *pfilename = bfd_get_filename (abfd);
958   *pfnname = NULL;
959   *pline = 0;
960
961   /* Stabs entries use a 12 byte format:
962        4 byte string table index
963        1 byte stab type
964        1 byte stab other field
965        2 byte stab desc field
966        4 byte stab value
967      FIXME: This will have to change for a 64 bit object format.
968
969      The stabs symbols are divided into compilation units.  For the
970      first entry in each unit, the type of 0, the value is the length
971      of the string table for this unit, and the desc field is the
972      number of stabs symbols for this unit.  */
973
974 #define STRDXOFF (0)
975 #define TYPEOFF (4)
976 #define OTHEROFF (5)
977 #define DESCOFF (6)
978 #define VALOFF (8)
979 #define STABSIZE (12)
980
981   info = (struct stab_find_info *) *pinfo;
982   if (info != NULL)
983     {
984       if (info->stabsec == NULL || info->strsec == NULL)
985         {
986           /* No stabs debugging information.  */
987           return TRUE;
988         }
989
990       stabsize = (info->stabsec->rawsize
991                   ? info->stabsec->rawsize
992                   : info->stabsec->size);
993       strsize = (info->strsec->rawsize
994                  ? info->strsec->rawsize
995                  : info->strsec->size);
996     }
997   else
998     {
999       long reloc_size, reloc_count;
1000       arelent **reloc_vector;
1001       int i;
1002       char *function_name;
1003       bfd_size_type amt = sizeof *info;
1004
1005       info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
1006       if (info == NULL)
1007         return FALSE;
1008
1009       /* FIXME: When using the linker --split-by-file or
1010          --split-by-reloc options, it is possible for the .stab and
1011          .stabstr sections to be split.  We should handle that.  */
1012
1013       info->stabsec = bfd_get_section_by_name (abfd, ".stab");
1014       info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
1015
1016       if (info->stabsec == NULL || info->strsec == NULL)
1017         {
1018           /* Try SOM section names.  */
1019           info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$");
1020           info->strsec  = bfd_get_section_by_name (abfd, "$GDB_STRINGS$");
1021
1022           if (info->stabsec == NULL || info->strsec == NULL)
1023             {
1024               /* No stabs debugging information.  Set *pinfo so that we
1025                  can return quickly in the info != NULL case above.  */
1026               *pinfo = info;
1027               return TRUE;
1028             }
1029         }
1030
1031       stabsize = (info->stabsec->rawsize
1032                   ? info->stabsec->rawsize
1033                   : info->stabsec->size);
1034       stabsize = (stabsize / STABSIZE) * STABSIZE;
1035       strsize = (info->strsec->rawsize
1036                  ? info->strsec->rawsize
1037                  : info->strsec->size);
1038
1039       info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
1040       info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
1041       if (info->stabs == NULL || info->strs == NULL)
1042         return FALSE;
1043
1044       if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1045                                       0, stabsize)
1046           || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1047                                          0, strsize))
1048         return FALSE;
1049
1050       /* Stab strings ought to be nul terminated.  Ensure the last one
1051          is, to prevent running off the end of the buffer.  */
1052       info->strs[strsize - 1] = 0;
1053
1054       /* If this is a relocatable object file, we have to relocate
1055          the entries in .stab.  This should always be simple 32 bit
1056          relocations against symbols defined in this object file, so
1057          this should be no big deal.  */
1058       reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1059       if (reloc_size < 0)
1060         return FALSE;
1061       reloc_vector = (arelent **) bfd_malloc (reloc_size);
1062       if (reloc_vector == NULL && reloc_size != 0)
1063         return FALSE;
1064       reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1065                                             symbols);
1066       if (reloc_count < 0)
1067         {
1068           if (reloc_vector != NULL)
1069             free (reloc_vector);
1070           return FALSE;
1071         }
1072       if (reloc_count > 0)
1073         {
1074           arelent **pr;
1075
1076           for (pr = reloc_vector; *pr != NULL; pr++)
1077             {
1078               arelent *r;
1079               unsigned long val;
1080               asymbol *sym;
1081
1082               r = *pr;
1083               /* Ignore R_*_NONE relocs.  */
1084               if (r->howto->dst_mask == 0)
1085                 continue;
1086
1087               if (r->howto->rightshift != 0
1088                   || r->howto->size != 2
1089                   || r->howto->bitsize != 32
1090                   || r->howto->pc_relative
1091                   || r->howto->bitpos != 0
1092                   || r->howto->dst_mask != 0xffffffff
1093                   || r->address * bfd_octets_per_byte (abfd) + 4 > stabsize)
1094                 {
1095                   _bfd_error_handler
1096                     (_("unsupported .stab relocation"));
1097                   bfd_set_error (bfd_error_invalid_operation);
1098                   if (reloc_vector != NULL)
1099                     free (reloc_vector);
1100                   return FALSE;
1101                 }
1102
1103               val = bfd_get_32 (abfd, info->stabs
1104                                 + r->address * bfd_octets_per_byte (abfd));
1105               val &= r->howto->src_mask;
1106               sym = *r->sym_ptr_ptr;
1107               val += sym->value + sym->section->vma + r->addend;
1108               bfd_put_32 (abfd, (bfd_vma) val, info->stabs
1109                           + r->address * bfd_octets_per_byte (abfd));
1110             }
1111         }
1112
1113       if (reloc_vector != NULL)
1114         free (reloc_vector);
1115
1116       /* First time through this function, build a table matching
1117          function VM addresses to stabs, then sort based on starting
1118          VM address.  Do this in two passes: once to count how many
1119          table entries we'll need, and a second to actually build the
1120          table.  */
1121
1122       info->indextablesize = 0;
1123       nul_fun = NULL;
1124       for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1125         {
1126           if (stab[TYPEOFF] == (bfd_byte) N_SO)
1127             {
1128               /* if we did not see a function def, leave space for one.  */
1129               if (nul_fun != NULL)
1130                 ++info->indextablesize;
1131
1132               /* N_SO with null name indicates EOF */
1133               if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1134                 nul_fun = NULL;
1135               else
1136                 {
1137                   nul_fun = stab;
1138
1139                   /* two N_SO's in a row is a filename and directory. Skip */
1140                   if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1141                       && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1142                     stab += STABSIZE;
1143                 }
1144             }
1145           else if (stab[TYPEOFF] == (bfd_byte) N_FUN
1146                    && bfd_get_32 (abfd, stab + STRDXOFF) != 0)
1147             {
1148               nul_fun = NULL;
1149               ++info->indextablesize;
1150             }
1151         }
1152
1153       if (nul_fun != NULL)
1154         ++info->indextablesize;
1155
1156       if (info->indextablesize == 0)
1157         return TRUE;
1158       ++info->indextablesize;
1159
1160       amt = info->indextablesize;
1161       amt *= sizeof (struct indexentry);
1162       info->indextable = (struct indexentry *) bfd_alloc (abfd, amt);
1163       if (info->indextable == NULL)
1164         return FALSE;
1165
1166       file_name = NULL;
1167       directory_name = NULL;
1168       nul_fun = NULL;
1169       stroff = 0;
1170
1171       for (i = 0, stab = info->stabs, nul_str = str = info->strs;
1172            i < info->indextablesize && stab < info->stabs + stabsize;
1173            stab += STABSIZE)
1174         {
1175           switch (stab[TYPEOFF])
1176             {
1177             case 0:
1178               /* This is the first entry in a compilation unit.  */
1179               if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1180                 break;
1181               str += stroff;
1182               stroff = bfd_get_32 (abfd, stab + VALOFF);
1183               break;
1184
1185             case N_SO:
1186               /* The main file name.  */
1187
1188               /* The following code creates a new indextable entry with
1189                  a NULL function name if there were no N_FUNs in a file.
1190                  Note that a N_SO without a file name is an EOF and
1191                  there could be 2 N_SO following it with the new filename
1192                  and directory.  */
1193               if (nul_fun != NULL)
1194                 {
1195                   info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1196                   info->indextable[i].stab = nul_fun;
1197                   info->indextable[i].str = nul_str;
1198                   info->indextable[i].directory_name = directory_name;
1199                   info->indextable[i].file_name = file_name;
1200                   info->indextable[i].function_name = NULL;
1201                   ++i;
1202                 }
1203
1204               directory_name = NULL;
1205               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1206               if (file_name == (char *) str)
1207                 {
1208                   file_name = NULL;
1209                   nul_fun = NULL;
1210                 }
1211               else
1212                 {
1213                   nul_fun = stab;
1214                   nul_str = str;
1215                   if (file_name >= (char *) info->strs + strsize
1216                       || file_name < (char *) str)
1217                     file_name = NULL;
1218                   if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1219                       && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1220                     {
1221                       /* Two consecutive N_SOs are a directory and a
1222                          file name.  */
1223                       stab += STABSIZE;
1224                       directory_name = file_name;
1225                       file_name = ((char *) str
1226                                    + bfd_get_32 (abfd, stab + STRDXOFF));
1227                       if (file_name >= (char *) info->strs + strsize
1228                           || file_name < (char *) str)
1229                         file_name = NULL;
1230                     }
1231                 }
1232               break;
1233
1234             case N_SOL:
1235               /* The name of an include file.  */
1236               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1237               /* PR 17512: file: 0c680a1f.  */
1238               /* PR 17512: file: 5da8aec4.  */
1239               if (file_name >= (char *) info->strs + strsize
1240                   || file_name < (char *) str)
1241                 file_name = NULL;
1242               break;
1243
1244             case N_FUN:
1245               /* A function name.  */
1246               function_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1247               if (function_name == (char *) str)
1248                 continue;
1249               if (function_name >= (char *) info->strs + strsize
1250                   || function_name < (char *) str)
1251                 function_name = NULL;
1252
1253               nul_fun = NULL;
1254               info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1255               info->indextable[i].stab = stab;
1256               info->indextable[i].str = str;
1257               info->indextable[i].directory_name = directory_name;
1258               info->indextable[i].file_name = file_name;
1259               info->indextable[i].function_name = function_name;
1260               ++i;
1261               break;
1262             }
1263         }
1264
1265       if (nul_fun != NULL)
1266         {
1267           info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1268           info->indextable[i].stab = nul_fun;
1269           info->indextable[i].str = nul_str;
1270           info->indextable[i].directory_name = directory_name;
1271           info->indextable[i].file_name = file_name;
1272           info->indextable[i].function_name = NULL;
1273           ++i;
1274         }
1275
1276       info->indextable[i].val = (bfd_vma) -1;
1277       info->indextable[i].stab = info->stabs + stabsize;
1278       info->indextable[i].str = str;
1279       info->indextable[i].directory_name = NULL;
1280       info->indextable[i].file_name = NULL;
1281       info->indextable[i].function_name = NULL;
1282       ++i;
1283
1284       info->indextablesize = i;
1285       qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1286              cmpindexentry);
1287
1288       *pinfo = info;
1289     }
1290
1291   /* We are passed a section relative offset.  The offsets in the
1292      stabs information are absolute.  */
1293   offset += bfd_get_section_vma (abfd, section);
1294
1295 #ifdef ENABLE_CACHING
1296   if (info->cached_indexentry != NULL
1297       && offset >= info->cached_offset
1298       && offset < (info->cached_indexentry + 1)->val)
1299     {
1300       stab = info->cached_stab;
1301       indexentry = info->cached_indexentry;
1302       file_name = info->cached_file_name;
1303     }
1304   else
1305 #endif
1306     {
1307       long low, high;
1308       long mid = -1;
1309
1310       /* Cache non-existent or invalid.  Do binary search on
1311          indextable.  */
1312       indexentry = NULL;
1313
1314       low = 0;
1315       high = info->indextablesize - 1;
1316       while (low != high)
1317         {
1318           mid = (high + low) / 2;
1319           if (offset >= info->indextable[mid].val
1320               && offset < info->indextable[mid + 1].val)
1321             {
1322               indexentry = &info->indextable[mid];
1323               break;
1324             }
1325
1326           if (info->indextable[mid].val > offset)
1327             high = mid;
1328           else
1329             low = mid + 1;
1330         }
1331
1332       if (indexentry == NULL)
1333         return TRUE;
1334
1335       stab = indexentry->stab + STABSIZE;
1336       file_name = indexentry->file_name;
1337     }
1338
1339   directory_name = indexentry->directory_name;
1340   str = indexentry->str;
1341
1342   saw_line = FALSE;
1343   saw_func = FALSE;
1344   for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1345     {
1346       bfd_boolean done;
1347       bfd_vma val;
1348
1349       done = FALSE;
1350
1351       switch (stab[TYPEOFF])
1352         {
1353         case N_SOL:
1354           /* The name of an include file.  */
1355           val = bfd_get_32 (abfd, stab + VALOFF);
1356           if (val <= offset)
1357             {
1358               file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1359               if (file_name >= (char *) info->strs + strsize
1360                   || file_name < (char *) str)
1361                 file_name = NULL;
1362               *pline = 0;
1363             }
1364           break;
1365
1366         case N_SLINE:
1367         case N_DSLINE:
1368         case N_BSLINE:
1369           /* A line number.  If the function was specified, then the value
1370              is relative to the start of the function.  Otherwise, the
1371              value is an absolute address.  */
1372           val = ((indexentry->function_name ? indexentry->val : 0)
1373                  + bfd_get_32 (abfd, stab + VALOFF));
1374           /* If this line starts before our desired offset, or if it's
1375              the first line we've been able to find, use it.  The
1376              !saw_line check works around a bug in GCC 2.95.3, which emits
1377              the first N_SLINE late.  */
1378           if (!saw_line || val <= offset)
1379             {
1380               *pline = bfd_get_16 (abfd, stab + DESCOFF);
1381
1382 #ifdef ENABLE_CACHING
1383               info->cached_stab = stab;
1384               info->cached_offset = val;
1385               info->cached_file_name = file_name;
1386               info->cached_indexentry = indexentry;
1387 #endif
1388             }
1389           if (val > offset)
1390             done = TRUE;
1391           saw_line = TRUE;
1392           break;
1393
1394         case N_FUN:
1395         case N_SO:
1396           if (saw_func || saw_line)
1397             done = TRUE;
1398           saw_func = TRUE;
1399           break;
1400         }
1401
1402       if (done)
1403         break;
1404     }
1405
1406   *pfound = TRUE;
1407
1408   if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1409       || directory_name == NULL)
1410     *pfilename = file_name;
1411   else
1412     {
1413       size_t dirlen;
1414
1415       dirlen = strlen (directory_name);
1416       if (info->filename == NULL
1417           || filename_ncmp (info->filename, directory_name, dirlen) != 0
1418           || filename_cmp (info->filename + dirlen, file_name) != 0)
1419         {
1420           size_t len;
1421
1422           /* Don't free info->filename here.  objdump and other
1423              apps keep a copy of a previously returned file name
1424              pointer.  */
1425           len = strlen (file_name) + 1;
1426           info->filename = (char *) bfd_alloc (abfd, dirlen + len);
1427           if (info->filename == NULL)
1428             return FALSE;
1429           memcpy (info->filename, directory_name, dirlen);
1430           memcpy (info->filename + dirlen, file_name, len);
1431         }
1432
1433       *pfilename = info->filename;
1434     }
1435
1436   if (indexentry->function_name != NULL)
1437     {
1438       char *s;
1439
1440       /* This will typically be something like main:F(0,1), so we want
1441          to clobber the colon.  It's OK to change the name, since the
1442          string is in our own local storage anyhow.  */
1443       s = strchr (indexentry->function_name, ':');
1444       if (s != NULL)
1445         *s = '\0';
1446
1447       *pfnname = indexentry->function_name;
1448     }
1449
1450   return TRUE;
1451 }
1452
1453 long
1454 _bfd_nosymbols_canonicalize_symtab (bfd *abfd ATTRIBUTE_UNUSED,
1455                                     asymbol **location ATTRIBUTE_UNUSED)
1456 {
1457   return 0;
1458 }
1459
1460 void
1461 _bfd_nosymbols_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
1462                              void *afile ATTRIBUTE_UNUSED,
1463                              asymbol *symbol ATTRIBUTE_UNUSED,
1464                              bfd_print_symbol_type how ATTRIBUTE_UNUSED)
1465 {
1466 }
1467
1468 void
1469 _bfd_nosymbols_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1470                                 asymbol *sym ATTRIBUTE_UNUSED,
1471                                 symbol_info *ret ATTRIBUTE_UNUSED)
1472 {
1473 }
1474
1475 const char *
1476 _bfd_nosymbols_get_symbol_version_string (bfd *abfd,
1477                                           asymbol *symbol ATTRIBUTE_UNUSED,
1478                                           bfd_boolean *hidden ATTRIBUTE_UNUSED)
1479 {
1480   return (const char *) _bfd_ptr_bfd_null_error (abfd);
1481 }
1482
1483 bfd_boolean
1484 _bfd_nosymbols_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1485                                         const char *name ATTRIBUTE_UNUSED)
1486 {
1487   return FALSE;
1488 }
1489
1490 alent *
1491 _bfd_nosymbols_get_lineno (bfd *abfd, asymbol *sym ATTRIBUTE_UNUSED)
1492 {
1493   return (alent *) _bfd_ptr_bfd_null_error (abfd);
1494 }
1495
1496 bfd_boolean
1497 _bfd_nosymbols_find_nearest_line
1498     (bfd *abfd,
1499      asymbol **symbols ATTRIBUTE_UNUSED,
1500      asection *section ATTRIBUTE_UNUSED,
1501      bfd_vma offset ATTRIBUTE_UNUSED,
1502      const char **filename_ptr ATTRIBUTE_UNUSED,
1503      const char **functionname_ptr ATTRIBUTE_UNUSED,
1504      unsigned int *line_ptr ATTRIBUTE_UNUSED,
1505      unsigned int *discriminator_ptr ATTRIBUTE_UNUSED)
1506 {
1507   return _bfd_bool_bfd_false_error (abfd);
1508 }
1509
1510 bfd_boolean
1511 _bfd_nosymbols_find_line (bfd *abfd,
1512                           asymbol **symbols ATTRIBUTE_UNUSED,
1513                           asymbol *symbol ATTRIBUTE_UNUSED,
1514                           const char **filename_ptr ATTRIBUTE_UNUSED,
1515                           unsigned int *line_ptr ATTRIBUTE_UNUSED)
1516 {
1517   return _bfd_bool_bfd_false_error (abfd);
1518 }
1519
1520 bfd_boolean
1521 _bfd_nosymbols_find_inliner_info
1522     (bfd *abfd,
1523      const char **filename_ptr ATTRIBUTE_UNUSED,
1524      const char **functionname_ptr ATTRIBUTE_UNUSED,
1525      unsigned int *line_ptr ATTRIBUTE_UNUSED)
1526 {
1527   return _bfd_bool_bfd_false_error (abfd);
1528 }
1529
1530 asymbol *
1531 _bfd_nosymbols_bfd_make_debug_symbol (bfd *abfd,
1532                                       void *ptr ATTRIBUTE_UNUSED,
1533                                       unsigned long sz ATTRIBUTE_UNUSED)
1534 {
1535   return (asymbol *) _bfd_ptr_bfd_null_error (abfd);
1536 }
1537
1538 long
1539 _bfd_nosymbols_read_minisymbols (bfd *abfd,
1540                                  bfd_boolean dynamic ATTRIBUTE_UNUSED,
1541                                  void **minisymsp ATTRIBUTE_UNUSED,
1542                                  unsigned int *sizep ATTRIBUTE_UNUSED)
1543 {
1544   return _bfd_long_bfd_n1_error (abfd);
1545 }
1546
1547 asymbol *
1548 _bfd_nosymbols_minisymbol_to_symbol (bfd *abfd,
1549                                      bfd_boolean dynamic ATTRIBUTE_UNUSED,
1550                                      const void *minisym ATTRIBUTE_UNUSED,
1551                                      asymbol *sym ATTRIBUTE_UNUSED)
1552 {
1553   return (asymbol *) _bfd_ptr_bfd_null_error (abfd);
1554 }
1555
1556 long
1557 _bfd_nodynamic_get_synthetic_symtab (bfd *abfd,
1558                                      long symcount ATTRIBUTE_UNUSED,
1559                                      asymbol **syms ATTRIBUTE_UNUSED,
1560                                      long dynsymcount ATTRIBUTE_UNUSED,
1561                                      asymbol **dynsyms ATTRIBUTE_UNUSED,
1562                                      asymbol **ret ATTRIBUTE_UNUSED)
1563 {
1564   return _bfd_long_bfd_n1_error (abfd);
1565 }