1 /* Generic symbol-table support for the BFD library.
2 Copyright (C) 1990-2024 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 SUBSECTION
172 typedef asymbol
173
174 An <<asymbol>> has the form:
175
176 CODE_FRAGMENT
177 .typedef struct bfd_symbol
178 .{
179 . {* A pointer to the BFD which owns the symbol. This information
180 . is necessary so that a back end can work out what additional
181 . information (invisible to the application writer) is carried
182 . with the symbol.
183 .
184 . This field is *almost* redundant, since you can use section->owner
185 . instead, except that some symbols point to the global sections
186 . bfd_{abs,com,und}_section. This could be fixed by making
187 . these globals be per-bfd (or per-target-flavor). FIXME. *}
188 . struct bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field. *}
189 .
190 . {* The text of the symbol. The name is left alone, and not copied; the
191 . application may not alter it. *}
192 . const char *name;
193 .
194 . {* The value of the symbol. This really should be a union of a
195 . numeric value with a pointer, since some flags indicate that
196 . a pointer to another symbol is stored here. *}
197 . symvalue value;
198 .
199 . {* Attributes of a symbol. *}
200 .#define BSF_NO_FLAGS 0
201 .
202 . {* The symbol has local scope; <<static>> in <<C>>. The value
203 . is the offset into the section of the data. *}
204 .#define BSF_LOCAL (1 << 0)
205 .
206 . {* The symbol has global scope; initialized data in <<C>>. The
207 . value is the offset into the section of the data. *}
208 .#define BSF_GLOBAL (1 << 1)
209 .
210 . {* The symbol has global scope and is exported. The value is
211 . the offset into the section of the data. *}
212 .#define BSF_EXPORT BSF_GLOBAL {* No real difference. *}
213 .
214 . {* A normal C symbol would be one of:
215 . <<BSF_LOCAL>>, <<BSF_UNDEFINED>> or <<BSF_GLOBAL>>. *}
216 .
217 . {* The symbol is a debugging record. The value has an arbitrary
218 . meaning, unless BSF_DEBUGGING_RELOC is also set. *}
219 .#define BSF_DEBUGGING (1 << 2)
220 .
221 . {* The symbol denotes a function entry point. Used in ELF,
222 . perhaps others someday. *}
223 .#define BSF_FUNCTION (1 << 3)
224 .
225 . {* Used by the linker. *}
226 .#define BSF_KEEP (1 << 5)
227 .
228 . {* An ELF common symbol. *}
229 .#define BSF_ELF_COMMON (1 << 6)
230 .
231 . {* A weak global symbol, overridable without warnings by
232 . a regular global symbol of the same name. *}
233 .#define BSF_WEAK (1 << 7)
234 .
235 . {* This symbol was created to point to a section, e.g. ELF's
236 . STT_SECTION symbols. *}
237 .#define BSF_SECTION_SYM (1 << 8)
238 .
239 . {* The symbol used to be a common symbol, but now it is
240 . allocated. *}
241 .#define BSF_OLD_COMMON (1 << 9)
242 .
243 . {* In some files the type of a symbol sometimes alters its
244 . location in an output file - ie in coff a <<ISFCN>> symbol
245 . which is also <<C_EXT>> symbol appears where it was
246 . declared and not at the end of a section. This bit is set
247 . by the target BFD part to convey this information. *}
248 .#define BSF_NOT_AT_END (1 << 10)
249 .
250 . {* Signal that the symbol is the label of constructor section. *}
251 .#define BSF_CONSTRUCTOR (1 << 11)
252 .
253 . {* Signal that the symbol is a warning symbol. The name is a
254 . warning. The name of the next symbol is the one to warn about;
255 . if a reference is made to a symbol with the same name as the next
256 . symbol, a warning is issued by the linker. *}
257 .#define BSF_WARNING (1 << 12)
258 .
259 . {* Signal that the symbol is indirect. This symbol is an indirect
260 . pointer to the symbol with the same name as the next symbol. *}
261 .#define BSF_INDIRECT (1 << 13)
262 .
263 . {* BSF_FILE marks symbols that contain a file name. This is used
264 . for ELF STT_FILE symbols. *}
265 .#define BSF_FILE (1 << 14)
266 .
267 . {* Symbol is from dynamic linking information. *}
268 .#define BSF_DYNAMIC (1 << 15)
269 .
270 . {* The symbol denotes a data object. Used in ELF, and perhaps
271 . others someday. *}
272 .#define BSF_OBJECT (1 << 16)
273 .
274 . {* This symbol is a debugging symbol. The value is the offset
275 . into the section of the data. BSF_DEBUGGING should be set
276 . as well. *}
277 .#define BSF_DEBUGGING_RELOC (1 << 17)
278 .
279 . {* This symbol is thread local. Used in ELF. *}
280 .#define BSF_THREAD_LOCAL (1 << 18)
281 .
282 . {* This symbol represents a complex relocation expression,
283 . with the expression tree serialized in the symbol name. *}
284 .#define BSF_RELC (1 << 19)
285 .
286 . {* This symbol represents a signed complex relocation expression,
287 . with the expression tree serialized in the symbol name. *}
288 .#define BSF_SRELC (1 << 20)
289 .
290 . {* This symbol was created by bfd_get_synthetic_symtab. *}
291 .#define BSF_SYNTHETIC (1 << 21)
292 .
293 . {* This symbol is an indirect code object. Unrelated to BSF_INDIRECT.
294 . The dynamic linker will compute the value of this symbol by
295 . calling the function that it points to. BSF_FUNCTION must
296 . also be also set. *}
297 .#define BSF_GNU_INDIRECT_FUNCTION (1 << 22)
298 . {* This symbol is a globally unique data object. The dynamic linker
299 . will make sure that in the entire process there is just one symbol
300 . with this name and type in use. BSF_OBJECT must also be set. *}
301 .#define BSF_GNU_UNIQUE (1 << 23)
302 .
303 . {* This section symbol should be included in the symbol table. *}
304 .#define BSF_SECTION_SYM_USED (1 << 24)
305 .
306 . flagword flags;
307 .
308 . {* A pointer to the section to which this symbol is
309 . relative. This will always be non NULL, there are special
310 . sections for undefined and absolute symbols. *}
311 . struct bfd_section *section;
312 .
313 . {* Back end special data. *}
314 . union
315 . {
316 . void *p;
317 . bfd_vma i;
318 . }
319 . udata;
320 .}
321 .asymbol;
322 .
323
324 EXTERNAL
325 .typedef enum bfd_print_symbol
326 .{
327 . bfd_print_symbol_name,
328 . bfd_print_symbol_more,
329 . bfd_print_symbol_all
330 .} bfd_print_symbol_type;
331 .
332 .{* Information about a symbol that nm needs. *}
333 .
334 .typedef struct _symbol_info
335 .{
336 . symvalue value;
337 . char type;
338 . const char *name; {* Symbol name. *}
339 . unsigned char stab_type; {* Stab type. *}
340 . char stab_other; {* Stab other. *}
341 . short stab_desc; {* Stab desc. *}
342 . const char *stab_name; {* String for stab type. *}
343 .} symbol_info;
344 .
345 */
346
347 #include "sysdep.h"
348 #include "bfd.h"
349 #include "libbfd.h"
350 #include "safe-ctype.h"
351 #include "bfdlink.h"
352 #include "aout/stab_gnu.h"
353
354 /*
355 DOCDD
356 INODE
357 symbol handling functions, , typedef asymbol, Symbols
358 SUBSECTION
359 Symbol handling functions
360 */
361
362 /*
363 FUNCTION
364 bfd_get_symtab_upper_bound
365
366 DESCRIPTION
367 Return the number of bytes required to store a vector of pointers
368 to <<asymbols>> for all the symbols in the BFD @var{abfd},
369 including a terminal NULL pointer. If there are no symbols in
370 the BFD, then return 0. If an error occurs, return -1.
371
372 .#define bfd_get_symtab_upper_bound(abfd) \
373 . BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
374 .
375 */
376
377 /*
378 FUNCTION
379 bfd_is_local_label
380
381 SYNOPSIS
382 bool bfd_is_local_label (bfd *abfd, asymbol *sym);
383
384 DESCRIPTION
385 Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
386 a compiler generated local label, else return FALSE.
387 */
388
389 bool
bfd_is_local_label(bfd * abfd,asymbol * sym)390 bfd_is_local_label (bfd *abfd, asymbol *sym)
391 {
392 /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
393 starts with '.' is local. This would accidentally catch section names
394 if we didn't reject them here. */
395 if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0)
396 return false;
397 if (sym->name == NULL)
398 return false;
399 return bfd_is_local_label_name (abfd, sym->name);
400 }
401
402 /*
403 FUNCTION
404 bfd_is_local_label_name
405
406 SYNOPSIS
407 bool bfd_is_local_label_name (bfd *abfd, const char *name);
408
409 DESCRIPTION
410 Return TRUE if a symbol with the name @var{name} in the BFD
411 @var{abfd} is a compiler generated local label, else return
412 FALSE. This just checks whether the name has the form of a
413 local label.
414
415 .#define bfd_is_local_label_name(abfd, name) \
416 . BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
417 .
418 */
419
420 /*
421 FUNCTION
422 bfd_is_target_special_symbol
423
424 SYNOPSIS
425 bool bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
426
427 DESCRIPTION
428 Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something
429 special to the particular target represented by the BFD. Such symbols
430 should normally not be mentioned to the user.
431
432 .#define bfd_is_target_special_symbol(abfd, sym) \
433 . BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
434 .
435 */
436
437 /*
438 FUNCTION
439 bfd_canonicalize_symtab
440
441 DESCRIPTION
442 Read the symbols from the BFD @var{abfd}, and fills in
443 the vector @var{location} with pointers to the symbols and
444 a trailing NULL.
445 Return the actual number of symbol pointers, not
446 including the NULL.
447
448 .#define bfd_canonicalize_symtab(abfd, location) \
449 . BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
450 .
451 */
452
453 /*
454 FUNCTION
455 bfd_set_symtab
456
457 SYNOPSIS
458 bool bfd_set_symtab
459 (bfd *abfd, asymbol **location, unsigned int count);
460
461 DESCRIPTION
462 Arrange that when the output BFD @var{abfd} is closed,
463 the table @var{location} of @var{count} pointers to symbols
464 will be written.
465 */
466
467 bool
bfd_set_symtab(bfd * abfd,asymbol ** location,unsigned int symcount)468 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
469 {
470 if (abfd->format != bfd_object || bfd_read_p (abfd))
471 {
472 bfd_set_error (bfd_error_invalid_operation);
473 return false;
474 }
475
476 abfd->outsymbols = location;
477 abfd->symcount = symcount;
478 return true;
479 }
480
481 /*
482 FUNCTION
483 bfd_print_symbol_vandf
484
485 SYNOPSIS
486 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
487
488 DESCRIPTION
489 Print the value and flags of the @var{symbol} supplied to the
490 stream @var{file}.
491 */
492 void
bfd_print_symbol_vandf(bfd * abfd,void * arg,asymbol * symbol)493 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
494 {
495 FILE *file = (FILE *) arg;
496
497 flagword type = symbol->flags;
498
499 if (symbol->section != NULL)
500 bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma);
501 else
502 bfd_fprintf_vma (abfd, file, symbol->value);
503
504 /* This presumes that a symbol can not be both BSF_DEBUGGING and
505 BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
506 BSF_OBJECT. */
507 fprintf (file, " %c%c%c%c%c%c%c",
508 ((type & BSF_LOCAL)
509 ? (type & BSF_GLOBAL) ? '!' : 'l'
510 : (type & BSF_GLOBAL) ? 'g'
511 : (type & BSF_GNU_UNIQUE) ? 'u' : ' '),
512 (type & BSF_WEAK) ? 'w' : ' ',
513 (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
514 (type & BSF_WARNING) ? 'W' : ' ',
515 (type & BSF_INDIRECT) ? 'I' : (type & BSF_GNU_INDIRECT_FUNCTION) ? 'i' : ' ',
516 (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
517 ((type & BSF_FUNCTION)
518 ? 'F'
519 : ((type & BSF_FILE)
520 ? 'f'
521 : ((type & BSF_OBJECT) ? 'O' : ' '))));
522 }
523
524 /*
525 FUNCTION
526 bfd_make_empty_symbol
527
528 DESCRIPTION
529 Create a new <<asymbol>> structure for the BFD @var{abfd}
530 and return a pointer to it.
531
532 This routine is necessary because each back end has private
533 information surrounding the <<asymbol>>. Building your own
534 <<asymbol>> and pointing to it will not create the private
535 information, and will cause problems later on.
536
537 .#define bfd_make_empty_symbol(abfd) \
538 . BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
539 .
540 */
541
542 /*
543 FUNCTION
544 _bfd_generic_make_empty_symbol
545
546 SYNOPSIS
547 asymbol *_bfd_generic_make_empty_symbol (bfd *);
548
549 DESCRIPTION
550 Create a new <<asymbol>> structure for the BFD @var{abfd}
551 and return a pointer to it. Used by core file routines,
552 binary back-end and anywhere else where no private info
553 is needed.
554 */
555
556 asymbol *
_bfd_generic_make_empty_symbol(bfd * abfd)557 _bfd_generic_make_empty_symbol (bfd *abfd)
558 {
559 size_t amt = sizeof (asymbol);
560 asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt);
561 if (new_symbol)
562 new_symbol->the_bfd = abfd;
563 return new_symbol;
564 }
565
566 /*
567 FUNCTION
568 bfd_make_debug_symbol
569
570 DESCRIPTION
571 Create a new <<asymbol>> structure for the BFD @var{abfd},
572 to be used as a debugging symbol.
573
574 .#define bfd_make_debug_symbol(abfd) \
575 . BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd))
576 .
577 */
578
579 struct section_to_type
580 {
581 const char *section;
582 char type;
583 };
584
585 /* Map special section names to POSIX/BSD single-character symbol types.
586 This table is probably incomplete. It is sorted for convenience of
587 adding entries. Since it is so short, a linear search is used. */
588 static const struct section_to_type stt[] =
589 {
590 {".drectve", 'i'}, /* MSVC's .drective section */
591 {".edata", 'e'}, /* MSVC's .edata (export) section */
592 {".idata", 'i'}, /* MSVC's .idata (import) section */
593 {".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */
594 {0, 0}
595 };
596
597 /* Return the single-character symbol type corresponding to
598 section S, or '?' for an unknown COFF section.
599
600 Check for leading strings which match, followed by a number, '.',
601 or '$' so .idata5 matches the .idata entry. */
602
603 static char
coff_section_type(const char * s)604 coff_section_type (const char *s)
605 {
606 const struct section_to_type *t;
607
608 for (t = &stt[0]; t->section; t++)
609 {
610 size_t len = strlen (t->section);
611 if (strncmp (s, t->section, len) == 0
612 && memchr (".$0123456789", s[len], 13) != 0)
613 return t->type;
614 }
615
616 return '?';
617 }
618
619 /* Return the single-character symbol type corresponding to section
620 SECTION, or '?' for an unknown section. This uses section flags to
621 identify sections.
622
623 FIXME These types are unhandled: e, i, p. If we handled these also,
624 we could perhaps obsolete coff_section_type. */
625
626 static char
decode_section_type(const struct bfd_section * section)627 decode_section_type (const struct bfd_section *section)
628 {
629 if (section->flags & SEC_CODE)
630 return 't';
631 if (section->flags & SEC_DATA)
632 {
633 if (section->flags & SEC_READONLY)
634 return 'r';
635 else if (section->flags & SEC_SMALL_DATA)
636 return 'g';
637 else
638 return 'd';
639 }
640 if ((section->flags & SEC_HAS_CONTENTS) == 0)
641 {
642 if (section->flags & SEC_SMALL_DATA)
643 return 's';
644 else
645 return 'b';
646 }
647 if (section->flags & SEC_DEBUGGING)
648 return 'N';
649 if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
650 return 'n';
651
652 return '?';
653 }
654
655 /*
656 FUNCTION
657 bfd_decode_symclass
658
659 SYNOPSIS
660 int bfd_decode_symclass (asymbol *symbol);
661
662 DESCRIPTION
663 Return a character corresponding to the symbol
664 class of @var{symbol}, or '?' for an unknown class.
665 */
666 int
bfd_decode_symclass(asymbol * symbol)667 bfd_decode_symclass (asymbol *symbol)
668 {
669 char c;
670
671 /* Paranoia... */
672 if (symbol == NULL || symbol->section == NULL)
673 return '?';
674
675 if (symbol->section && bfd_is_com_section (symbol->section))
676 {
677 if (symbol->section->flags & SEC_SMALL_DATA)
678 return 'c';
679 else
680 return 'C';
681 }
682 if (bfd_is_und_section (symbol->section))
683 {
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 else
694 return 'U';
695 }
696 if (bfd_is_ind_section (symbol->section))
697 return 'I';
698 if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION)
699 return 'i';
700 if (symbol->flags & BSF_WEAK)
701 {
702 /* If weak, determine if it's specifically an object
703 or non-object weak. */
704 if (symbol->flags & BSF_OBJECT)
705 return 'V';
706 else
707 return 'W';
708 }
709 if (symbol->flags & BSF_GNU_UNIQUE)
710 return 'u';
711 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
712 return '?';
713
714 if (bfd_is_abs_section (symbol->section))
715 c = 'a';
716 else if (symbol->section)
717 {
718 c = coff_section_type (symbol->section->name);
719 if (c == '?')
720 c = decode_section_type (symbol->section);
721 }
722 else
723 return '?';
724 if (symbol->flags & BSF_GLOBAL)
725 c = TOUPPER (c);
726 return c;
727
728 /* We don't have to handle these cases just yet, but we will soon:
729 N_SETV: 'v';
730 N_SETA: 'l';
731 N_SETT: 'x';
732 N_SETD: 'z';
733 N_SETB: 's';
734 N_INDR: 'i';
735 */
736 }
737
738 /*
739 FUNCTION
740 bfd_is_undefined_symclass
741
742 SYNOPSIS
743 bool bfd_is_undefined_symclass (int symclass);
744
745 DESCRIPTION
746 Returns non-zero if the class symbol returned by
747 bfd_decode_symclass represents an undefined symbol.
748 Returns zero otherwise.
749 */
750
751 bool
bfd_is_undefined_symclass(int symclass)752 bfd_is_undefined_symclass (int symclass)
753 {
754 return symclass == 'U' || symclass == 'w' || symclass == 'v';
755 }
756
757 /*
758 FUNCTION
759 bfd_symbol_info
760
761 SYNOPSIS
762 void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
763
764 DESCRIPTION
765 Fill in the basic info about symbol that nm needs.
766 Additional info may be added by the back-ends after
767 calling this function.
768 */
769
770 void
bfd_symbol_info(asymbol * symbol,symbol_info * ret)771 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
772 {
773 ret->type = bfd_decode_symclass (symbol);
774
775 if (bfd_is_undefined_symclass (ret->type))
776 ret->value = 0;
777 else
778 ret->value = symbol->value + symbol->section->vma;
779
780 ret->name = symbol->name;
781 }
782
783 /*
784 FUNCTION
785 bfd_copy_private_symbol_data
786
787 SYNOPSIS
788 bool bfd_copy_private_symbol_data
789 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
790
791 DESCRIPTION
792 Copy private symbol information from @var{isym} in the BFD
793 @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
794 Return <<TRUE>> on success, <<FALSE>> on error. Possible error
795 returns are:
796
797 o <<bfd_error_no_memory>> -
798 Not enough memory exists to create private data for @var{osec}.
799
800 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
801 . BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
802 . (ibfd, isymbol, obfd, osymbol))
803 .
804 */
805
806 /* The generic version of the function which returns mini symbols.
807 This is used when the backend does not provide a more efficient
808 version. It just uses BFD asymbol structures as mini symbols. */
809
810 long
_bfd_generic_read_minisymbols(bfd * abfd,bool dynamic,void ** minisymsp,unsigned int * sizep)811 _bfd_generic_read_minisymbols (bfd *abfd,
812 bool dynamic,
813 void **minisymsp,
814 unsigned int *sizep)
815 {
816 long storage;
817 asymbol **syms = NULL;
818 long symcount;
819
820 if (dynamic)
821 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
822 else
823 storage = bfd_get_symtab_upper_bound (abfd);
824 if (storage < 0)
825 goto error_return;
826 if (storage == 0)
827 return 0;
828
829 syms = (asymbol **) bfd_malloc (storage);
830 if (syms == NULL)
831 goto error_return;
832
833 if (dynamic)
834 symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
835 else
836 symcount = bfd_canonicalize_symtab (abfd, syms);
837 if (symcount < 0)
838 goto error_return;
839
840 if (symcount == 0)
841 /* We return 0 above when storage is 0. Exit in the same state
842 here, so as to not complicate callers with having to deal with
843 freeing memory for zero symcount. */
844 free (syms);
845 else
846 {
847 *minisymsp = syms;
848 *sizep = sizeof (asymbol *);
849 }
850 return symcount;
851
852 error_return:
853 bfd_set_error (bfd_error_no_symbols);
854 free (syms);
855 return -1;
856 }
857
858 /* The generic version of the function which converts a minisymbol to
859 an asymbol. We don't worry about the sym argument we are passed;
860 we just return the asymbol the minisymbol points to. */
861
862 asymbol *
_bfd_generic_minisymbol_to_symbol(bfd * abfd ATTRIBUTE_UNUSED,bool dynamic ATTRIBUTE_UNUSED,const void * minisym,asymbol * sym ATTRIBUTE_UNUSED)863 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
864 bool dynamic ATTRIBUTE_UNUSED,
865 const void *minisym,
866 asymbol *sym ATTRIBUTE_UNUSED)
867 {
868 return *(asymbol **) minisym;
869 }
870
871 /* Look through stabs debugging information in .stab and .stabstr
872 sections to find the source file and line closest to a desired
873 location. This is used by COFF and ELF targets. It sets *pfound
874 to TRUE if it finds some information. The *pinfo field is used to
875 pass cached information in and out of this routine; this first time
876 the routine is called for a BFD, *pinfo should be NULL. The value
877 placed in *pinfo should be saved with the BFD, and passed back each
878 time this function is called. */
879
880 /* We use a cache by default. */
881
882 #define ENABLE_CACHING
883
884 /* We keep an array of indexentry structures to record where in the
885 stabs section we should look to find line number information for a
886 particular address. */
887
888 struct indexentry
889 {
890 bfd_vma val;
891 bfd_byte *stab;
892 bfd_byte *str;
893 char *directory_name;
894 char *file_name;
895 char *function_name;
896 int idx;
897 };
898
899 /* Compare two indexentry structures. This is called via qsort. */
900
901 static int
cmpindexentry(const void * a,const void * b)902 cmpindexentry (const void *a, const void *b)
903 {
904 const struct indexentry *contestantA = (const struct indexentry *) a;
905 const struct indexentry *contestantB = (const struct indexentry *) b;
906
907 if (contestantA->val < contestantB->val)
908 return -1;
909 if (contestantA->val > contestantB->val)
910 return 1;
911 return contestantA->idx - contestantB->idx;
912 }
913
914 /* A pointer to this structure is stored in *pinfo. */
915
916 struct stab_find_info
917 {
918 /* The .stab section. */
919 asection *stabsec;
920 /* The .stabstr section. */
921 asection *strsec;
922 /* The contents of the .stab section. */
923 bfd_byte *stabs;
924 /* The contents of the .stabstr section. */
925 bfd_byte *strs;
926
927 /* A table that indexes stabs by memory address. */
928 struct indexentry *indextable;
929 /* The number of entries in indextable. */
930 int indextablesize;
931
932 #ifdef ENABLE_CACHING
933 /* Cached values to restart quickly. */
934 struct indexentry *cached_indexentry;
935 bfd_vma cached_offset;
936 bfd_byte *cached_stab;
937 char *cached_file_name;
938 #endif
939
940 /* Saved ptr to malloc'ed filename. */
941 char *filename;
942 };
943
944 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)945 _bfd_stab_section_find_nearest_line (bfd *abfd,
946 asymbol **symbols,
947 asection *section,
948 bfd_vma offset,
949 bool *pfound,
950 const char **pfilename,
951 const char **pfnname,
952 unsigned int *pline,
953 void **pinfo)
954 {
955 struct stab_find_info *info;
956 bfd_size_type stabsize, strsize;
957 bfd_byte *stab, *str;
958 bfd_byte *nul_fun, *nul_str;
959 bfd_size_type stroff;
960 struct indexentry *indexentry;
961 char *file_name;
962 char *directory_name;
963 bool saw_line, saw_func;
964
965 *pfound = false;
966 *pfilename = bfd_get_filename (abfd);
967 *pfnname = NULL;
968 *pline = 0;
969
970 /* Stabs entries use a 12 byte format:
971 4 byte string table index
972 1 byte stab type
973 1 byte stab other field
974 2 byte stab desc field
975 4 byte stab value
976 FIXME: This will have to change for a 64 bit object format.
977
978 The stabs symbols are divided into compilation units. For the
979 first entry in each unit, the type of 0, the value is the length
980 of the string table for this unit, and the desc field is the
981 number of stabs symbols for this unit. */
982
983 #define STRDXOFF (0)
984 #define TYPEOFF (4)
985 #define OTHEROFF (5)
986 #define DESCOFF (6)
987 #define VALOFF (8)
988 #define STABSIZE (12)
989
990 info = (struct stab_find_info *) *pinfo;
991 if (info != NULL)
992 {
993 if (info->stabsec == NULL || info->strsec == NULL)
994 {
995 /* No usable stabs debugging information. */
996 return true;
997 }
998
999 stabsize = (info->stabsec->rawsize
1000 ? info->stabsec->rawsize
1001 : info->stabsec->size);
1002 strsize = (info->strsec->rawsize
1003 ? info->strsec->rawsize
1004 : info->strsec->size);
1005 }
1006 else
1007 {
1008 long reloc_size, reloc_count;
1009 arelent **reloc_vector;
1010 int i;
1011 char *function_name;
1012 bfd_size_type amt = sizeof *info;
1013
1014 info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
1015 if (info == NULL)
1016 return false;
1017 *pinfo = info;
1018
1019 /* FIXME: When using the linker --split-by-file or
1020 --split-by-reloc options, it is possible for the .stab and
1021 .stabstr sections to be split. We should handle that. */
1022
1023 info->stabsec = bfd_get_section_by_name (abfd, ".stab");
1024 info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
1025
1026 if (info->stabsec == NULL || info->strsec == NULL)
1027 {
1028 /* Try SOM section names. */
1029 info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$");
1030 info->strsec = bfd_get_section_by_name (abfd, "$GDB_STRINGS$");
1031
1032 if (info->stabsec == NULL || info->strsec == NULL)
1033 return true;
1034 }
1035
1036 if ((info->stabsec->flags & SEC_HAS_CONTENTS) == 0
1037 || (info->strsec->flags & SEC_HAS_CONTENTS) == 0)
1038 goto out;
1039
1040 stabsize = (info->stabsec->rawsize
1041 ? info->stabsec->rawsize
1042 : info->stabsec->size);
1043 stabsize = (stabsize / STABSIZE) * STABSIZE;
1044 strsize = (info->strsec->rawsize
1045 ? info->strsec->rawsize
1046 : info->strsec->size);
1047
1048 if (stabsize == 0 || strsize == 0)
1049 goto out;
1050
1051 if (!bfd_malloc_and_get_section (abfd, info->stabsec, &info->stabs))
1052 goto out;
1053 if (!bfd_malloc_and_get_section (abfd, info->strsec, &info->strs))
1054 goto out1;
1055
1056 /* Stab strings ought to be nul terminated. Ensure the last one
1057 is, to prevent running off the end of the buffer. */
1058 info->strs[strsize - 1] = 0;
1059
1060 /* If this is a relocatable object file, we have to relocate
1061 the entries in .stab. This should always be simple 32 bit
1062 relocations against symbols defined in this object file, so
1063 this should be no big deal. */
1064 reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1065 if (reloc_size < 0)
1066 goto out2;
1067 reloc_vector = (arelent **) bfd_malloc (reloc_size);
1068 if (reloc_vector == NULL && reloc_size != 0)
1069 goto out2;
1070 reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1071 symbols);
1072 if (reloc_count < 0)
1073 {
1074 out3:
1075 free (reloc_vector);
1076 out2:
1077 free (info->strs);
1078 info->strs = NULL;
1079 out1:
1080 free (info->stabs);
1081 info->stabs = NULL;
1082 out:
1083 info->stabsec = NULL;
1084 return false;
1085 }
1086 if (reloc_count > 0)
1087 {
1088 arelent **pr;
1089
1090 for (pr = reloc_vector; *pr != NULL; pr++)
1091 {
1092 arelent *r;
1093 unsigned long val;
1094 asymbol *sym;
1095 bfd_size_type octets;
1096
1097 r = *pr;
1098 /* Ignore R_*_NONE relocs. */
1099 if (r->howto->dst_mask == 0)
1100 continue;
1101
1102 octets = r->address * bfd_octets_per_byte (abfd, NULL);
1103 if (r->howto->rightshift != 0
1104 || bfd_get_reloc_size (r->howto) != 4
1105 || r->howto->bitsize != 32
1106 || r->howto->pc_relative
1107 || r->howto->bitpos != 0
1108 || r->howto->dst_mask != 0xffffffff
1109 || octets > stabsize - 4)
1110 {
1111 _bfd_error_handler
1112 (_("unsupported .stab relocation"));
1113 bfd_set_error (bfd_error_invalid_operation);
1114 goto out3;
1115 }
1116
1117 val = bfd_get_32 (abfd, info->stabs + octets);
1118 val &= r->howto->src_mask;
1119 sym = *r->sym_ptr_ptr;
1120 val += sym->value + sym->section->vma + r->addend;
1121 bfd_put_32 (abfd, (bfd_vma) val, info->stabs + octets);
1122 }
1123 }
1124
1125 free (reloc_vector);
1126
1127 /* First time through this function, build a table matching
1128 function VM addresses to stabs, then sort based on starting
1129 VM address. Do this in two passes: once to count how many
1130 table entries we'll need, and a second to actually build the
1131 table. */
1132
1133 info->indextablesize = 0;
1134 nul_fun = NULL;
1135 for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1136 {
1137 if (stab[TYPEOFF] == (bfd_byte) N_SO)
1138 {
1139 /* if we did not see a function def, leave space for one. */
1140 if (nul_fun != NULL)
1141 ++info->indextablesize;
1142
1143 /* N_SO with null name indicates EOF */
1144 if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1145 nul_fun = NULL;
1146 else
1147 {
1148 nul_fun = stab;
1149
1150 /* two N_SO's in a row is a filename and directory. Skip */
1151 if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1152 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1153 stab += STABSIZE;
1154 }
1155 }
1156 else if (stab[TYPEOFF] == (bfd_byte) N_FUN
1157 && bfd_get_32 (abfd, stab + STRDXOFF) != 0)
1158 {
1159 nul_fun = NULL;
1160 ++info->indextablesize;
1161 }
1162 }
1163
1164 if (nul_fun != NULL)
1165 ++info->indextablesize;
1166
1167 if (info->indextablesize == 0)
1168 {
1169 free (info->strs);
1170 info->strs = NULL;
1171 free (info->stabs);
1172 info->stabs = NULL;
1173 info->stabsec = NULL;
1174 return true;
1175 }
1176 ++info->indextablesize;
1177
1178 amt = info->indextablesize;
1179 amt *= sizeof (struct indexentry);
1180 info->indextable = (struct indexentry *) bfd_malloc (amt);
1181 if (info->indextable == NULL)
1182 goto out3;
1183
1184 file_name = NULL;
1185 directory_name = NULL;
1186 nul_fun = NULL;
1187 stroff = 0;
1188
1189 for (i = 0, stab = info->stabs, nul_str = str = info->strs;
1190 i < info->indextablesize && stab < info->stabs + stabsize;
1191 stab += STABSIZE)
1192 {
1193 switch (stab[TYPEOFF])
1194 {
1195 case 0:
1196 /* This is the first entry in a compilation unit. */
1197 if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1198 break;
1199 str += stroff;
1200 stroff = bfd_get_32 (abfd, stab + VALOFF);
1201 break;
1202
1203 case N_SO:
1204 /* The main file name. */
1205
1206 /* The following code creates a new indextable entry with
1207 a NULL function name if there were no N_FUNs in a file.
1208 Note that a N_SO without a file name is an EOF and
1209 there could be 2 N_SO following it with the new filename
1210 and directory. */
1211 if (nul_fun != NULL)
1212 {
1213 info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1214 info->indextable[i].stab = nul_fun;
1215 info->indextable[i].str = nul_str;
1216 info->indextable[i].directory_name = directory_name;
1217 info->indextable[i].file_name = file_name;
1218 info->indextable[i].function_name = NULL;
1219 info->indextable[i].idx = i;
1220 ++i;
1221 }
1222
1223 directory_name = NULL;
1224 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1225 if (file_name == (char *) str)
1226 {
1227 file_name = NULL;
1228 nul_fun = NULL;
1229 }
1230 else
1231 {
1232 nul_fun = stab;
1233 nul_str = str;
1234 if (file_name >= (char *) info->strs + strsize
1235 || file_name < (char *) str)
1236 file_name = NULL;
1237 if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1238 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1239 {
1240 /* Two consecutive N_SOs are a directory and a
1241 file name. */
1242 stab += STABSIZE;
1243 directory_name = file_name;
1244 file_name = ((char *) str
1245 + bfd_get_32 (abfd, stab + STRDXOFF));
1246 if (file_name >= (char *) info->strs + strsize
1247 || file_name < (char *) str)
1248 file_name = NULL;
1249 }
1250 }
1251 break;
1252
1253 case N_SOL:
1254 /* The name of an include file. */
1255 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1256 /* PR 17512: file: 0c680a1f. */
1257 /* PR 17512: file: 5da8aec4. */
1258 if (file_name >= (char *) info->strs + strsize
1259 || file_name < (char *) str)
1260 file_name = NULL;
1261 break;
1262
1263 case N_FUN:
1264 /* A function name. */
1265 function_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1266 if (function_name == (char *) str)
1267 continue;
1268 if (function_name >= (char *) info->strs + strsize
1269 || function_name < (char *) str)
1270 function_name = NULL;
1271
1272 nul_fun = NULL;
1273 info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1274 info->indextable[i].stab = stab;
1275 info->indextable[i].str = str;
1276 info->indextable[i].directory_name = directory_name;
1277 info->indextable[i].file_name = file_name;
1278 info->indextable[i].function_name = function_name;
1279 info->indextable[i].idx = i;
1280 ++i;
1281 break;
1282 }
1283 }
1284
1285 if (nul_fun != NULL)
1286 {
1287 info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1288 info->indextable[i].stab = nul_fun;
1289 info->indextable[i].str = nul_str;
1290 info->indextable[i].directory_name = directory_name;
1291 info->indextable[i].file_name = file_name;
1292 info->indextable[i].function_name = NULL;
1293 info->indextable[i].idx = i;
1294 ++i;
1295 }
1296
1297 info->indextable[i].val = (bfd_vma) -1;
1298 info->indextable[i].stab = info->stabs + stabsize;
1299 info->indextable[i].str = str;
1300 info->indextable[i].directory_name = NULL;
1301 info->indextable[i].file_name = NULL;
1302 info->indextable[i].function_name = NULL;
1303 info->indextable[i].idx = i;
1304 ++i;
1305
1306 info->indextablesize = i;
1307 qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1308 cmpindexentry);
1309 }
1310
1311 /* We are passed a section relative offset. The offsets in the
1312 stabs information are absolute. */
1313 offset += bfd_section_vma (section);
1314
1315 #ifdef ENABLE_CACHING
1316 if (info->cached_indexentry != NULL
1317 && offset >= info->cached_offset
1318 && offset < (info->cached_indexentry + 1)->val)
1319 {
1320 stab = info->cached_stab;
1321 indexentry = info->cached_indexentry;
1322 file_name = info->cached_file_name;
1323 }
1324 else
1325 #endif
1326 {
1327 long low, high;
1328 long mid = -1;
1329
1330 /* Cache non-existent or invalid. Do binary search on
1331 indextable. */
1332 indexentry = NULL;
1333
1334 low = 0;
1335 high = info->indextablesize - 1;
1336 while (low != high)
1337 {
1338 mid = (high + low) / 2;
1339 if (offset >= info->indextable[mid].val
1340 && offset < info->indextable[mid + 1].val)
1341 {
1342 indexentry = &info->indextable[mid];
1343 break;
1344 }
1345
1346 if (info->indextable[mid].val > offset)
1347 high = mid;
1348 else
1349 low = mid + 1;
1350 }
1351
1352 if (indexentry == NULL)
1353 return true;
1354
1355 stab = indexentry->stab + STABSIZE;
1356 file_name = indexentry->file_name;
1357 }
1358
1359 directory_name = indexentry->directory_name;
1360 str = indexentry->str;
1361
1362 saw_line = false;
1363 saw_func = false;
1364 for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1365 {
1366 bool done;
1367 bfd_vma val;
1368
1369 done = false;
1370
1371 switch (stab[TYPEOFF])
1372 {
1373 case N_SOL:
1374 /* The name of an include file. */
1375 val = bfd_get_32 (abfd, stab + VALOFF);
1376 if (val <= offset)
1377 {
1378 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1379 if (file_name >= (char *) info->strs + strsize
1380 || file_name < (char *) str)
1381 file_name = NULL;
1382 *pline = 0;
1383 }
1384 break;
1385
1386 case N_SLINE:
1387 case N_DSLINE:
1388 case N_BSLINE:
1389 /* A line number. If the function was specified, then the value
1390 is relative to the start of the function. Otherwise, the
1391 value is an absolute address. */
1392 val = ((indexentry->function_name ? indexentry->val : 0)
1393 + bfd_get_32 (abfd, stab + VALOFF));
1394 /* If this line starts before our desired offset, or if it's
1395 the first line we've been able to find, use it. The
1396 !saw_line check works around a bug in GCC 2.95.3, which emits
1397 the first N_SLINE late. */
1398 if (!saw_line || val <= offset)
1399 {
1400 *pline = bfd_get_16 (abfd, stab + DESCOFF);
1401
1402 #ifdef ENABLE_CACHING
1403 info->cached_stab = stab;
1404 info->cached_offset = val;
1405 info->cached_file_name = file_name;
1406 info->cached_indexentry = indexentry;
1407 #endif
1408 }
1409 if (val > offset)
1410 done = true;
1411 saw_line = true;
1412 break;
1413
1414 case N_FUN:
1415 case N_SO:
1416 if (saw_func || saw_line)
1417 done = true;
1418 saw_func = true;
1419 break;
1420 }
1421
1422 if (done)
1423 break;
1424 }
1425
1426 *pfound = true;
1427
1428 if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1429 || directory_name == NULL)
1430 *pfilename = file_name;
1431 else
1432 {
1433 size_t dirlen;
1434
1435 dirlen = strlen (directory_name);
1436 if (info->filename == NULL
1437 || filename_ncmp (info->filename, directory_name, dirlen) != 0
1438 || filename_cmp (info->filename + dirlen, file_name) != 0)
1439 {
1440 size_t len;
1441
1442 /* Don't free info->filename here. objdump and other
1443 apps keep a copy of a previously returned file name
1444 pointer. */
1445 len = strlen (file_name) + 1;
1446 info->filename = (char *) bfd_alloc (abfd, dirlen + len);
1447 if (info->filename == NULL)
1448 return false;
1449 memcpy (info->filename, directory_name, dirlen);
1450 memcpy (info->filename + dirlen, file_name, len);
1451 }
1452
1453 *pfilename = info->filename;
1454 }
1455
1456 if (indexentry->function_name != NULL)
1457 {
1458 char *s;
1459
1460 /* This will typically be something like main:F(0,1), so we want
1461 to clobber the colon. It's OK to change the name, since the
1462 string is in our own local storage anyhow. */
1463 s = strchr (indexentry->function_name, ':');
1464 if (s != NULL)
1465 *s = '\0';
1466
1467 *pfnname = indexentry->function_name;
1468 }
1469
1470 return true;
1471 }
1472
1473 void
_bfd_stab_cleanup(bfd * abfd ATTRIBUTE_UNUSED,void ** pinfo)1474 _bfd_stab_cleanup (bfd *abfd ATTRIBUTE_UNUSED, void **pinfo)
1475 {
1476 struct stab_find_info *info = (struct stab_find_info *) *pinfo;
1477 if (info == NULL)
1478 return;
1479
1480 free (info->indextable);
1481 free (info->strs);
1482 free (info->stabs);
1483 }
1484
1485 long
_bfd_nosymbols_canonicalize_symtab(bfd * abfd ATTRIBUTE_UNUSED,asymbol ** location ATTRIBUTE_UNUSED)1486 _bfd_nosymbols_canonicalize_symtab (bfd *abfd ATTRIBUTE_UNUSED,
1487 asymbol **location ATTRIBUTE_UNUSED)
1488 {
1489 return 0;
1490 }
1491
1492 void
_bfd_nosymbols_print_symbol(bfd * abfd ATTRIBUTE_UNUSED,void * afile ATTRIBUTE_UNUSED,asymbol * symbol ATTRIBUTE_UNUSED,bfd_print_symbol_type how ATTRIBUTE_UNUSED)1493 _bfd_nosymbols_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
1494 void *afile ATTRIBUTE_UNUSED,
1495 asymbol *symbol ATTRIBUTE_UNUSED,
1496 bfd_print_symbol_type how ATTRIBUTE_UNUSED)
1497 {
1498 }
1499
1500 void
_bfd_nosymbols_get_symbol_info(bfd * abfd ATTRIBUTE_UNUSED,asymbol * sym ATTRIBUTE_UNUSED,symbol_info * ret ATTRIBUTE_UNUSED)1501 _bfd_nosymbols_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1502 asymbol *sym ATTRIBUTE_UNUSED,
1503 symbol_info *ret ATTRIBUTE_UNUSED)
1504 {
1505 }
1506
1507 const char *
_bfd_nosymbols_get_symbol_version_string(bfd * abfd,asymbol * symbol ATTRIBUTE_UNUSED,bool base_p ATTRIBUTE_UNUSED,bool * hidden ATTRIBUTE_UNUSED)1508 _bfd_nosymbols_get_symbol_version_string (bfd *abfd,
1509 asymbol *symbol ATTRIBUTE_UNUSED,
1510 bool base_p ATTRIBUTE_UNUSED,
1511 bool *hidden ATTRIBUTE_UNUSED)
1512 {
1513 return (const char *) _bfd_ptr_bfd_null_error (abfd);
1514 }
1515
1516 bool
_bfd_nosymbols_bfd_is_local_label_name(bfd * abfd ATTRIBUTE_UNUSED,const char * name ATTRIBUTE_UNUSED)1517 _bfd_nosymbols_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1518 const char *name ATTRIBUTE_UNUSED)
1519 {
1520 return false;
1521 }
1522
1523 alent *
_bfd_nosymbols_get_lineno(bfd * abfd,asymbol * sym ATTRIBUTE_UNUSED)1524 _bfd_nosymbols_get_lineno (bfd *abfd, asymbol *sym ATTRIBUTE_UNUSED)
1525 {
1526 return (alent *) _bfd_ptr_bfd_null_error (abfd);
1527 }
1528
1529 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)1530 _bfd_nosymbols_find_nearest_line
1531 (bfd *abfd,
1532 asymbol **symbols ATTRIBUTE_UNUSED,
1533 asection *section ATTRIBUTE_UNUSED,
1534 bfd_vma offset ATTRIBUTE_UNUSED,
1535 const char **filename_ptr ATTRIBUTE_UNUSED,
1536 const char **functionname_ptr ATTRIBUTE_UNUSED,
1537 unsigned int *line_ptr ATTRIBUTE_UNUSED,
1538 unsigned int *discriminator_ptr ATTRIBUTE_UNUSED)
1539 {
1540 return _bfd_bool_bfd_false_error (abfd);
1541 }
1542
1543 bool
_bfd_nosymbols_find_nearest_line_with_alt(bfd * abfd,const char * alt_filename ATTRIBUTE_UNUSED,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)1544 _bfd_nosymbols_find_nearest_line_with_alt
1545 (bfd *abfd,
1546 const char *alt_filename ATTRIBUTE_UNUSED,
1547 asymbol **symbols ATTRIBUTE_UNUSED,
1548 asection *section ATTRIBUTE_UNUSED,
1549 bfd_vma offset ATTRIBUTE_UNUSED,
1550 const char **filename_ptr ATTRIBUTE_UNUSED,
1551 const char **functionname_ptr ATTRIBUTE_UNUSED,
1552 unsigned int *line_ptr ATTRIBUTE_UNUSED,
1553 unsigned int *discriminator_ptr ATTRIBUTE_UNUSED)
1554 {
1555 return _bfd_bool_bfd_false_error (abfd);
1556 }
1557
1558 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)1559 _bfd_nosymbols_find_line (bfd *abfd,
1560 asymbol **symbols ATTRIBUTE_UNUSED,
1561 asymbol *symbol ATTRIBUTE_UNUSED,
1562 const char **filename_ptr ATTRIBUTE_UNUSED,
1563 unsigned int *line_ptr ATTRIBUTE_UNUSED)
1564 {
1565 return _bfd_bool_bfd_false_error (abfd);
1566 }
1567
1568 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)1569 _bfd_nosymbols_find_inliner_info
1570 (bfd *abfd,
1571 const char **filename_ptr ATTRIBUTE_UNUSED,
1572 const char **functionname_ptr ATTRIBUTE_UNUSED,
1573 unsigned int *line_ptr ATTRIBUTE_UNUSED)
1574 {
1575 return _bfd_bool_bfd_false_error (abfd);
1576 }
1577
1578 asymbol *
_bfd_nosymbols_bfd_make_debug_symbol(bfd * abfd)1579 _bfd_nosymbols_bfd_make_debug_symbol (bfd *abfd)
1580 {
1581 return (asymbol *) _bfd_ptr_bfd_null_error (abfd);
1582 }
1583
1584 long
_bfd_nosymbols_read_minisymbols(bfd * abfd,bool dynamic ATTRIBUTE_UNUSED,void ** minisymsp ATTRIBUTE_UNUSED,unsigned int * sizep ATTRIBUTE_UNUSED)1585 _bfd_nosymbols_read_minisymbols (bfd *abfd,
1586 bool dynamic ATTRIBUTE_UNUSED,
1587 void **minisymsp ATTRIBUTE_UNUSED,
1588 unsigned int *sizep ATTRIBUTE_UNUSED)
1589 {
1590 return _bfd_long_bfd_n1_error (abfd);
1591 }
1592
1593 asymbol *
_bfd_nosymbols_minisymbol_to_symbol(bfd * abfd,bool dynamic ATTRIBUTE_UNUSED,const void * minisym ATTRIBUTE_UNUSED,asymbol * sym ATTRIBUTE_UNUSED)1594 _bfd_nosymbols_minisymbol_to_symbol (bfd *abfd,
1595 bool dynamic ATTRIBUTE_UNUSED,
1596 const void *minisym ATTRIBUTE_UNUSED,
1597 asymbol *sym ATTRIBUTE_UNUSED)
1598 {
1599 return (asymbol *) _bfd_ptr_bfd_null_error (abfd);
1600 }
1601
1602 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)1603 _bfd_nodynamic_get_synthetic_symtab (bfd *abfd,
1604 long symcount ATTRIBUTE_UNUSED,
1605 asymbol **syms ATTRIBUTE_UNUSED,
1606 long dynsymcount ATTRIBUTE_UNUSED,
1607 asymbol **dynsyms ATTRIBUTE_UNUSED,
1608 asymbol **ret ATTRIBUTE_UNUSED)
1609 {
1610 return _bfd_long_bfd_n1_error (abfd);
1611 }
1612