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