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