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