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